/*
* See the NOTICE file distributed with this work for additional
* information regarding copyright ownership.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package com.xpn.xwiki.notify;
import org.jmock.Mock;
import org.jmock.core.constraint.IsEqual;
import com.xpn.xwiki.XWiki;
import com.xpn.xwiki.XWikiContext;
import com.xpn.xwiki.XWikiException;
import com.xpn.xwiki.doc.XWikiDocument;
import com.xpn.xwiki.objects.BaseObject;
import com.xpn.xwiki.objects.classes.BaseClass;
import com.xpn.xwiki.test.AbstractBridgedXWikiComponentTestCase;
import org.xwiki.model.reference.DocumentReference;
/**
* Tests the {@link PropertyChangedRule} in the notification mechanism. <br>
* The tests are done for the {@link DocChangeRule#verify(XWikiDocument, XWikiDocument, XWikiContext)} function and,
* since this function should be symmetric with respect to its two document parameters, all the tests are done symmetric
* too: each test function contains two asserttions, one for the result of <tt>verify(newdoc, olddoc, context)</tt>
* and the other one for <tt>verify(olddoc, newdoc, context)</tt>; some tests cases might be duplicated by the
* symmetric call in another test function.
*/
@Deprecated
public class PropertyChangedRuleTest extends AbstractBridgedXWikiComponentTestCase
implements XWikiDocChangeNotificationInterface
{
private PropertyChangedRule rule;
private XWikiDocument classDoc;
private String testClassName = "Test.TestClass";
private DocumentReference testClassReference = new DocumentReference("Test", "Test", "TestClass");
private BaseClass testClass;
private BaseClass otherClass;
private String otherClassName = "Test.OtherClass";
private DocumentReference testOtherClassReference = new DocumentReference("Test", "Test", "OtherClass");
private String testPropertyName = "field";
private XWikiContext context;
private Mock mockXWiki;
private boolean passed;
/**
* Creates 2 classes: one that would actually be used to create objects and check property changes and the other one
* to be able to test behaviour when the document contains more than one type of objects. Creates a xwiki mock that
* only returns the above mentioned classes on {@link XWiki#getClass(String, XWikiContext)}.
*/
protected void setUp() throws Exception
{
super.setUp();
this.context = new XWikiContext();
this.mockXWiki = mock(XWiki.class);
this.mockXWiki.stubs().method("getXClass").with(new IsEqual(testClassReference), new IsEqual(this.context))
.will(returnValue(this.testClass));
this.mockXWiki.stubs().method("getXClass").with(new IsEqual(testOtherClassReference), new IsEqual(this.context))
.will(returnValue(this.otherClass));
this.context.setWiki((XWiki) this.mockXWiki.proxy());
this.classDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestClass"));
this.testClass = this.classDoc.getXClass();
testClass.addTextField(this.testPropertyName, this.testPropertyName, 10);
XWikiDocument otherClassDoc = new XWikiDocument(new DocumentReference("Test", "Test", "OtherClass"));
this.otherClass = otherClassDoc.getXClass();
// Just to make tests a little more interesting
this.otherClass.addTextField(this.testPropertyName, this.testPropertyName, 10);
this.rule = new PropertyChangedRule(this, this.testClassName, this.testPropertyName);
}
public void testVerifySingleObjectNotChanged() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject oldObj = oldDoc.newObject(this.testClassName, this.context);
BaseObject newObj = newDoc.newObject(this.testClassName, this.context);
oldObj.setStringValue(this.testPropertyName, "value");
newObj.setStringValue(this.testPropertyName, "value");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
// The rule should be symmetric. Do the inverse test too
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
}
public void testVerifySingleObjectChanged() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject oldObj = oldDoc.newObject(this.testClassName, this.context);
BaseObject newObj = newDoc.newObject(this.testClassName, this.context);
oldObj.setStringValue(this.testPropertyName, "value1");
newObj.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertTrue("My notification should have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertTrue("My notification should have been called", this.passed);
}
public void testVerifySingleObjectXWikiClassNotChanged() throws XWikiException
{
XWikiDocument newDoc = this.classDoc.clone();
XWikiDocument oldDoc = this.classDoc.clone();
BaseObject oldObj = oldDoc.newObject(this.testClassName, this.context);
BaseObject newObj = newDoc.newObject(this.testClassName, this.context);
oldObj.setStringValue(this.testPropertyName, "value");
newObj.setStringValue(this.testPropertyName, "value");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
}
public void testVerifyMultipleObjectsXWikiClassNotChanged() throws XWikiException
{
XWikiDocument newDoc = this.classDoc.clone();
XWikiDocument oldDoc = this.classDoc.clone();
BaseObject otherOldObject = oldDoc.newObject(this.otherClassName, this.context);
BaseObject oldObj = oldDoc.newObject(this.testClassName, this.context);
BaseObject otherNewObject = newDoc.newObject(this.otherClassName, this.context);
BaseObject newObj = newDoc.newObject(this.testClassName, this.context);
otherOldObject.setStringValue(this.testPropertyName, "value1");
oldObj.setStringValue(this.testPropertyName, "value");
otherNewObject.setStringValue(this.testPropertyName, "value1");
newObj.setStringValue(this.testPropertyName, "value");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
}
public void testVerifyMultipleObjectsXWikiClassChanged() throws XWikiException
{
XWikiDocument newDoc = this.classDoc.clone();
XWikiDocument oldDoc = this.classDoc.clone();
BaseObject otherOldObject = oldDoc.newObject(this.otherClassName, this.context);
BaseObject oldObj = oldDoc.newObject(this.testClassName, this.context);
BaseObject otherNewObject = newDoc.newObject(this.otherClassName, this.context);
BaseObject newObj = newDoc.newObject(this.testClassName, this.context);
otherOldObject.setStringValue(this.testPropertyName, "value1");
oldObj.setStringValue(this.testPropertyName, "value1");
otherNewObject.setStringValue(this.testPropertyName, "value1");
newObj.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertTrue("My notification should have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertTrue("My notification should have been called", this.passed);
}
public void testVerifySingleObjectXWikiClassChanged() throws XWikiException
{
XWikiDocument newDoc = this.classDoc.clone();
XWikiDocument oldDoc = this.classDoc.clone();
BaseObject oldObj = oldDoc.newObject(this.testClassName, this.context);
BaseObject newObj = newDoc.newObject(this.testClassName, this.context);
oldObj.setStringValue(this.testPropertyName, "value1");
newObj.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertTrue("My notification should have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertTrue("My notification should have been called", this.passed);
}
public void testVerifyMultipleObjectsMultipleXWikiClassChanged() throws XWikiException
{
XWikiDocument newDoc = this.classDoc.clone();
XWikiDocument oldDoc = this.classDoc.clone();
BaseObject otherOldObject = oldDoc.newObject(this.otherClassName, this.context);
BaseObject oldObj = oldDoc.newObject(this.testClassName, this.context);
BaseObject oldObj2 = oldDoc.newObject(this.testClassName, this.context);
BaseObject otherNewObject = newDoc.newObject(this.otherClassName, this.context);
BaseObject newObj = newDoc.newObject(this.testClassName, this.context);
BaseObject newObj2 = newDoc.newObject(this.testClassName, this.context);
otherOldObject.setStringValue(this.testPropertyName, "value1");
oldObj.setStringValue(this.testPropertyName, "value1");
oldObj2.setStringValue(this.testPropertyName, "value2");
otherNewObject.setStringValue(this.testPropertyName, "value1");
newObj.setStringValue(this.testPropertyName, "value1");
newObj2.setStringValue(this.testPropertyName, "value3");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertTrue("My notification should have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertTrue("My notification should have been called", this.passed);
}
public void testVerifyMultipleObjectsMultipleXWikiClassNotChanged() throws XWikiException
{
XWikiDocument newDoc = this.classDoc.clone();
XWikiDocument oldDoc = this.classDoc.clone();
BaseObject otherOldObject = oldDoc.newObject(this.otherClassName, this.context);
BaseObject oldObj = oldDoc.newObject(this.testClassName, this.context);
BaseObject oldObj2 = oldDoc.newObject(this.testClassName, this.context);
BaseObject otherNewObject = newDoc.newObject(this.otherClassName, this.context);
BaseObject newObj = newDoc.newObject(this.testClassName, this.context);
BaseObject newObj2 = newDoc.newObject(this.testClassName, this.context);
otherOldObject.setStringValue(this.testPropertyName, "value1");
oldObj.setStringValue(this.testPropertyName, "value1");
oldObj2.setStringValue(this.testPropertyName, "value2");
otherNewObject.setStringValue(this.testPropertyName, "value1");
newObj.setStringValue(this.testPropertyName, "value1");
newObj2.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
}
public void testVerifyObjectAdded() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject newObj = newDoc.newObject(this.testClassName, this.context);
newObj.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertTrue("My notification should have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertTrue("My notification should have been called", this.passed);
}
public void testVerifyObjectDeleted() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject oldObj = oldDoc.newObject(this.testClassName, this.context);
oldObj.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertTrue("My notification should have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertTrue("My notification should have been called", this.passed);
}
public void testVerifyNoObjectOfClassObjectDeleted() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject oldObj = oldDoc.newObject(this.testClassName, this.context);
BaseObject newObj = newDoc.newObject(this.otherClassName, this.context);
newObj.setStringValue(this.testPropertyName, "value1");
oldObj.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertTrue("My notification should have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertTrue("My notification should have been called", this.passed);
}
public void testVerifyNoObjectOfClass() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject oldObj = oldDoc.newObject(this.otherClassName, this.context);
BaseObject newObj = newDoc.newObject(this.otherClassName, this.context);
newObj.setStringValue(this.testPropertyName, "value1");
oldObj.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
}
public void testVerifyMultipleObjectsPropertyNotChanged() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject newObj1 = newDoc.newObject(this.testClassName, this.context);
newObj1.setStringValue(this.testPropertyName, "value1");
BaseObject newObj2 = newDoc.newObject(this.testClassName, this.context);
newObj2.setStringValue(this.testPropertyName, "value2");
BaseObject oldObj1 = oldDoc.newObject(this.testClassName, this.context);
oldObj1.setStringValue(this.testPropertyName, "value1");
BaseObject oldObj2 = oldDoc.newObject(this.testClassName, this.context);
oldObj2.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
}
public void testVerifyMultipleObjectsPropertyChanged() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject newObj1 = newDoc.newObject(this.testClassName, this.context);
newObj1.setStringValue(this.testPropertyName, "value1");
BaseObject newObj2 = newDoc.newObject(this.testClassName, this.context);
newObj2.setStringValue(this.testPropertyName, "value2");
BaseObject oldObj1 = oldDoc.newObject(this.testClassName, this.context);
oldObj1.setStringValue(this.testPropertyName, "value1");
BaseObject oldObj2 = oldDoc.newObject(this.testClassName, this.context);
oldObj2.setStringValue(this.testPropertyName, "value3");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertTrue("My notification should have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertTrue("My notification should have been called", this.passed);
}
public void testVerifyMultipleObjectsOtherObjectAdded() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject newObj1 = newDoc.newObject(this.testClassName, this.context);
newObj1.setStringValue(this.testPropertyName, "value1");
BaseObject newObjOtherClass = newDoc.newObject(this.otherClassName, this.context);
newObjOtherClass.setStringValue(this.testPropertyName, "value2");
BaseObject newObj2 = newDoc.newObject(this.testClassName, this.context);
newObj2.setStringValue(this.testPropertyName, "value2");
BaseObject oldObj1 = oldDoc.newObject(this.testClassName, this.context);
oldObj1.setStringValue(this.testPropertyName, "value1");
BaseObject oldObj2 = oldDoc.newObject(this.testClassName, this.context);
oldObj2.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
}
public void testVerifyMultipleObjectsOtherObjectDeleted() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject newObj1 = newDoc.newObject(this.testClassName, this.context);
newObj1.setStringValue(this.testPropertyName, "value1");
BaseObject newObj2 = newDoc.newObject(this.testClassName, this.context);
newObj2.setStringValue(this.testPropertyName, "value2");
BaseObject oldObj1 = oldDoc.newObject(this.testClassName, this.context);
oldObj1.setStringValue(this.testPropertyName, "value1");
BaseObject oldObjOtherClass = oldDoc.newObject(this.otherClassName, this.context);
oldObjOtherClass.setStringValue(this.testPropertyName, "value2");
BaseObject oldObj2 = oldDoc.newObject(this.testClassName, this.context);
oldObj2.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertFalse("My notification should not have been called", this.passed);
}
public void testVerifyMultipleObjectsObjectAdded() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject newObj1 = newDoc.newObject(this.testClassName, this.context);
newObj1.setStringValue(this.testPropertyName, "value1");
BaseObject newObj2 = newDoc.newObject(this.testClassName, this.context);
newObj2.setStringValue(this.testPropertyName, "value2");
BaseObject oldObj1 = oldDoc.newObject(this.testClassName, this.context);
oldObj1.setStringValue(this.testPropertyName, "value1");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertTrue("My notification should have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertTrue("My notification should have been called", this.passed);
}
public void testVerifyMultipleObjectsObjectDeleted() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject newObj1 = newDoc.newObject(this.testClassName, this.context);
newObj1.setStringValue(this.testPropertyName, "value1");
BaseObject oldObj1 = oldDoc.newObject(this.testClassName, this.context);
oldObj1.setStringValue(this.testPropertyName, "value1");
BaseObject oldObj2 = oldDoc.newObject(this.testClassName, this.context);
oldObj2.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertTrue("My notification should have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertTrue("My notification should have been called", this.passed);
}
public void testVerifyMultipleObjectsOtherObjectAddedPropertyChanged() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject newObj1 = newDoc.newObject(this.testClassName, this.context);
newObj1.setStringValue(this.testPropertyName, "value1");
BaseObject newObjOtherClass = newDoc.newObject(this.otherClassName, this.context);
newObjOtherClass.setStringValue(this.testPropertyName, "value2");
BaseObject newObj2 = newDoc.newObject(this.testClassName, this.context);
newObj2.setStringValue(this.testPropertyName, "value3");
BaseObject oldObj1 = oldDoc.newObject(this.testClassName, this.context);
oldObj1.setStringValue(this.testPropertyName, "value1");
BaseObject oldObj2 = oldDoc.newObject(this.testClassName, this.context);
oldObj2.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertTrue("My notification should have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertTrue("My notification should have been called", this.passed);
}
public void testVerifyMultipleObjectsClassChanged() throws XWikiException
{
XWikiDocument newDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
XWikiDocument oldDoc = new XWikiDocument(new DocumentReference("Test", "Test", "TestDoc"));
BaseObject newObj1 = newDoc.newObject(this.testClassName, this.context);
newObj1.setStringValue(this.testPropertyName, "value1");
BaseObject newObjOtherClass = newDoc.newObject(this.otherClassName, this.context);
newObjOtherClass.setStringValue(this.testPropertyName, "value2");
BaseObject oldObj1 = oldDoc.newObject(this.testClassName, this.context);
oldObj1.setStringValue(this.testPropertyName, "value1");
BaseObject oldObj2 = oldDoc.newObject(this.testClassName, this.context);
oldObj2.setStringValue(this.testPropertyName, "value2");
this.passed = false;
this.rule.verify(newDoc, oldDoc, this.context);
assertTrue("My notification should have been called", this.passed);
// The rule should be symmetric. Do the inverse test too.
this.passed = false;
this.rule.verify(oldDoc, newDoc, this.context);
assertTrue("My notification should have been called", this.passed);
}
public void notify(XWikiNotificationRule rule, XWikiDocument newdoc, XWikiDocument olddoc, int event,
XWikiContext context)
{
this.passed = true;
}
}