Java tutorial
/** * Copyright 2010-present Facebook. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.facebook.model; import android.test.AndroidTestCase; import android.test.suitebuilder.annotation.LargeTest; import android.test.suitebuilder.annotation.MediumTest; import android.test.suitebuilder.annotation.SmallTest; import com.facebook.FacebookGraphObjectException; import junit.framework.Assert; import org.json.JSONArray; import org.json.JSONException; import org.json.JSONObject; import java.util.*; import java.util.Map.Entry; public final class GraphObjectFactoryTests extends AndroidTestCase { @SmallTest @MediumTest @LargeTest public void testCreateEmptyGraphObject() { GraphObject graphObject = GraphObject.Factory.create(); assertTrue(graphObject != null); } @SmallTest @MediumTest @LargeTest public void testCanTreatAsMap() { GraphObject graphObject = GraphObject.Factory.create(); graphObject.setProperty("hello", "world"); assertEquals("world", (String) graphObject.asMap().get("hello")); } @SmallTest @MediumTest @LargeTest public void testCanTreatAsGraphPlace() { GraphPlace graphPlace = GraphObject.Factory.create(GraphPlace.class); graphPlace.setName("hello"); assertEquals("hello", graphPlace.getName()); } @SmallTest @MediumTest @LargeTest public void testCanTreatAsGraphUser() { GraphUser graphUser = GraphObject.Factory.create(GraphUser.class); graphUser.setFirstName("Michael"); assertEquals("Michael", graphUser.getFirstName()); assertEquals("Michael", graphUser.getProperty("first_name")); assertEquals("Michael", graphUser.asMap().get("first_name")); graphUser.setProperty("last_name", "Scott"); assertEquals("Scott", graphUser.getProperty("last_name")); assertEquals("Scott", graphUser.getLastName()); assertEquals("Scott", graphUser.asMap().get("last_name")); } @SmallTest @MediumTest @LargeTest public void testCanCastBetweenGraphObjectTypes() { GraphObject graphObject = GraphObject.Factory.create(); graphObject.setProperty("first_name", "Mickey"); GraphUser graphUser = graphObject.cast(GraphUser.class); assertTrue(graphUser != null); // Should see the name we set earlier as a GraphObject. assertEquals("Mickey", graphUser.getFirstName()); // Changes to GraphUser should be reflected in GraphObject version. graphUser.setLastName("Mouse"); assertEquals("Mouse", graphObject.getProperty("last_name")); } interface Base extends GraphObject { } interface Derived extends Base { } @SmallTest @MediumTest @LargeTest public void testCastingToSameTypeGivesSameObject() { Base base = GraphObject.Factory.create(Base.class); Base cast = base.cast(Base.class); assertTrue(base == cast); } @SmallTest @MediumTest @LargeTest public void testCastingToBaseTypeGivesSameObject() { Derived derived = GraphObject.Factory.create(Derived.class); Base cast = derived.cast(Base.class); assertTrue(derived == cast); cast = cast.cast(Derived.class); assertTrue(derived == cast); } @SmallTest @MediumTest @LargeTest public void testCanSetComplexTypes() { GraphLocation graphLocation = GraphObject.Factory.create(GraphLocation.class); graphLocation.setCity("Seattle"); GraphPlace graphPlace = GraphObject.Factory.create(GraphPlace.class); graphPlace.setLocation(graphLocation); assertEquals(graphLocation, graphPlace.getLocation()); assertEquals("Seattle", graphPlace.getLocation().getCity()); } @SmallTest @MediumTest @LargeTest public void testCanConvertFromJSON() throws JSONException { JSONObject jsonLocation = new JSONObject(); jsonLocation.put("city", "Paris"); jsonLocation.put("country", "France"); JSONObject jsonPlace = new JSONObject(); jsonPlace.put("location", jsonLocation); jsonPlace.put("name", "Eiffel Tower"); GraphPlace graphPlace = GraphObject.Factory.create(jsonPlace, GraphPlace.class); GraphLocation graphLocation = graphPlace.getLocation(); assertEquals("Paris", graphLocation.getCity()); } @SmallTest @MediumTest @LargeTest public void testCanConvertFromGraphObject() throws JSONException { GraphObject graphObject = GraphObject.Factory.create(); graphObject.setProperty("city", "Paris"); graphObject.setProperty("country", "France"); JSONObject jsonPlace = new JSONObject(); jsonPlace.put("location", graphObject); jsonPlace.put("name", "Eiffel Tower"); GraphPlace graphPlace = GraphObject.Factory.create(jsonPlace, GraphPlace.class); GraphLocation graphLocation = graphPlace.getLocation(); assertEquals("Paris", graphLocation.getCity()); } private abstract class GraphObjectClass implements GraphObject { } @SmallTest @MediumTest @LargeTest public void testCanConvertNumbers() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("double_as_string", 3.14159); jsonObject.put("int_as_string", 42); GraphMetric metric = GraphObject.Factory.create(jsonObject, GraphMetric.class); assertEquals("42", metric.getIntAsString()); assertNotNull(metric.getDoubleAsString()); assertTrue(metric.getDoubleAsString().startsWith("3.14159")); } private interface GraphMetric extends GraphObject { String getIntAsString(); String getDoubleAsString(); } @SmallTest @MediumTest @LargeTest public void testCantWrapNonInterface() { try { GraphObject.Factory.create(GraphObjectClass.class); fail("Expected exception"); } catch (FacebookGraphObjectException exception) { } } private interface BadNoParameterMethodNameGraphObject extends GraphObject { Object floppityFlee(); } @SmallTest @MediumTest @LargeTest public void testCantWrapBadZeroParameterMethodName() { try { GraphObject.Factory.create(BadNoParameterMethodNameGraphObject.class); fail("Expected exception"); } catch (FacebookGraphObjectException exception) { } } private interface BadSingleParameterMethodNameGraphObject extends GraphObject { void floppityFlee(Object obj); } @SmallTest @MediumTest @LargeTest public void testCantWrapBadSingleParameterMethodName() { try { GraphObject.Factory.create(BadSingleParameterMethodNameGraphObject.class); fail("Expected exception"); } catch (FacebookGraphObjectException exception) { } } private interface BadGetterNameGraphObject extends GraphObject { void get(); } @SmallTest @MediumTest @LargeTest public void testCantWrapBadGetterName() { try { GraphObject.Factory.create(BadGetterNameGraphObject.class); fail("Expected exception"); } catch (FacebookGraphObjectException exception) { } } private interface BadGetterParamsGraphObject extends GraphObject { Object getFoo(Object obj); } @SmallTest @MediumTest @LargeTest public void testCantWrapBadGetterParams() { try { GraphObject.Factory.create(BadGetterParamsGraphObject.class); fail("Expected exception"); } catch (FacebookGraphObjectException exception) { } } private interface BadGetterReturnTypeGraphObject extends GraphObject { void getFoo(); } @SmallTest @MediumTest @LargeTest public void testCantWrapBadGetterReturnType() { try { GraphObject.Factory.create(BadGetterReturnTypeGraphObject.class); fail("Expected exception"); } catch (FacebookGraphObjectException exception) { } } private interface BadSetterNameGraphObject extends GraphObject { void set(); } @SmallTest @MediumTest @LargeTest public void testCantWrapBadSetterName() { try { GraphObject.Factory.create(BadSetterNameGraphObject.class); fail("Expected exception"); } catch (FacebookGraphObjectException exception) { } } private interface BadSetterParamsGraphObject extends GraphObject { void setFoo(); } @SmallTest @MediumTest @LargeTest public void testCantWrapBadSetterParams() { try { GraphObject.Factory.create(BadSetterParamsGraphObject.class); fail("Expected exception"); } catch (FacebookGraphObjectException exception) { } } private interface BadSetterReturnTypeGraphObject extends GraphObject { Object setFoo(Object obj); } @SmallTest @MediumTest @LargeTest public void testCantWrapBadSetterReturnType() { try { GraphObject.Factory.create(BadSetterReturnTypeGraphObject.class); fail("Expected exception"); } catch (FacebookGraphObjectException exception) { } } private interface BadBaseInterfaceGraphObject extends BadSetterReturnTypeGraphObject { void setBar(Object obj); Object getBar(); } @SmallTest @MediumTest @LargeTest public void testCantWrapBadBaseInterface() { try { GraphObject.Factory.create(BadBaseInterfaceGraphObject.class); fail("Expected exception"); } catch (FacebookGraphObjectException exception) { } } private interface GoodPropertyOverrideInterfaceGraphObject extends GraphObject { void setDefaultName(String s); // No annotation to ensure that the right property is being set. String getAnotherDefaultName(); @PropertyName("another_default_name") void putSomething(String s); @PropertyName("default_name") String retrieveSomething(); @PropertyName("MixedCase") void setMixedCase(String s); @PropertyName("MixedCase") String getMixedCase(); } @SmallTest @MediumTest @LargeTest public void testCanOverrideGraphPropertyNames() { GoodPropertyOverrideInterfaceGraphObject graphObject = GraphObject.Factory .create(GoodPropertyOverrideInterfaceGraphObject.class); String testValue = "flu-blah"; graphObject.setDefaultName(testValue); Assert.assertEquals(testValue, graphObject.retrieveSomething()); testValue = testValue + "1"; graphObject.putSomething(testValue); Assert.assertEquals(testValue, graphObject.getAnotherDefaultName()); testValue = testValue + "2"; graphObject.setMixedCase(testValue); Assert.assertEquals(testValue, graphObject.getMixedCase()); } private interface BadPropertyOverrideInterfaceGraphObject extends GraphObject { @PropertyName("") void setMissingProperty(Object value); } @SmallTest @MediumTest @LargeTest public void testCantWrapBadPropertyNameOverrides() { try { GraphObject.Factory.create(BadPropertyOverrideInterfaceGraphObject.class); fail("Expected exception"); } catch (FacebookGraphObjectException exception) { } } @SmallTest @MediumTest @LargeTest public void testObjectEquals() { GraphObject graphObject = GraphObject.Factory.create(); graphObject.setProperty("aKey", "aValue"); assertTrue(graphObject.equals(graphObject)); GraphPlace graphPlace = graphObject.cast(GraphPlace.class); assertTrue(graphObject.equals(graphPlace)); assertTrue(graphPlace.equals(graphObject)); GraphObject aDifferentGraphObject = GraphObject.Factory.create(); aDifferentGraphObject.setProperty("aKey", "aDifferentValue"); assertFalse(graphObject.equals(aDifferentGraphObject)); } @SmallTest @MediumTest @LargeTest public void testGetProperty() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("hello", "world"); jsonObject.put("hocus", "pocus"); GraphObject graphObject = GraphObject.Factory.create(jsonObject); assertEquals("world", graphObject.getProperty("hello")); assertTrue(graphObject.getProperty("fred") == null); } @SmallTest @MediumTest @LargeTest public void testSetProperty() throws JSONException { JSONObject jsonObject = new JSONObject(); GraphObject graphObject = GraphObject.Factory.create(jsonObject); graphObject.setProperty("hello", "world"); graphObject.setProperty("don't imagine", "purple elephants"); assertEquals("world", jsonObject.getString("hello")); assertEquals("purple elephants", jsonObject.getString("don't imagine")); } @SmallTest @MediumTest @LargeTest public void testSetPropertyWithGraphObject() throws JSONException { JSONObject jsonObject = new JSONObject(); GraphObject graphObject = GraphObject.Factory.create(jsonObject); GraphObject nestedObject = GraphObject.Factory.create(); graphObject.setProperty("foo", nestedObject); JSONObject nestedJsonObject = jsonObject.getJSONObject("foo"); assertNotNull(nestedJsonObject); } @SmallTest @MediumTest @LargeTest public void testSetPropertyWithGraphObjectList() throws JSONException { JSONObject jsonObject = new JSONObject(); GraphObject graphObject = GraphObject.Factory.create(jsonObject); GraphObjectList<GraphObject> nestedList = GraphObject.Factory.createList(GraphObject.class); graphObject.setProperty("foo", nestedList); JSONArray nestedJsonArray = jsonObject.getJSONArray("foo"); assertNotNull(nestedJsonArray); } @SmallTest @MediumTest @LargeTest public void testSetPropertyWithList() throws JSONException { JSONObject jsonObject = new JSONObject(); GraphObject graphObject = GraphObject.Factory.create(jsonObject); List<GraphObject> nestedList = new ArrayList<GraphObject>(); graphObject.setProperty("foo", nestedList); JSONArray nestedJsonArray = jsonObject.getJSONArray("foo"); assertNotNull(nestedJsonArray); } @SmallTest @MediumTest @LargeTest public void testRemoveProperty() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("whirled", "peas"); GraphObject graphObject = GraphObject.Factory.create(jsonObject); graphObject.setProperty("hello", "world"); graphObject.setProperty("don't imagine", "purple elephants"); assertEquals("world", jsonObject.getString("hello")); assertEquals("purple elephants", jsonObject.getString("don't imagine")); } @SmallTest @MediumTest @LargeTest public void testMapClear() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("hello", "world"); GraphObject graphObject = GraphObject.Factory.create(jsonObject); assertEquals(1, jsonObject.length()); graphObject.asMap().clear(); assertEquals(0, jsonObject.length()); } @SmallTest @MediumTest @LargeTest public void testMapContainsKey() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("hello", "world"); GraphObject graphObject = GraphObject.Factory.create(jsonObject); assertTrue(graphObject.asMap().containsKey("hello")); assertFalse(graphObject.asMap().containsKey("hocus")); } @SmallTest @MediumTest @LargeTest public void testMapContainsValue() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("hello", "world"); GraphObject graphObject = GraphObject.Factory.create(jsonObject); assertTrue(graphObject.asMap().containsValue("world")); assertFalse(graphObject.asMap().containsValue("pocus")); } @SmallTest @MediumTest @LargeTest public void testMapEntrySet() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("hello", "world"); jsonObject.put("hocus", "pocus"); GraphObject graphObject = GraphObject.Factory.create(jsonObject); Set<Entry<String, Object>> entrySet = graphObject.asMap().entrySet(); assertEquals(2, entrySet.size()); } @SmallTest @MediumTest @LargeTest public void testMapGet() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("hello", "world"); jsonObject.put("hocus", "pocus"); GraphObject graphObject = GraphObject.Factory.create(jsonObject); assertEquals("world", graphObject.asMap().get("hello")); assertTrue(graphObject.getProperty("fred") == null); } @SmallTest @MediumTest @LargeTest public void testMapGetReturnsNullForMissingProperty() throws JSONException { GraphUser graphUser = GraphObject.Factory.create(GraphUser.class); assertNull(graphUser.getBirthday()); } @SmallTest @MediumTest @LargeTest public void testMapIsEmpty() throws JSONException { JSONObject jsonObject = new JSONObject(); GraphObject graphObject = GraphObject.Factory.create(jsonObject); assertTrue(graphObject.asMap().isEmpty()); jsonObject.put("hello", "world"); jsonObject.put("hocus", "pocus"); assertFalse(graphObject.asMap().isEmpty()); } @SmallTest @MediumTest @LargeTest public void testMapKeySet() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("hello", "world"); jsonObject.put("hocus", "pocus"); GraphObject graphObject = GraphObject.Factory.create(jsonObject); Set<String> keySet = graphObject.asMap().keySet(); assertEquals(2, keySet.size()); assertTrue(keySet.contains("hello")); assertTrue(keySet.contains("hocus")); assertFalse(keySet.contains("world")); } @SmallTest @MediumTest @LargeTest public void testMapPut() throws JSONException { JSONObject jsonObject = new JSONObject(); GraphObject graphObject = GraphObject.Factory.create(jsonObject); graphObject.setProperty("hello", "world"); graphObject.setProperty("hocus", "pocus"); assertEquals("pocus", jsonObject.get("hocus")); assertEquals(2, jsonObject.length()); } @SmallTest @MediumTest @LargeTest public void testMapPutOfWrapperPutsJSONObject() throws JSONException { JSONObject jsonObject = new JSONObject(); GraphObject graphObject = GraphObject.Factory.create(jsonObject); graphObject.setProperty("hello", "world"); graphObject.setProperty("hocus", "pocus"); GraphObject parentObject = GraphObject.Factory.create(); parentObject.setProperty("key", graphObject); JSONObject jsonParent = parentObject.getInnerJSONObject(); Object obj = jsonParent.opt("key"); assertNotNull(obj); assertEquals(jsonObject, obj); } @SmallTest @MediumTest @LargeTest public void testMapPutOfWrapperPutsJSONArray() throws JSONException { JSONArray jsonArray = new JSONArray(); GraphObjectList<String> graphObjectList = GraphObject.Factory.createList(jsonArray, String.class); graphObjectList.add("hello"); graphObjectList.add("world"); GraphObject parentObject = GraphObject.Factory.create(); parentObject.setProperty("key", graphObjectList); JSONObject jsonParent = parentObject.getInnerJSONObject(); Object obj = jsonParent.opt("key"); assertNotNull(obj); assertEquals(jsonArray, obj); } @SmallTest @MediumTest @LargeTest public void testMapPutAll() throws JSONException { HashMap<String, Object> map = new HashMap<String, Object>(); map.put("hello", "world"); map.put("hocus", "pocus"); JSONObject jsonObject = new JSONObject(); GraphObject graphObject = GraphObject.Factory.create(jsonObject); graphObject.asMap().putAll(map); assertEquals("pocus", jsonObject.get("hocus")); assertEquals(2, jsonObject.length()); } @SmallTest @MediumTest @LargeTest public void testMapRemove() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("hello", "world"); jsonObject.put("hocus", "pocus"); GraphObject graphObject = GraphObject.Factory.create(jsonObject); graphObject.removeProperty("hello"); assertEquals(1, jsonObject.length()); } @SmallTest @MediumTest @LargeTest public void testMapSize() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("hello", "world"); jsonObject.put("hocus", "pocus"); GraphObject graphObject = GraphObject.Factory.create(jsonObject); assertEquals(2, graphObject.asMap().size()); } @SmallTest @MediumTest @LargeTest public void testMapValues() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("hello", "world"); jsonObject.put("hocus", "pocus"); GraphObject graphObject = GraphObject.Factory.create(jsonObject); Collection<Object> values = graphObject.asMap().values(); assertEquals(2, values.size()); assertTrue(values.contains("world")); } @SmallTest @MediumTest @LargeTest public void testGetInnerJSONObject() throws JSONException { JSONObject jsonObject = new JSONObject(); jsonObject.put("hello", "world"); jsonObject.put("hocus", "pocus"); GraphObject graphObject = GraphObject.Factory.create(jsonObject); assertEquals(jsonObject, graphObject.getInnerJSONObject()); } @SmallTest @MediumTest @LargeTest public void testSettingGraphObjectProxyStoresJSONObject() throws JSONException { GraphPlace graphPlace = GraphObject.Factory.create(GraphPlace.class); GraphLocation graphLocation = GraphObject.Factory.create(GraphLocation.class); graphPlace.setLocation(graphLocation); assertEquals(graphLocation.getInnerJSONObject(), graphPlace.getInnerJSONObject().get("location")); } private interface DateGraphObject extends GraphObject { Date getDate1(); Date getDate2(); Date getDate3(); Date getDate4(); void setDate4(Date date); } @SmallTest @MediumTest @LargeTest public void testGetStringsAsDates() { DateGraphObject dates = GraphObject.Factory.create(DateGraphObject.class); dates.setProperty("date1", "2012-07-04"); dates.setProperty("date2", "2012-07-04T19:30:50"); dates.setProperty("date3", "2012-07-04T19:20:40-0400"); // Dates without a time zone should be assumed to be in the current timezone. Calendar cal = new GregorianCalendar(); cal.set(Calendar.MILLISECOND, 0); cal.set(2012, 6, 4, 0, 0, 0); Date expectedDate1 = cal.getTime(); Date date1 = dates.getDate1(); assertEquals(expectedDate1, date1); cal.set(2012, 6, 4, 19, 30, 50); Date expectedDate2 = cal.getTime(); Date date2 = dates.getDate2(); assertEquals(expectedDate2, date2); // Dates with an explicit time zone should take that timezone into account. cal = new GregorianCalendar(TimeZone.getTimeZone("GMT")); cal.set(Calendar.MILLISECOND, 0); cal.set(2012, 6, 4, 23, 20, 40); Date expectedDate3 = cal.getTime(); Date date3 = dates.getDate3(); assertEquals(expectedDate3, date3); cal.set(2012, 9, 28, 9, 53, 0); Date expectedDate4 = cal.getTime(); dates.setDate4(expectedDate4); Date date4 = dates.getDate4(); assertEquals(expectedDate4, date4); } @SmallTest @MediumTest @LargeTest public void testCollectionAdd() throws JSONException { JSONArray array = new JSONArray(); Collection<Integer> collection = GraphObject.Factory.createList(array, Integer.class); collection.add(5); assertTrue(array.length() == 1); assertTrue(array.optInt(0) == 5); } @SmallTest @MediumTest @LargeTest public void testCollectionAddAll() throws JSONException { JSONArray array = new JSONArray(); Collection<Integer> collectionToAdd = Arrays.asList(5, -1); Collection<Integer> collection = GraphObject.Factory.createList(array, Integer.class); collection.addAll(collectionToAdd); assertTrue(array.length() == 2); assertTrue(array.optInt(0) == 5); assertTrue(array.optInt(1) == -1); } @SmallTest @MediumTest @LargeTest public void testCollectionContains() throws JSONException { JSONArray array = new JSONArray(); array.put(5); Collection<Integer> collection = GraphObject.Factory.createList(array, Integer.class); assertTrue(collection.contains(5)); assertFalse(collection.contains(6)); } @SmallTest @MediumTest @LargeTest public void testCollectionContainsAll() throws JSONException { JSONArray array = new JSONArray(); array.put(5); array.put(-1); Collection<Integer> collection = GraphObject.Factory.createList(array, Integer.class); assertTrue(collection.containsAll(Arrays.asList(5))); assertTrue(collection.containsAll(Arrays.asList(5, -1))); assertFalse(collection.containsAll(Arrays.asList(5, -1, 2))); } @SmallTest @MediumTest @LargeTest public void testCollectionIsEmpty() throws JSONException { JSONArray array = new JSONArray(); Collection<Integer> collection = GraphObject.Factory.createList(array, Integer.class); assertTrue(collection.isEmpty()); array.put(5); assertFalse(collection.isEmpty()); } @SmallTest @MediumTest @LargeTest public void testCollectionIterator() throws JSONException { JSONArray array = new JSONArray(); array.put(5); array.put(-1); Collection<Integer> collection = GraphObject.Factory.createList(array, Integer.class); Iterator<Integer> iter = collection.iterator(); assertTrue(iter.hasNext()); assertTrue(iter.next() == 5); assertTrue(iter.hasNext()); assertTrue(iter.next() == -1); assertFalse(iter.hasNext()); for (Integer i : collection) { assertNotSame(0, i); } } @SmallTest @MediumTest @LargeTest public void testCollectionIteratorOfGraphObject() throws JSONException { Collection<GraphLocation> collection = GraphObject.Factory.createList(GraphLocation.class); GraphLocation seattle = GraphObject.Factory.create(GraphLocation.class); seattle.setCity("Seattle"); collection.add(seattle); GraphLocation paris = GraphObject.Factory.create(GraphLocation.class); paris.setCity("Paris"); collection.add(paris); Iterator<GraphLocation> iter = collection.iterator(); assertTrue(iter.hasNext()); assertEquals(seattle, iter.next()); assertTrue(iter.hasNext()); assertEquals(paris, iter.next()); assertFalse(iter.hasNext()); for (GraphLocation location : collection) { assertTrue(location != null); } } @SmallTest @MediumTest @LargeTest public void testCollectionSize() throws JSONException { JSONArray array = new JSONArray(); Collection<Integer> collection = GraphObject.Factory.createList(array, Integer.class); assertEquals(0, collection.size()); array.put(5); assertEquals(1, collection.size()); } @SmallTest @MediumTest @LargeTest public void testCollectionClearThrows() throws JSONException { try { Collection<Integer> collection = GraphObject.Factory.createList(Integer.class); collection.clear(); fail("Expected exception"); } catch (UnsupportedOperationException exception) { } } @SmallTest @MediumTest @LargeTest public void testCollectionRemoveThrows() throws JSONException { try { Collection<Integer> collection = GraphObject.Factory.createList(Integer.class); collection.remove(5); fail("Expected exception"); } catch (UnsupportedOperationException exception) { } } @SmallTest @MediumTest @LargeTest public void testCollectionRemoveAllThrows() throws JSONException { try { Collection<Integer> collection = GraphObject.Factory.createList(Integer.class); collection.removeAll(Arrays.asList()); fail("Expected exception"); } catch (UnsupportedOperationException exception) { } } @SmallTest @MediumTest @LargeTest public void testCollectionRetainAllThrows() throws JSONException { try { Collection<Integer> collection = GraphObject.Factory.createList(Integer.class); collection.retainAll(Arrays.asList()); fail("Expected exception"); } catch (UnsupportedOperationException exception) { } } private interface Locations extends GraphObject { Collection<GraphLocation> getLocations(); } @SmallTest @MediumTest @LargeTest public void testObjectWrapsJSONCollection() throws JSONException { JSONObject jsonLocation = new JSONObject(); jsonLocation.put("city", "Seattle"); JSONArray jsonArray = new JSONArray(); jsonArray.put(jsonLocation); JSONObject jsonLocations = new JSONObject(); jsonLocations.put("locations", jsonArray); Locations locations = GraphObject.Factory.create(jsonLocations, Locations.class); Collection<GraphLocation> locationsGraphObjectCollection = locations.getLocations(); assertTrue(locationsGraphObjectCollection != null); GraphLocation graphLocation = locationsGraphObjectCollection.iterator().next(); assertTrue(graphLocation != null); assertEquals("Seattle", graphLocation.getCity()); } @SmallTest @MediumTest @LargeTest public void testObjectWrapsIterable() throws JSONException { GraphUser user = GraphObject.Factory.create(GraphUser.class); user.setFirstName("Foo"); user.setLastName("Bar"); List<GraphUser> users = new ArrayList<GraphUser>(); users.add(user); OpenGraphAction action = GraphObject.Factory.create(OpenGraphAction.class); action.setTags(users); String json = action.getInnerJSONObject().toString(); assertTrue("JSON string should contain last_name", json.contains("last_name")); Object tags = action.getInnerJSONObject().get("tags"); assertNotNull("tags should not be null", tags); assertTrue("tags should be JSONArray", tags instanceof JSONArray); List<GraphObject> retrievedUsers = action.getTags(); assertEquals("Size should be 1", 1, retrievedUsers.size()); GraphUser retrievedUser = retrievedUsers.get(0).cast(GraphUser.class); assertEquals("First name should be Foo", "Foo", retrievedUser.getFirstName()); assertEquals("Last name should be Bar", "Bar", retrievedUser.getLastName()); } @SmallTest @MediumTest @LargeTest public void testCollectionWrapsJSONObject() throws JSONException { JSONObject jsonLocation = new JSONObject(); jsonLocation.put("city", "Seattle"); JSONArray jsonArray = new JSONArray(); jsonArray.put(jsonLocation); Collection<GraphLocation> locationsGraphObjectCollection = GraphObject.Factory.createList(jsonArray, GraphLocation.class); assertTrue(locationsGraphObjectCollection != null); GraphLocation graphLocation = locationsGraphObjectCollection.iterator().next(); assertTrue(graphLocation != null); assertEquals("Seattle", graphLocation.getCity()); } @SmallTest @MediumTest @LargeTest public void testCannotCastCollectionOfNonGraphObjects() throws JSONException { try { GraphObjectList<Integer> collection = GraphObject.Factory.createList(Integer.class); collection.castToListOf(GraphLocation.class); fail("Expected exception"); } catch (FacebookGraphObjectException exception) { } } @SmallTest @MediumTest @LargeTest public void testCanCastCollectionOfGraphObjects() throws JSONException { JSONObject jsonSeattle = new JSONObject(); jsonSeattle.put("city", "Seattle"); JSONArray jsonArray = new JSONArray(); jsonArray.put(jsonSeattle); GraphObjectList<GraphObject> collection = GraphObject.Factory.createList(jsonArray, GraphObject.class); GraphObjectList<GraphLocation> locationCollection = collection.castToListOf(GraphLocation.class); assertTrue(locationCollection != null); GraphLocation seattle = locationCollection.iterator().next(); assertTrue(seattle != null); assertEquals("Seattle", seattle.getCity()); } @SmallTest @MediumTest @LargeTest public void testCastingCollectionToSameTypeGivesSameObject() { GraphObjectList<Base> base = GraphObject.Factory.createList(Base.class); GraphObjectList<Base> cast = base.castToListOf(Base.class); assertTrue(base == cast); } @SmallTest @MediumTest @LargeTest public void testCastingCollectionToBaseTypeGivesSameObject() { GraphObjectList<Derived> derived = GraphObject.Factory.createList(Derived.class); GraphObjectList<Base> cast = derived.castToListOf(Base.class); assertTrue((GraphObjectList<?>) derived == (GraphObjectList<?>) cast); } @SmallTest @MediumTest @LargeTest public void testCanGetInnerJSONArray() throws JSONException { JSONArray jsonArray = new JSONArray(); GraphObjectList<GraphObject> collection = GraphObject.Factory.createList(jsonArray, GraphObject.class); assertEquals(jsonArray, collection.getInnerJSONArray()); } @SmallTest @MediumTest @LargeTest public void testCanGetRandomAccess() throws JSONException { JSONArray jsonArray = new JSONArray(); jsonArray.put("Seattle"); jsonArray.put("Menlo Park"); GraphObjectList<String> collection = GraphObject.Factory.createList(jsonArray, String.class); assertEquals("Menlo Park", collection.get(1)); } @SmallTest @MediumTest @LargeTest public void testCanSetRandomAccess() throws JSONException { JSONArray jsonArray = new JSONArray(); GraphObjectList<String> collection = GraphObject.Factory.createList(jsonArray, String.class); collection.add("Seattle"); collection.add("Menlo Park"); collection.set(1, "Ann Arbor"); assertEquals("Ann Arbor", collection.get(1)); } @SmallTest @MediumTest @LargeTest public void testCollectionPutOfWrapperPutsJSONObject() throws JSONException { JSONObject jsonObject = new JSONObject(); GraphObject graphObject = GraphObject.Factory.create(jsonObject); graphObject.setProperty("hello", "world"); graphObject.setProperty("hocus", "pocus"); GraphObjectList<GraphObject> parentList = GraphObject.Factory.createList(GraphObject.class); parentList.add(graphObject); JSONArray jsonArray = parentList.getInnerJSONArray(); Object obj = jsonArray.opt(0); assertNotNull(obj); assertEquals(jsonObject, obj); parentList.set(0, graphObject); obj = jsonArray.opt(0); assertNotNull(obj); assertEquals(jsonObject, obj); } @SmallTest @MediumTest @LargeTest public void testCamelCaseToLowercase() { assertEquals("hello_world", GraphObject.Factory.convertCamelCaseToLowercaseWithUnderscores("HelloWorld")); assertEquals("hello_world", GraphObject.Factory.convertCamelCaseToLowercaseWithUnderscores("helloWorld")); } interface NestedObject extends GraphObject { String getId(); void setId(String id); String getUrl(); void setUrl(String url); } interface ObjectWithNestedObject extends GraphObject { // Single-object version NestedObject getNestedObject(); void setNestedObject(NestedObject nestedObject); @PropertyName("nested_object") @CreateGraphObject("id") void setNestedObjectById(String id); @PropertyName("nested_object") @CreateGraphObject("url") void setNestedObjectByUrl(String url); // Test overloaded name @CreateGraphObject("id") void setNestedObject(String id); // List version GraphObjectList<NestedObject> getNestedObjects(); void setNestedObjects(List<NestedObject> nestedObjects); @PropertyName("nested_objects") @CreateGraphObject("id") void setNestedObjectsById(List<String> id); @PropertyName("nested_objects") @CreateGraphObject("url") void setNestedObjectsByUrl(List<String> url); } @SmallTest @MediumTest @LargeTest public void testGetPropertyAs() throws JSONException { JSONObject nestedObject = new JSONObject(); nestedObject.put("id", "55"); GraphObject containingObject = GraphObject.Factory.create(); containingObject.setProperty("nested", nestedObject); NestedObject nestedGraphObject = containingObject.getPropertyAs("nested", NestedObject.class); assertNotNull(nestedGraphObject); assertEquals("55", nestedGraphObject.getId()); } @SmallTest @MediumTest @LargeTest public void testGetPropertyAsList() throws JSONException { JSONObject nestedObject = new JSONObject(); nestedObject.put("id", "55"); JSONArray nestedArray = new JSONArray(Arrays.asList(new JSONObject[] { nestedObject })); GraphObject containingObject = GraphObject.Factory.create(); containingObject.setProperty("nested", nestedArray); GraphObjectList<NestedObject> nestedGraphObjects = containingObject.getPropertyAsList("nested", NestedObject.class); assertNotNull(nestedGraphObjects); assertEquals("55", nestedGraphObjects.get(0).getId()); } @SmallTest @MediumTest @LargeTest public void testSetNestedObject() { ObjectWithNestedObject object = GraphObject.Factory.create(ObjectWithNestedObject.class); object.setNestedObjectById("77"); NestedObject nestedObject = object.getNestedObject(); assertNotNull(nestedObject); assertEquals("77", nestedObject.getId()); object.setNestedObjectByUrl("http://www.example.com"); nestedObject = object.getNestedObject(); assertNotNull(nestedObject); assertEquals("http://www.example.com", nestedObject.getUrl()); // Overloaded method object.setNestedObject("77"); nestedObject = object.getNestedObject(); assertNotNull(nestedObject); assertEquals("77", nestedObject.getId()); } @SmallTest @MediumTest @LargeTest public void testSetNestedObjects() { ObjectWithNestedObject object = GraphObject.Factory.create(ObjectWithNestedObject.class); object.setNestedObjectsById(Arrays.asList("77", "88")); GraphObjectList<NestedObject> nestedObjects = object.getNestedObjects(); assertNotNull(nestedObjects); assertEquals("77", nestedObjects.get(0).getId()); assertEquals("88", nestedObjects.get(1).getId()); object.setNestedObjectsByUrl(Arrays.asList("http://www.example.com/1", "http://www.example.com/2")); nestedObjects = object.getNestedObjects(); assertNotNull(nestedObjects); assertEquals("http://www.example.com/1", nestedObjects.get(0).getUrl()); assertEquals("http://www.example.com/2", nestedObjects.get(1).getUrl()); } interface GraphObjectWithPrimitives extends GraphObject { boolean getBoolean(); void setBoolean(boolean value); int getInt(); void setInt(int value); char getChar(); void setChar(char value); } @SmallTest @MediumTest @LargeTest public void testSetBooleanProperty() { GraphObjectWithPrimitives graphObject = GraphObject.Factory.create(GraphObjectWithPrimitives.class); graphObject.setBoolean(true); assertEquals(true, graphObject.getBoolean()); } @SmallTest @MediumTest @LargeTest public void testBooleanPropertyDefaultsToFalse() { GraphObjectWithPrimitives graphObject = GraphObject.Factory.create(GraphObjectWithPrimitives.class); assertEquals(false, graphObject.getBoolean()); } @SmallTest @MediumTest @LargeTest public void testSetNumericProperty() { GraphObjectWithPrimitives graphObject = GraphObject.Factory.create(GraphObjectWithPrimitives.class); graphObject.setInt(5); assertEquals(5, graphObject.getInt()); } @SmallTest @MediumTest @LargeTest public void testNumericPropertyDefaultsToZero() { GraphObjectWithPrimitives graphObject = GraphObject.Factory.create(GraphObjectWithPrimitives.class); assertEquals(0, graphObject.getInt()); } @SmallTest @MediumTest @LargeTest public void testSetCharProperty() { GraphObjectWithPrimitives graphObject = GraphObject.Factory.create(GraphObjectWithPrimitives.class); graphObject.setChar('z'); assertEquals('z', graphObject.getChar()); } @SmallTest @MediumTest @LargeTest public void testCharPropertyDefaultsToZero() { GraphObjectWithPrimitives graphObject = GraphObject.Factory.create(GraphObjectWithPrimitives.class); assertEquals(0, graphObject.getChar()); } }