You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@stanbol.apache.org by og...@apache.org on 2011/05/16 12:15:31 UTC
svn commit: r1103672 [2/2] - in
/incubator/stanbol/trunk/entityhub/generic/test/src/main/java/org/apache/stanbol/entityhub/test:
Utils.java model/RepresentationTest.java model/ValueFactoryTest.java
yard/YardTest.java
Modified: incubator/stanbol/trunk/entityhub/generic/test/src/main/java/org/apache/stanbol/entityhub/test/yard/YardTest.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/entityhub/generic/test/src/main/java/org/apache/stanbol/entityhub/test/yard/YardTest.java?rev=1103672&r1=1103671&r2=1103672&view=diff
==============================================================================
--- incubator/stanbol/trunk/entityhub/generic/test/src/main/java/org/apache/stanbol/entityhub/test/yard/YardTest.java (original)
+++ incubator/stanbol/trunk/entityhub/generic/test/src/main/java/org/apache/stanbol/entityhub/test/yard/YardTest.java Mon May 16 10:15:31 2011
@@ -34,196 +34,203 @@ import org.apache.stanbol.entityhub.serv
import org.apache.stanbol.entityhub.servicesapi.yard.YardException;
import org.junit.Test;
-
public abstract class YardTest {
-
+
/**
* Getter for the {@link Yard} instance to be tested
+ *
* @return the {@link Yard} instance to be tested
*/
protected abstract Yard getYard();
-
+
/**
- * Stores all the IDs of Representations created by the create(..) methods.
- * This collection is used to clean up the store after all the unit tests
- * are executed.
+ * Stores all the IDs of Representations created by the create(..) methods. This collection is used to
+ * clean up the store after all the unit tests are executed.
*/
protected static Collection<String> representationIds = new HashSet<String>();
-
- protected Representation create() throws YardException{
+
+ protected Representation create() throws YardException {
Representation r = getYard().create();
representationIds.add(r.getId());
return r;
}
-
- protected Representation create(String id,boolean store) throws YardException{
+
+ protected Representation create(String id, boolean store) throws YardException {
Representation r;
- if(store){
+ if (store) {
r = getYard().create(id);
- } else if(id != null && !id.isEmpty()){
- r = getYard().getValueFactory().createRepresentation(id);
+ } else if (id != null && !id.isEmpty()) {
+ r = getYard().getValueFactory().createRepresentation(id);
} else {
throw new IllegalArgumentException("If store is FALSE the id MUST NOT be NULL nor EMPTY!");
}
representationIds.add(r.getId());
return r;
}
-
+
@Test
public void testGetValueFactory() {
assertNotNull("The ValueFactory MUST NOT be NULL", getYard().getValueFactory());
}
+
@Test
- public void testGetQueryFactory(){
- assertNotNull("The QueryFactory MUST NOT be NULL",getYard().getQueryFactory());
+ public void testGetQueryFactory() {
+ assertNotNull("The QueryFactory MUST NOT be NULL", getYard().getQueryFactory());
}
-
+
@Test
- public void testYardId(){
- assertNotNull("The ID of the Yard MUST NOT be NULL",getYard().getId());
+ public void testYardId() {
+ assertNotNull("The ID of the Yard MUST NOT be NULL", getYard().getId());
}
-
+
@Test
- public void testYardName(){
- assertNotNull("The Name of the Yard MUST NOT be NULL",getYard().getName());
+ public void testYardName() {
+ assertNotNull("The Name of the Yard MUST NOT be NULL", getYard().getName());
assertFalse("The Name of the Yard MUST NOT be an empty String", getYard().getName().isEmpty());
}
-
+
@Test
- public void testDefaultCreate() throws YardException{
+ public void testDefaultCreate() throws YardException {
Yard yard = getYard();
Representation test = yard.create();
assertNotNull(test);
Representation test2 = yard.create();
assertNotNull(test2);
assertNotSame(test, test2);
- assertFalse("Two Representation created with create() MUST NOT be equals",test.equals(test2));
+ assertFalse("Two Representation created with create() MUST NOT be equals", test.equals(test2));
}
@Test
- public void testCreateWithNull() throws YardException{
+ public void testCreateWithNull() throws YardException {
Yard yard = getYard();
Representation test = yard.create(null);
- assertNotNull("Parsing NULL to create(String) MUST create a valid Representation",test);
- representationIds.add(test.getId()); //add id to cleanup list
+ assertNotNull("Parsing NULL to create(String) MUST create a valid Representation", test);
+ representationIds.add(test.getId()); // add id to cleanup list
Representation test2 = yard.create(null);
- assertNotNull("Parsing NULL to create(String) MUST create a valid Representation",test2);
- representationIds.add(test2.getId()); //add id to cleanup list
+ assertNotNull("Parsing NULL to create(String) MUST create a valid Representation", test2);
+ representationIds.add(test2.getId()); // add id to cleanup list
assertNotSame(test, test2);
- assertFalse("Two Representation created with create(null) MUST NOT be equals",test.equals(test2));
+ assertFalse("Two Representation created with create(null) MUST NOT be equals", test.equals(test2));
}
- @Test(expected=IllegalArgumentException.class)
- public void testCreateWithEmptyString() throws YardException{
- getYard().create("");//throws an IllegalArgumentException
+ @Test(expected = IllegalArgumentException.class)
+ public void testCreateWithEmptyString() throws YardException {
+ getYard().create("");// throws an IllegalArgumentException
}
- @Test(expected=IllegalArgumentException.class)
- public void testCreateWithExistingId() throws YardException{
+ @Test(expected = IllegalArgumentException.class)
+ public void testCreateWithExistingId() throws YardException {
Yard yard = getYard();
Representation test = create();
assertNotNull(test);
- yard.create(test.getId()); //throws an IllegalArgumentException
+ yard.create(test.getId()); // throws an IllegalArgumentException
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testIsRepresentationWithNull() throws YardException {
getYard().isRepresentation(null);
}
-
- @Test(expected=IllegalArgumentException.class)
- public void testIsRepresentationWithEmptyString() throws YardException{
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testIsRepresentationWithEmptyString() throws YardException {
getYard().isRepresentation("");
}
- @Test(expected=IllegalArgumentException.class)
+
+ @Test(expected = IllegalArgumentException.class)
public void testStoreRepresentationWithNull() throws YardException {
- getYard().store((Representation)null);
+ getYard().store((Representation) null);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testStoreRepresentationsWithNull() throws YardException {
- getYard().store((Iterable<Representation>)null);
+ getYard().store((Iterable<Representation>) null);
}
+
@Test
public void testStoreRepresentation() throws YardException {
- //NOTE: this does not test if the updated view of the representation is
- // stored, but only that the store method works for representations
- // that are already in the Yard AND representations that are not yet
- // present within the yard
+ // NOTE: this does not test if the updated view of the representation is
+ // stored, but only that the store method works for representations
+ // that are already in the Yard AND representations that are not yet
+ // present within the yard
String testId = "urn:yard.test.testStoreRepresentation:representation.id1";
String testId2 = "urn:yard.test.testStoreRepresentation:representation.id2";
Yard yard = getYard();
- Representation test = create(testId,false);
+ Representation test = create(testId, false);
Representation added = yard.store(test); // this adds the representation
assertEquals(test, added);
- Representation test2 = create(testId2,true); //this creates and adds the representation
- //now test that the representation can also be updated
+ Representation test2 = create(testId2, true); // this creates and adds the representation
+ // now test that the representation can also be updated
added = yard.store(test2);
assertEquals(test2, added);
}
+
@Test
public void testStoreRepresentations() throws YardException {
- //NOTE: this does not test if the updated view of the representation is
- // stored, but only that the store method works for representations
- // that are already in the Yard AND representations that are not yet
- // present within the yard
+ // NOTE: this does not test if the updated view of the representation is
+ // stored, but only that the store method works for representations
+ // that are already in the Yard AND representations that are not yet
+ // present within the yard
String testId = "urn:yard.test.testStoreRepresentations:representation.id1";
String testId2 = "urn:yard.test.testStoreRepresentations:representation.id2";
String field = "urn:the.field:used.for.this.Test";
Yard yard = getYard();
- Representation test = create(testId,false);
- Representation test2 = create(testId2,true); //this creates and adds the representation
- //now add both and mix Representations that are already present in the yard
- //with an other that is not yet present in the yard
+ Representation test = create(testId, false);
+ Representation test2 = create(testId2, true); // this creates and adds the representation
+ // now add both and mix Representations that are already present in the yard
+ // with an other that is not yet present in the yard
- //change the representations to be sure to force an update even if the
- //implementation checks for changes before updating a representation
+ // change the representations to be sure to force an update even if the
+ // implementation checks for changes before updating a representation
test2.add(field, "test value 2");
- Iterable<Representation> addedIterable = yard.store(Arrays.asList(test,test2));
+ Iterable<Representation> addedIterable = yard.store(Arrays.asList(test, test2));
assertNotNull(addedIterable);
- Collection<Representation> added = asCollection(addedIterable.iterator());
- //test that both the parsed Representations where stored (updated & created)
+ Collection<Representation> added = asCollection(addedIterable.iterator());
+ // test that both the parsed Representations where stored (updated & created)
assertTrue(added.remove(test));
assertTrue(added.remove(test2));
assertTrue(added.isEmpty());
}
+
@Test
public void testStoreRepresentationsWithNullElement() throws YardException {
String testId = "urn:yard.test.testStoreRepresentationsWithNullElement:representation.id";
Yard yard = getYard();
- Representation test = create(testId,false);
- Iterable<Representation> added = yard.store(Arrays.asList(
- test,
- null));
- //now test that only the valid representation was added and the null
- //value was ignored
+ Representation test = create(testId, false);
+ Iterable<Representation> added = yard.store(Arrays.asList(test, null));
+ // now test that only the valid representation was added and the null
+ // value was ignored
assertNotNull(added);
Iterator<Representation> addedIt = added.iterator();
assertTrue(addedIt.hasNext());
assertEquals(test, addedIt.next());
assertFalse(addedIt.hasNext());
}
- @Test(expected=IllegalArgumentException.class)
+
+ @Test(expected = IllegalArgumentException.class)
public void testGetRepresentationWithNull() throws YardException {
getYard().getRepresentation(null);
}
- @Test(expected=IllegalArgumentException.class)
+
+ @Test(expected = IllegalArgumentException.class)
public void testGetRepresentationWithEmptyString() throws YardException {
getYard().getRepresentation("");
}
+
@Test
public void testGetNonExistantRepresentation() throws YardException {
String id = "urn:yard.test.testGetNonExistantRepresentation:representation.id";
assertNull(getYard().getRepresentation(id));
}
+
/**
- * This tests that {@link Representation} retrieved from the Yard do not
- * influence other {@link Representation} instances for the same ID. It is
- * important, that when different {@link Representation} instances are
- * returned to different caller, that these do not influence each other.<p>
- * It also tests, that any update to the {@link Representation} as managed
- * by the {@link Yard} does also not influence {@link Representation}
- * instances that where created before the change.
+ * This tests that {@link Representation} retrieved from the Yard do not influence other
+ * {@link Representation} instances for the same ID. It is important, that when different
+ * {@link Representation} instances are returned to different caller, that these do not influence each
+ * other.
+ * <p>
+ * It also tests, that any update to the {@link Representation} as managed by the {@link Yard} does also
+ * not influence {@link Representation} instances that where created before the change.
+ *
* @throws YardException
*/
@Test
@@ -232,262 +239,278 @@ public abstract class YardTest {
Yard yard = getYard();
String field = "urn:the.field:used.for.this.Test";
String value1 = "this is a test";
- //Representations created via the yard need to be created (as empty
- //representation within the yard
- Representation test = create(id,true);
- //retrieve the representation from the store
+ // Representations created via the yard need to be created (as empty
+ // representation within the yard
+ Representation test = create(id, true);
+ // retrieve the representation from the store
Representation retrieved = yard.getRepresentation(id);
assertNotNull(retrieved);
- //they MUST NOT be the same, but the MUST be equals
- //Note:
- //the fact that two representations with the same id are equals is tested
- //by the unit tests for the representation interface
- assertEquals(test, retrieved);
- assertNotSame("getRepresentation MUST return an new instance for each " +
- "call, so that changes in one return instance do not influence " +
- "an other returned instance!",test, retrieved);
- //now add a property to the original one
+ // they MUST NOT be the same, but the MUST be equals
+ // Note:
+ // the fact that two representations with the same id are equals is tested
+ // by the unit tests for the representation interface
+ assertEquals(test, retrieved);
+ assertNotSame("getRepresentation MUST return an new instance for each "
+ + "call, so that changes in one return instance do not influence "
+ + "an other returned instance!", test, retrieved);
+ // now add a property to the original one
test.add(field, value1);
- //and check that the retrieved does not have the value
+ // and check that the retrieved does not have the value
assertFalse(retrieved.get(field).hasNext());
- //now store the representation and check that updated are not reflected
- //within the retrieved one
+ // now store the representation and check that updated are not reflected
+ // within the retrieved one
yard.store(test);
assertFalse(retrieved.get(field).hasNext());
- //now retrieve again an representation
+ // now retrieve again an representation
retrieved = null;
retrieved = yard.getRepresentation(id);
- //now the Representation MUST HAVE the new field
+ // now the Representation MUST HAVE the new field
assertTrue(retrieved.get(field).hasNext());
assertEquals(value1, retrieved.getFirst(field));
-
- //finally retrieve a second and perform the change test again
+
+ // finally retrieve a second and perform the change test again
Representation retrieved2 = yard.getRepresentation(id);
retrieved.removeAll(field);
- //check the value is still in retrieved2
+ // check the value is still in retrieved2
assertTrue(retrieved2.get(field).hasNext());
assertEquals(value1, retrieved2.getFirst(field));
-
+
}
-
+
@Test
public void testIsRepresentation() throws YardException {
String id = "urn:yard.test.testIsRepresentation:representation.id";
Yard yard = getYard();
- //Representations created via the yard need to be created (as empty
- //representation within the yard
+ // Representations created via the yard need to be created (as empty
+ // representation within the yard
Representation test = create();
assertTrue(yard.isRepresentation(test.getId()));
- //Representations created via the ValueFactory MUST NOT be added to the
- //Yard
- Representation test2 = create(id,false);
+ // Representations created via the ValueFactory MUST NOT be added to the
+ // Yard
+ Representation test2 = create(id, false);
assertFalse(yard.isRepresentation(test2.getId()));
- //now store test2 and test again
+ // now store test2 and test again
yard.store(test2);
assertTrue(yard.isRepresentation(test2.getId()));
- //now remove test and test again
+ // now remove test and test again
yard.remove(test.getId());
assertFalse(yard.isRepresentation(test.getId()));
yard.remove(test2.getId());
assertFalse(yard.isRepresentation(test2.getId()));
}
- @Test(expected=IllegalArgumentException.class)
+
+ @Test(expected = IllegalArgumentException.class)
public void testUpdateRepresentationWithNull() throws YardException {
- getYard().update((Representation)null);
+ getYard().update((Representation) null);
}
- @Test(expected=IllegalArgumentException.class)
+
+ @Test(expected = IllegalArgumentException.class)
public void testUpdateRepresentationWithNonPresent() throws YardException {
String id = "urn:yard.test.testUpdateRepresentationWithNonPresent:representation.id";
- Representation test = create(id,false);
- getYard().update(test); //throws an Exception because test is not part of the yard
+ Representation test = create(id, false);
+ getYard().update(test); // throws an Exception because test is not part of the yard
}
- @Test(expected=IllegalArgumentException.class)
+
+ @Test(expected = IllegalArgumentException.class)
public void testUpdateRepresentationsWithNull() throws YardException {
- getYard().update((Iterable<Representation>)null);
+ getYard().update((Iterable<Representation>) null);
}
+
@Test
public void testUpdateRepresentations() throws YardException {
- //NOTE: this does not test if the updated view of the representation is
- // stored, but only that the update method works correctly
+ // NOTE: this does not test if the updated view of the representation is
+ // stored, but only that the update method works correctly
Yard yard = getYard();
String id1 = "urn:yard.test.testUpdateRepresentations:representation.id1";
String id2 = "urn:yard.test.testUpdateRepresentations:representation.id2";
String field = "urn:the.field:used.for.this.Test";
- Representation test1 = create(id1,true);
- Representation test2 = create(id2,true);
- //change the representations to be sure to force an update even if the
- //implementation checks for changes before updating a representation
- test1.add(field, "test value 1");
+ Representation test1 = create(id1, true);
+ Representation test2 = create(id2, true);
+ // change the representations to be sure to force an update even if the
+ // implementation checks for changes before updating a representation
+ test1.add(field, "test value 1");
test2.add(field, "test value 2");
- Iterable<Representation> updatedIterable = yard.update(Arrays.asList(test1,test2));
+ Iterable<Representation> updatedIterable = yard.update(Arrays.asList(test1, test2));
assertNotNull(updatedIterable);
- Collection<Representation> updated = asCollection(updatedIterable.iterator());
- //test that both the parsed Representations where stored (updated & created)
+ Collection<Representation> updated = asCollection(updatedIterable.iterator());
+ // test that both the parsed Representations where stored (updated & created)
assertTrue(updated.remove(test1));
assertTrue(updated.remove(test2));
assertTrue(updated.isEmpty());
}
+
/**
* When updating multiple null values need to be ignored.
+ *
* @throws YardException
*/
@Test
public void testUpdateRepresentationsWithNullElement() throws YardException {
- //NOTE: this does not test if the updated view of the representation is
- // stored, but only that the update method works correctly
+ // NOTE: this does not test if the updated view of the representation is
+ // stored, but only that the update method works correctly
Yard yard = getYard();
String id1 = "urn:yard.test.testUpdateRepresentationsWithNullElement:representation.id";
String field = "urn:the.field:used.for.this.Test";
- Representation test1 = create(id1,true);
- //change the representations to be sure to force an update even if the
- //implementation checks for changes before updating a representation
- test1.add(field, "test value 1");
- Iterable<Representation> updated = yard.update(Arrays.asList(test1,null));
+ Representation test1 = create(id1, true);
+ // change the representations to be sure to force an update even if the
+ // implementation checks for changes before updating a representation
+ test1.add(field, "test value 1");
+ Iterable<Representation> updated = yard.update(Arrays.asList(test1, null));
assertNotNull(updated);
Iterator<Representation> updatedIt = updated.iterator();
assertTrue(updatedIt.hasNext());
assertEquals(test1, updatedIt.next());
assertFalse(updatedIt.hasNext());
}
+
/**
* When updating multiple non present representations need to be ignored.
+ *
* @throws YardException
*/
@Test
public void testUpdateRepresentationsWithNonPresent() throws YardException {
- //NOTE: this does not test if the updated view of the representation is
- // stored, but only that the update method works correctly
+ // NOTE: this does not test if the updated view of the representation is
+ // stored, but only that the update method works correctly
Yard yard = getYard();
String id1 = "urn:yard.test.testUpdateRepresentationsWithNonPresent:representation.id1";
String id2 = "urn:yard.test.testUpdateRepresentationsWithNonPresent:representation.id2";
String field = "urn:the.field:used.for.this.Test";
- Representation test1 = create(id1,true);
- //change the representations to be sure to force an update even if the
- //implementation checks for changes before updating a representation
+ Representation test1 = create(id1, true);
+ // change the representations to be sure to force an update even if the
+ // implementation checks for changes before updating a representation
test1.add(field, "test value 1");
- //create a 2nd Representation by using the ValueFactory (will not add it
- //to the yard!)
- Representation test2 = create(id2,false);
- //now test1 is present and test2 is not.
- Iterable<Representation> updated = yard.update(Arrays.asList(test1,test2));
- //We expect that only test1 is updated and test2 is ignored
+ // create a 2nd Representation by using the ValueFactory (will not add it
+ // to the yard!)
+ Representation test2 = create(id2, false);
+ // now test1 is present and test2 is not.
+ Iterable<Representation> updated = yard.update(Arrays.asList(test1, test2));
+ // We expect that only test1 is updated and test2 is ignored
assertNotNull(updated);
Iterator<Representation> updatedIt = updated.iterator();
assertTrue(updatedIt.hasNext());
assertEquals(test1, updatedIt.next());
assertFalse(updatedIt.hasNext());
}
-
- @Test(expected=IllegalArgumentException.class)
+
+ @Test(expected = IllegalArgumentException.class)
public void testRemoveRepresentationWithNull() throws YardException {
- getYard().remove((String)null);
+ getYard().remove((String) null);
}
+
/**
- * Tests two things:<ol>
- * <li> if representations are removed form the yard
- * <li> if the representation instance is still valid after it is removed
+ * Tests two things:
+ * <ol>
+ * <li>if representations are removed form the yard
+ * <li>if the representation instance is still valid after it is removed
* </ol>
- * The second is very important, because Representations might still be
- * used by other components after they are remove from the store they
- * where created in
+ * The second is very important, because Representations might still be used by other components after
+ * they are remove from the store they where created in
+ *
* @throws YardException
*/
@Test
public void testRemoveRepresentation() throws YardException {
- //NOTE: This test needs not to use the create(..) method, because we
- //remove the created representation form the store anyway as part of the
- //test
+ // NOTE: This test needs not to use the create(..) method, because we
+ // remove the created representation form the store anyway as part of the
+ // test
String id = "urn:yard.test.tesrRemoveRepresentation:representation.id";
String field = "urn:the.field:used.for.this.Test";
String testValue = "This is a test";
Yard yard = getYard();
- Representation test = yard.getValueFactory().createRepresentation(id);
+ Representation test = yard.getValueFactory().createRepresentation(id);
test.add(field, testValue);
- yard.store(test); //store the representation
- assertTrue(yard.isRepresentation(test.getId())); //test if stored
- test = null; //free the initial
- //create the instance form the store to test (2)
+ yard.store(test); // store the representation
+ assertTrue(yard.isRepresentation(test.getId())); // test if stored
+ test = null; // free the initial
+ // create the instance form the store to test (2)
test = yard.getRepresentation(id);
- assertEquals(id, test.getId()); //only to be sure ...
- yard.remove(test.getId()); //test (1) - the remove
- assertFalse(yard.isRepresentation(test.getId()));//test if removed
- //test if the test object is not destroyed by removing the representation
- //it represents form the store (2)
+ assertEquals(id, test.getId()); // only to be sure ...
+ yard.remove(test.getId()); // test (1) - the remove
+ assertFalse(yard.isRepresentation(test.getId()));// test if removed
+ // test if the test object is not destroyed by removing the representation
+ // it represents form the store (2)
assertEquals(testValue, test.getFirst(field));
}
- @Test(expected=IllegalArgumentException.class)
+
+ @Test(expected = IllegalArgumentException.class)
public void testRemoveRepresentationsWithNull() throws YardException {
- getYard().remove((Iterable<String>)null);
+ getYard().remove((Iterable<String>) null);
}
+
/**
- * Tests that multiple Representations are removed.
+ * Tests that multiple Representations are removed.
+ *
* @throws YardException
*/
@Test
public void testRemoveRepresentations() throws YardException {
- //NOTE: This test needs not to use the create(..) method, because we
- //remove the created representation form the store anyway as part of the
- //test
+ // NOTE: This test needs not to use the create(..) method, because we
+ // remove the created representation form the store anyway as part of the
+ // test
String id = "urn:yard.test.testRemoveRepresentationsWithNullValue:representation.id1";
String id2 = "urn:yard.test.testRemoveRepresentationsWithNullValue:representation.id2";
String field = "urn:the.field:used.for.this.Test";
String testValue = "This is a test";
Yard yard = getYard();
- //use both ways to add the two Representations (should make no differences,
- //but one never can know ...
- Representation test1 = yard.create(id); //create and add
- Representation test2 = yard.getValueFactory().createRepresentation(id2); //create
- test2.add(field, testValue); //add value
- yard.store(test2);//store
- assertTrue(yard.isRepresentation(test1.getId())); //test if stored
+ // use both ways to add the two Representations (should make no differences,
+ // but one never can know ...
+ Representation test1 = yard.create(id); // create and add
+ Representation test2 = yard.getValueFactory().createRepresentation(id2); // create
+ test2.add(field, testValue); // add value
+ yard.store(test2);// store
+ assertTrue(yard.isRepresentation(test1.getId())); // test if stored
assertTrue(yard.isRepresentation(test2.getId()));
- yard.remove(Arrays.asList(test1.getId(),test2.getId())); //remove
- assertFalse(yard.isRepresentation(test1.getId())); //test if removed
- assertFalse(yard.isRepresentation(test2.getId()));
+ yard.remove(Arrays.asList(test1.getId(), test2.getId())); // remove
+ assertFalse(yard.isRepresentation(test1.getId())); // test if removed
+ assertFalse(yard.isRepresentation(test2.getId()));
}
+
/**
- * Tests if <code>null</code> values within the Iterable are ignored and do
- * not cause an Exception
+ * Tests if <code>null</code> values within the Iterable are ignored and do not cause an Exception
+ *
* @throws YardException
*/
@Test
public void testRemoveRepresentationsWithNullValue() throws YardException {
- //NOTE: This test needs not to use the create(..) method, because we
- //remove the created representation form the store anyway as part of the
- //test
+ // NOTE: This test needs not to use the create(..) method, because we
+ // remove the created representation form the store anyway as part of the
+ // test
String id = "urn:yard.test.testRemoveRepresentationsWithNullValue:representation.id";
Yard yard = getYard();
- Representation test = yard.create(id); //create and add
+ Representation test = yard.create(id); // create and add
assertTrue(yard.isRepresentation(test.getId()));
- yard.remove(Arrays.asList(test.getId(),null));
+ yard.remove(Arrays.asList(test.getId(), null));
assertFalse(yard.isRepresentation(test.getId()));
}
+
/**
- * Tests that {@link Representation} IDs that are not stored by the yard are
- * ignored by the multiple remove method
+ * Tests that {@link Representation} IDs that are not stored by the yard are ignored by the multiple
+ * remove method
+ *
* @throws YardException
*/
@Test
public void testRemoveRepresentationsWithNonStoredValue() throws YardException {
- //NOTE: This test needs not to use the create(..) method, because we
- //remove the created representation form the store anyway as part of the
- //test
+ // NOTE: This test needs not to use the create(..) method, because we
+ // remove the created representation form the store anyway as part of the
+ // test
String id = "urn:yard.test.testRemoveRepresentationsWithNullValue:representation.stored";
String id2 = "urn:yard.test.testRemoveRepresentationsWithNullValue:representation.notStored";
Yard yard = getYard();
- Representation test = yard.create(id); //create and add
+ Representation test = yard.create(id); // create and add
assertTrue(yard.isRepresentation(test.getId()));
- yard.remove(Arrays.asList(test.getId(),id2));
+ yard.remove(Arrays.asList(test.getId(), id2));
assertFalse(yard.isRepresentation(test.getId()));
assertFalse(yard.isRepresentation(id2));
}
+
/**
- * The {@link Representation} as stored in the Yard MUST NOT change if the
- * source {@link Representation} stored to the {@link Yard} or an
- * Representation retrieved from the Yard is changed. Only the
- * {@link Yard#store(Representation))} and the {@link Yard#update(Representation)}
- * methods are allowed to synchronised the Representation within the Yard with
- * the state (changes) of the parsed value.
+ * The {@link Representation} as stored in the Yard MUST NOT change if the source {@link Representation}
+ * stored to the {@link Yard} or an Representation retrieved from the Yard is changed. Only the
+ * {@link Yard#store(Representation))} and the {@link Yard#update(Representation)} methods are allowed to
+ * synchronised the Representation within the Yard with the state (changes) of the parsed value.
+ *
* @throws YardException
*/
@Test
@@ -496,44 +519,44 @@ public abstract class YardTest {
String field = "urn:the.field:used.for.this.Test";
String testValue = "This is a test";
Yard yard = getYard();
- //use the ValueFactory to create the representation to ensure that this
- //instance has nothing to do with the store
- Representation test = create(id,false);
- //now store the empty Representation
+ // use the ValueFactory to create the representation to ensure that this
+ // instance has nothing to do with the store
+ Representation test = create(id, false);
+ // now store the empty Representation
yard.store(test);
- //now add a values
+ // now add a values
test.add(field, testValue);
- //now get the representation from the yard
+ // now get the representation from the yard
Representation stored = yard.getRepresentation(id);
- //test if the stored version does not contain the value
+ // test if the stored version does not contain the value
assertFalse(stored.get(field).hasNext());
stored = null;
- //now store the updated version
+ // now store the updated version
yard.store(test);
- //now check that the updated value is stored
+ // now check that the updated value is stored
stored = yard.getRepresentation(id);
assertEquals(testValue, stored.getFirst(field));
-
- //now we need to test if modifications of an Representation returned
+
+ // now we need to test if modifications of an Representation returned
test = stored;
stored = null;
String testValue2 = "This is an ohter test value";
test.add(field, testValue2);
-
- //now get the representation from the yard and check that it still has
- //only one value
+
+ // now get the representation from the yard and check that it still has
+ // only one value
stored = yard.getRepresentation(id);
Collection<Object> values = asCollection(stored.get(field));
- assertTrue(values.remove(testValue)); //test that it contains the value
- assertTrue(values.isEmpty()); //and that there is only this value
+ assertTrue(values.remove(testValue)); // test that it contains the value
+ assertTrue(values.isEmpty()); // and that there is only this value
values = null;
- //now update the stored version with the new state
+ // now update the stored version with the new state
stored = null;
stored = yard.update(test);
values = asCollection(stored.get(field));
- assertTrue(values.remove(testValue)); //test that it contains the original
- assertTrue(values.remove(testValue2)); //test that it contains the 2nd value
- assertTrue(values.isEmpty()); //and that there are only these two values
+ assertTrue(values.remove(testValue)); // test that it contains the original
+ assertTrue(values.remove(testValue2)); // test that it contains the 2nd value
+ assertTrue(values.isEmpty()); // and that there are only these two values
values = null;
}
}