* ModeShape (http://www.modeshape.org)

*

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

*/

* The {@link JcrObservationManager} test class.

*/

    private static final String LOCK_MIXIN = "mix:lockable"; // extends referenceable

    private static final String LOCK_OWNER = "jcr:lockOwner"; // property

    private static final String LOCK_IS_DEEP = "jcr:lockIsDeep"; // property

    // private static final String NT_BASE = "nt:base";

    private static final String REF_MIXIN = "mix:referenceable";

    private static final String UNSTRUCTURED = "nt:unstructured";

    private static final String USER_ID = "superuser";

    protected static final String WORKSPACE = "ws1";

    protected static final String WORKSPACE2 = "ws2";

    private Node testRootNode;

    @BeforeClass

    public static void beforeAll() {

        // Initialize PicketBox ...

        JaasTestUtil.initJaas("security/jaas.conf.xml");

    }

    @AfterClass

    public static void afterAll() {

        JaasTestUtil.releaseJaas();

    }

    @Override

    protected boolean startRepositoryAutomatically() {

        return false;

    }

    @Override

    @Before

    public void beforeEach() throws Exception {

        super.beforeEach();

        FileUtil.delete("target/journal");

        startRepositoryWithConfiguration(resourceStream("config/repo-config-observation.json"));

        session = login(WORKSPACE);

        this.testRootNode = this.session.getRootNode().addNode("testroot", UNSTRUCTURED);

        save();

    }

    SimpleListener addListener( int expectedEventsCount,

                                int eventTypes,

                                String absPath,

                                boolean isDeep,

                                String[] uuids,

                                String[] nodeTypeNames,

                                boolean noLocal ) throws Exception {

        return addListener(expectedEventsCount, 1, eventTypes, absPath, isDeep, uuids, nodeTypeNames, noLocal);

    }

    SimpleListener addListener( int expectedEventsCount,

                                int numIterators,

                                int eventTypes,

                                String absPath,

                                boolean isDeep,

                                String[] uuids,

                                String[] nodeTypeNames,

                                boolean noLocal ) throws Exception {

        return addListener(this.session,

                           expectedEventsCount,

                           numIterators,

                           eventTypes,

                           absPath,

                           isDeep,

                           uuids,

                           nodeTypeNames,

                           noLocal);

    }

    SimpleListener addListener( Session session,

                                int expectedEventsCount,

                                int eventTypes,

                                String absPath,

                                boolean isDeep,

                                String[] uuids,

                                String[] nodeTypeNames,

                                boolean noLocal ) throws Exception {

        return addListener(session, expectedEventsCount, 1, eventTypes, absPath, isDeep, uuids, nodeTypeNames, noLocal);

    }

    SimpleListener addListener( Session session,

                                int expectedEventsCount,

                                int numIterators,

                                int eventTypes,

                                String absPath,

                                boolean isDeep,

                                String[] uuids,

                                String[] nodeTypeNames,

                                boolean noLocal ) throws Exception {

        SimpleListener listener = new SimpleListener(expectedEventsCount, numIterators, eventTypes);

        session.getWorkspace()

               .getObservationManager()

               .addEventListener(listener, eventTypes, absPath, isDeep, uuids, nodeTypeNames, noLocal);

        return listener;

    }

    protected JcrSession login( String workspaceName ) throws RepositoryException {

        Session session = repository.login(new SimpleCredentials(USER_ID, USER_ID.toCharArray()), workspaceName);

        assertTrue(session != this.session);

        return (JcrSession)session;

    }

    void checkResults( SimpleListener listener ) {

        if (listener.getActualEventCount() != listener.getExpectedEventCount()) {

            // Wrong number ...

            StringBuilder sb = new StringBuilder(" Actual events were: ");

            for (Event event : listener.getEvents()) {

                sb.append('\n').append(event);

            }

            assertThat("Received incorrect number of events." + sb.toString(),

                       listener.getActualEventCount(),

                       is(listener.getExpectedEventCount()));

            assertThat(listener.getErrorMessage(), listener.getErrorMessage(), is(nullValue()));

        }

    }

    boolean containsPath( SimpleListener listener,

                          String path ) throws Exception {

        for (Event event : listener.getEvents()) {

            if (event.getPath().equals(path)) return true;

        }

        return false;

    }

    ObservationManager getObservationManager() throws RepositoryException {

        return this.session.getWorkspace().getObservationManager();

    }

    Node getRoot() {

        return testRootNode;

    }

    Workspace getWorkspace() {

        return this.session.getWorkspace();

    }

    void removeListener( SimpleListener listener ) throws Exception {

        this.session.getWorkspace().getObservationManager().removeEventListener(listener);

    }

    void save() throws RepositoryException {

        this.session.save();

    }

    @Test

    public void shouldNotReceiveEventIfUuidDoesNotMatch() throws Exception {

        // setup

        Node n1 = getRoot().addNode("node1", UNSTRUCTURED);

        n1.addMixin(REF_MIXIN);

        save();

        // register listener

        SimpleListener listener = addListener(0,

                                              Event.PROPERTY_ADDED,

                                              getRoot().getPath(),

                                              true,

                                              new String[] { UUID.randomUUID().toString() },

                                              null,

                                              false);

        // create properties

        n1.setProperty("prop1", "foo");

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

    }

    @Test

    public void shouldNotReceiveEventIfNodeTypeDoesNotMatch() throws Exception {

        // setup

        Node node1 = getRoot().addNode("node1", UNSTRUCTURED);

        save();

        // register listener

        SimpleListener listener = addListener(0, ALL_EVENTS, null, false, null, new String[] {REF_MIXIN}, false);

        // create event triggers

        node1.setProperty("newProperty", "newValue"); // node1 is NOT referenceable

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

    }

    @Test

    public void shouldReceiveNodeAddedEventWhenRegisteredToReceiveAllEvents() throws Exception {

        // register listener (add + primary type property)

        SimpleListener listener = addListener(4, ALL_EVENTS, null, false, null, null, false)

                .withExpectedNodePrimaryType(UNSTRUCTURED).withExpectedNodeMixinTypes(REF_MIXIN);

        // add node

        Node addedNode = getRoot().addNode("node1", UNSTRUCTURED);

        addedNode.addMixin(REF_MIXIN);

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        assertTrue("Path for added node is wrong: actual=" + listener.getEvents().get(0).getPath() + ", expected="

                   + addedNode.getPath(),

                   containsPath(listener, addedNode.getPath()));

    }

    @Test

    public void shouldReceiveNodeRemovedEventWhenRegisteredToReceiveAllEvents() throws Exception {

        // add the node that will be removed

        Node addedNode = getRoot().addNode("node1", UNSTRUCTURED);

        save();

        // register listener (add + 3 property events)

        SimpleListener listener = addListener(1, ALL_EVENTS, null, false, null, null, false).withExpectedNodePrimaryType(UNSTRUCTURED);

        // remove node

        String path = addedNode.getPath();

        addedNode.remove();

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        assertTrue("Path for removed node is wrong: actual=" + listener.getEvents().get(0).getPath() + ", expected=" + path,

                   containsPath(listener, path));

    }

    @Test

    public void shouldReceivePropertyAddedEventWhenRegisteredToReceiveAllEvents() throws Exception {

        // setup

        Node node = getRoot().addNode("node1", UNSTRUCTURED);

        node.addMixin(REF_MIXIN);

        save();

        // register listener

        SimpleListener listener = addListener(1, ALL_EVENTS, null, false, null, null, false)

                .withExpectedNodePrimaryType(UNSTRUCTURED).withExpectedNodeMixinTypes(REF_MIXIN);

        // add the property

        Property prop1 = node.setProperty("prop1", "prop1 content");

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        Event propertyAddedEvent = listener.getEvents().get(0);

        assertTrue("Path for added property is wrong: actual=" + propertyAddedEvent.getPath() + ", expected="

                   + prop1.getPath(),

                   containsPath(listener, prop1.getPath()));

        assertTrue(propertyAddedEvent instanceof PropertyEvent);

        PropertyEvent propertyEvent = (PropertyEvent) propertyAddedEvent;

        assertEquals("prop1 content", propertyEvent.getCurrentValue());

        assertEquals(1, propertyEvent.getCurrentValues().size());

        assertEquals("prop1 content", propertyEvent.getCurrentValues().get(0));

        assertFalse(propertyEvent.isMultiValue());

        assertFalse(propertyEvent.wasMultiValue());

        assertNull(propertyEvent.getPreviousValue());

        assertNull(propertyEvent.getPreviousValues());

    }

    @Test

    public void shouldReceivePropertyChangedEventWhenRegisteredToReceiveAllEvents() throws Exception {

        // setup

        Node node = getRoot().addNode("node1", UNSTRUCTURED);

        Property prop1 = node.setProperty("prop1", "prop1 content");

        save();

        // register listener

        SimpleListener listener = addListener(1, ALL_EVENTS, null, false, null, null, false).withExpectedNodePrimaryType(UNSTRUCTURED);

        // change the property

        prop1.setValue("prop1 modified content");

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        Event propertyChangedEvent = listener.getEvents().get(0);

        assertTrue("Path for changed property is wrong: actual=" + propertyChangedEvent.getPath() + ", expected="

                   + prop1.getPath(),

                   containsPath(listener, prop1.getPath()));

        assertTrue(propertyChangedEvent instanceof PropertyEvent);

        PropertyEvent propertyEvent = (PropertyEvent) propertyChangedEvent;

        assertEquals("prop1 modified content", propertyEvent.getCurrentValue());

        assertEquals(1, propertyEvent.getCurrentValues().size());

        assertEquals("prop1 modified content", propertyEvent.getCurrentValues().get(0));

        assertFalse(propertyEvent.isMultiValue());

        assertFalse(propertyEvent.wasMultiValue());

        assertEquals("prop1 content", propertyEvent.getPreviousValue());

        assertEquals(1, propertyEvent.getPreviousValues().size());

        assertEquals("prop1 content", propertyEvent.getPreviousValues().get(0));

    }

    @Test

    public void shouldReceivePropertyRemovedEventWhenRegisteredToReceiveAllEvents() throws Exception {

        // setup

        Node node = getRoot().addNode("node1", UNSTRUCTURED);

        Property prop = node.setProperty("prop1", "prop1 content");

        String propPath = prop.getPath();

        save();

        // register listener

        SimpleListener listener = addListener(1, ALL_EVENTS, null, false, null, null, false).withExpectedNodePrimaryType(UNSTRUCTURED);

        // remove the property

        prop.remove();

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        Event propertyRemovedEvent = listener.getEvents().get(0);

        assertTrue("Path for removed property is wrong: actual=" + propertyRemovedEvent.getPath() + ", expected="

                   + propPath, containsPath(listener, propPath));

        assertTrue(propertyRemovedEvent instanceof PropertyEvent);

        PropertyEvent propertyEvent = (PropertyEvent) propertyRemovedEvent;

        assertEquals("prop1 content", propertyEvent.getCurrentValue());

        assertEquals(1, propertyEvent.getCurrentValues().size());

        assertEquals("prop1 content", propertyEvent.getCurrentValues().get(0));

        assertFalse(propertyEvent.isMultiValue());

        assertFalse(propertyEvent.wasMultiValue());

        assertNull(propertyEvent.getPreviousValue());

        assertNull(propertyEvent.getPreviousValues());

    }

    @Test

    public void shouldReceivePropertyAddedEventWhenRegisteredToReceiveEventsBasedUponNodeTypeName() throws Exception {

        // register listener

        String[] nodeTypeNames = {"mode:root"};

        SimpleListener listener = addListener(1, ALL_EVENTS, null, true, null, nodeTypeNames, false)

                .withExpectedNodePrimaryType("mode:root");

        // add the property

        this.session.getRootNode().setProperty("fooProp", new String[]{"foo", "bar"});

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        String propPath = "/fooProp";

        Event propertyAddedEvent = listener.getEvents().get(0);

        assertTrue("Path for added property is wrong: actual=" + propertyAddedEvent.getPath() + ", expected=" + propPath,

                   containsPath(listener, propPath));

        assertTrue(propertyAddedEvent instanceof PropertyEvent);

        PropertyEvent propertyEvent = (PropertyEvent) propertyAddedEvent;

        assertEquals("foo", propertyEvent.getCurrentValue());

        assertEquals(2, propertyEvent.getCurrentValues().size());

        assertEquals(Arrays.asList("foo", "bar"), propertyEvent.getCurrentValues());

        assertTrue(propertyEvent.isMultiValue());

        assertFalse(propertyEvent.wasMultiValue());

        assertNull(propertyEvent.getPreviousValue());

        assertNull(propertyEvent.getPreviousValues());

    }

    // ===========================================================================================================================

    // @see org.apache.jackrabbit.test.api.observation.EventIteratorTest

    // ===========================================================================================================================

    /**

     * @see EventIteratorTest#testGetPosition()

     * @throws Exception

     */

    @Test

    public void shouldTestEventIteratorTest_testGetPosition() throws Exception {

        // register listener

        SimpleListener listener = addListener(3, Event.NODE_ADDED, null, false, null, null, false);

        // add nodes to generate events

        getRoot().addNode("node1", UNSTRUCTURED);

        getRoot().addNode("node2", UNSTRUCTURED);

        getRoot().addNode("node3", UNSTRUCTURED);

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

    }

    /**

     * @see EventIteratorTest#testGetSize()

     * @throws Exception

     */

    @Test

    public void shouldTestEventIteratorTest_testGetSize() throws Exception {

        // register listener

        SimpleListener listener = addListener(1, Event.NODE_ADDED, null, false, null, null, false);

        // add node to generate event

        getRoot().addNode("node1", UNSTRUCTURED);

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

    }

    @Test

    public void shouldTestEventIteratorTest_testSkip() throws Exception {

        // create events

        List<Event> events = new ArrayList<Event>();

        DateTime now = session.dateFactory().create();

        JcrEventBundle bundle = new JcrEventBundle(now, "userId", null);

        String id1 = UUID.randomUUID().toString();

        String id2 = UUID.randomUUID().toString();

        String id3 = UUID.randomUUID().toString();

        events.add(new JcrObservationManager.JcrEvent(bundle, Event.NODE_ADDED, "/testroot/node1",

                                                                                 id1, nodeType(JcrNtLexicon.UNSTRUCTURED), null));

        events.add(new JcrObservationManager.JcrEvent(bundle, Event.NODE_ADDED, "/testroot/node2", id2,

                                                                                 nodeType(JcrNtLexicon.UNSTRUCTURED), null));

        events.add(new JcrObservationManager.JcrEvent(bundle, Event.NODE_ADDED, "/testroot/node3", id3,

                                                                                 nodeType(JcrNtLexicon.UNSTRUCTURED), null));

        // create iterator

        EventIterator itr = new JcrObservationManager.JcrEventIterator(events);

        // tests

        itr.skip(0); // skip zero elements

        assertThat("getPosition() for first element should return 0.", itr.getPosition(), is(0L));

        itr.skip(2); // skip one element

        assertThat("Wrong value when skipping ", itr.getPosition(), is(2L));

        try {

            itr.skip(2); // skip past end

            fail("EventIterator must throw NoSuchElementException when skipping past the end");

        } catch (NoSuchElementException e) {

            // success

        }

    }

    private NodeType nodeType(Name name) {

        return session.repository().nodeTypeManager().getNodeTypes().getNodeType(name);

    }

    // ===========================================================================================================================

    // @see org.apache.jackrabbit.test.api.observation.EventTest

    // ===========================================================================================================================

    /**

     * @see EventTest#testGetNodePath()

     * @throws Exception

     */

    @Test

    public void shouldTestEventTest_testGetNodePath() throws Exception {

        // register listener

        SimpleListener listener = addListener(1, Event.NODE_ADDED, null, false, null, null, false);

        // add node to generate event

        Node addedNode = getRoot().addNode("node1", UNSTRUCTURED);

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        assertTrue("Path added node is wrong: actual=" + listener.getEvents().get(0).getPath() + ", expected="

                   + addedNode.getPath(),

                   containsPath(listener, addedNode.getPath()));

    }

    /**

     * @see EventTest#testGetType()

     * @throws Exception

     */

    @Test

    public void shouldTestEventTest_testGetType() throws Exception {

        // register listener

        SimpleListener listener = addListener(1, Event.NODE_ADDED, null, false, null, null, false);

        // add node to generate event

        getRoot().addNode("node1", UNSTRUCTURED);

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        assertThat("Event did not return correct event type", listener.getEvents().get(0).getType(), is(Event.NODE_ADDED));

    }

    /**

     * @see EventTest#testGetUserId()

     * @throws Exception

     */

    @Test

    public void shouldTestEventTest_testGetUserId() throws Exception {

        // register listener

        SimpleListener listener = addListener(1, Event.NODE_ADDED, null, false, null, null, false);

        // add a node to generate event

        getRoot().addNode("node1", UNSTRUCTURED);

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        assertThat("UserId of event is not equal to userId of session", listener.getEvents().get(0).getUserID(), is(USER_ID));

    }

    // ===========================================================================================================================

    // @see org.apache.jackrabbit.test.api.observation.GetRegisteredEventListenersTest

    // ===========================================================================================================================

    /**

     * @see GetRegisteredEventListenersTest#testGetSize()

     * @throws Exception

     */

    @Test

    public void shouldTestGetRegisteredEventListenersTest_testGetSize() throws Exception {

        assertThat("A new session must not have any event listeners registered.",

                   getObservationManager().getRegisteredEventListeners().getSize(),

                   is(0L));

        // register listener

        SimpleListener listener = addListener(0, ALL_EVENTS, null, false, null, null, false);

        addListener(0, ALL_EVENTS, null, false, null, null, false);

        assertThat("Wrong number of event listeners.", getObservationManager().getRegisteredEventListeners().getSize(), is(2L));

        // make sure same listener isn't added again

        getObservationManager().addEventListener(listener, ALL_EVENTS, null, false, null, null, false);

        assertThat("The same listener should not be added more than once.", getObservationManager().getRegisteredEventListeners()

                                                                                                   .getSize(), is(2L));

    }

    /**

     * @see GetRegisteredEventListenersTest#testRemoveEventListener()

     * @throws Exception

     */

    @Test

    public void shouldTestGetRegisteredEventListenersTest_testRemoveEventListener() throws Exception {

        SimpleListener listener1 = addListener(0, ALL_EVENTS, null, false, null, null, false);

        EventListener listener2 = addListener(0, ALL_EVENTS, null, false, null, null, false);

        assertThat("Wrong number of event listeners.", getObservationManager().getRegisteredEventListeners().getSize(), is(2L));

        // now remove

        removeListener(listener1);

        assertThat("Wrong number of event listeners after removing a listener.",

                   getObservationManager().getRegisteredEventListeners().getSize(),

                   is(1L));

        assertThat("Wrong number of event listeners after removing a listener.",

                   getObservationManager().getRegisteredEventListeners().nextEventListener(),

                   is(listener2));

    }

    @Test

    @FixFor( "MODE-1407" )

    public void shouldTestLockingTest_testAddLockToNode() throws Exception {

        // setup

        String node1 = "node1";

        Node lockable = getRoot().addNode(node1, UNSTRUCTURED);

        lockable.addMixin(LOCK_MIXIN);

        save();

        // register listener

        SimpleListener listener = addListener(2, 2, Event.PROPERTY_ADDED, getRoot().getPath(), true, null, null, false);

        // lock node (no save needed)

        session.getWorkspace().getLockManager().lock(lockable.getPath(), false, true, 1L, "me");

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        assertTrue("No event created for " + LOCK_OWNER, containsPath(listener, lockable.getPath() + '/' + LOCK_OWNER));

        assertTrue("No event created for " + LOCK_IS_DEEP, containsPath(listener, lockable.getPath() + '/' + LOCK_IS_DEEP));

    }

    @Test

    @FixFor( "MODE-1407" )

    public void shouldTestLockingTest_testRemoveLockFromNode() throws Exception {

        // setup

        String node1 = "node1";

        Node lockable = getRoot().addNode(node1, UNSTRUCTURED);

        lockable.addMixin(LOCK_MIXIN);

        save();

        session.getWorkspace().getLockManager().lock(lockable.getPath(), false, true, 1L, "me");

        // register listener

        SimpleListener listener = addListener(2, Event.PROPERTY_REMOVED, null, false, null, null, false);

        // lock node (no save needed)

        session.getWorkspace().getLockManager().unlock(lockable.getPath());

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        assertTrue("No event created for " + LOCK_OWNER, containsPath(listener, lockable.getPath() + '/' + LOCK_OWNER));

        assertTrue("No event created for " + LOCK_IS_DEEP, containsPath(listener, lockable.getPath() + '/' + LOCK_IS_DEEP));

    }

    // ===========================================================================================================================

    // @see org.apache.jackrabbit.test.api.observation.NodeAddedTest

    // ===========================================================================================================================

    /**

     * @see NodeAddedTest#testMultipleNodeAdded1()

     * @throws Exception

     */

    @Test

    public void shouldTestNodeAddedTest_testMultipleNodeAdded1() throws Exception {

        // register listener

        SimpleListener listener = addListener(2, Event.NODE_ADDED, null, false, null, null, false);

        // add a couple sibling nodes

        Node addedNode1 = getRoot().addNode("node1", UNSTRUCTURED);

        Node addedNode2 = getRoot().addNode("node2", UNSTRUCTURED);

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        assertTrue("Path for first added node is wrong", containsPath(listener, addedNode1.getPath()));

        assertTrue("Path for second added node is wrong", containsPath(listener, addedNode2.getPath()));

    }

    /**

     * @see NodeAddedTest#testMultipleNodeAdded2()

     * @throws Exception

     */

    @Test

    public void shouldTestNodeAddedTest_testMultipleNodeAdded2() throws Exception {

        // register listener

        SimpleListener listener = addListener(2, Event.NODE_ADDED, null, false, null, null, false);

        // add node and child node

        Node addedNode = getRoot().addNode("node1", UNSTRUCTURED);

        Node addedChildNode = addedNode.addNode("node2", UNSTRUCTURED);

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        assertTrue("Path for added node is wrong", containsPath(listener, addedNode.getPath()));

        assertTrue("Path for added child node is wrong", containsPath(listener, addedChildNode.getPath()));

    }

    /**

     * @see NodeAddedTest#testSingleNodeAdded()

     * @throws Exception

     */

    @Test

    public void shouldTestNodeAddedTest_testSingleNodeAdded() throws Exception {

        // register listener

        SimpleListener listener = addListener(1, Event.NODE_ADDED, null, false, null, null, false);

        // add node

        Node addedNode = getRoot().addNode("node1", UNSTRUCTURED);

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        assertTrue("Path for added node is wrong: actual=" + listener.getEvents().get(0).getPath() + ", expected="

                   + addedNode.getPath(),

                   containsPath(listener, addedNode.getPath()));

    }

    /**

     * @see NodeAddedTest#testTransientNodeAddedRemoved()

     * @throws Exception

     */

    @Test

    public void shouldTestNodeAddedTest_testTransientNodeAddedRemoved() throws Exception {

        // register listener

        SimpleListener listener = addListener(1, Event.NODE_ADDED, null, false, null, null, false);

        // add a child node and immediately remove it

        Node addedNode = getRoot().addNode("node1", UNSTRUCTURED);

        Node transientNode = addedNode.addNode("node2", UNSTRUCTURED); // should not get this event because of the following

        // remove

        transientNode.remove();

        save();

        // event handling

        listener.waitForEvents();

        removeListener(listener);

        // tests

        checkResults(listener);

        assertTrue("Path for added node is wrong: actual=" + listener.getEvents().get(0).getPath() + ", expected="