public void testClone() {
assertFalse(this.testModel.hasAnyPropertyChangeListeners(PROPERTY_NAME));
this.testModel.addPropertyChangeListener(this);
assertTrue(this.testModel.hasAnyPropertyChangeListeners(PROPERTY_NAME));
// verify that the clone does not have any listeners
TestModel clone = (TestModel) this.testModel.clone();
assertFalse(clone.hasAnyPropertyChangeListeners(PROPERTY_NAME));
clone.addPropertyChangeListener(this);
assertTrue(clone.hasAnyPropertyChangeListeners(PROPERTY_NAME));
// check original
assertTrue(this.testModel.hasAnyPropertyChangeListeners(PROPERTY_NAME));
// now test events fired by original
this.propertyChangeEvent = null;
this.propertyChangeCalled = false;
this.testModel.testFirePropertyChangeObjectObject();
this.verifyPropertyChangeEvent(OLD_OBJECT_VALUE, NEW_OBJECT_VALUE);
assertTrue(this.propertyChangeCalled);
// now test events fired by clone
this.propertyChangeEvent = null;
this.propertyChangeCalled = false;
clone.testFirePropertyChangeObjectObject();
this.verifyPropertyChangeEvent(clone, OLD_OBJECT_VALUE, NEW_OBJECT_VALUE);
assertTrue(this.propertyChangeCalled);
}
public void testSingleArgumentNamedProperty() {
TestModel testModel = new TestModel(7);
Target target = new Target(testModel, TestModel.VALUE_PROPERTY, 7, 99);
testModel.addPropertyChangeListener(
TestModel.VALUE_PROPERTY,
ReflectiveChangeListener.buildPropertyChangeListener(
target, "propertyChangedSingleArgument"));
testModel.setValue(99);
assertFalse(target.zeroArgumentFlag);
assertTrue(target.singleArgumentFlag);
}
@Test
public void enforced() {
Sprinkles.dropInstances();
Sprinkles s = Sprinkles.init(Robolectric.application);
s.addMigration(new Migration().createTable(TestModel.class));
TestModel m = new TestModel();
assertFalse(m.save());
m.title = "hej";
assertTrue(m.save());
}
public void testNodeAddedSingleArgument() {
TestModel testModel = new TestModel("root");
Target target = new Target(testModel, TestModel.STRINGS_TREE, new String[] {"root", "child"});
testModel.addTreeChangeListener(this.buildSingleArgumentListener(target));
testModel.addNode("root", "child");
assertFalse(target.nodeAddedZeroArgumentFlag);
assertTrue(target.nodeAddedSingleArgumentFlag);
assertFalse(target.nodeRemovedZeroArgumentFlag);
assertFalse(target.nodeRemovedSingleArgumentFlag);
assertFalse(target.treeChangedZeroArgumentFlag);
assertFalse(target.treeChangedSingleArgumentFlag);
}
/** test method that has more general method parameter type */
public void testSingleArgumentNamedProperty2() throws Exception {
TestModel testModel = new TestModel(7);
Target target = new Target(testModel, TestModel.VALUE_PROPERTY, 7, 99);
Method method =
ObjectTools.method(target, "propertyChangedSingleArgument2", new Class[] {Object.class});
testModel.addPropertyChangeListener(
TestModel.VALUE_PROPERTY,
ReflectiveChangeListener.buildPropertyChangeListener(target, method));
testModel.setValue(99);
assertFalse(target.zeroArgumentFlag);
assertTrue(target.singleArgumentFlag);
}
private void postEventInManualUpdateMode() {
// Generate an event which will cause all cache entries to be marked dirty.
fViewerListener.reset();
fViewerListener.addUpdates(
TreePath.EMPTY, fModel.getRootElement(), -1, ALL_UPDATES_COMPLETE | PROPERTY_UPDATES);
fVMListener.reset();
fFormattedValuesListener.reset();
fVMProvider.postEvent(new TestEvent(fModel.getRootElement(), IModelDelta.CONTENT));
while (!fViewerListener.isFinished(ALL_UPDATES_COMPLETE | PROPERTY_UPDATES))
if (!fDisplay.readAndDispatch()) fDisplay.sleep();
assertTrue(fFormattedValuesListener.getFormattedValuesCompleted().isEmpty());
}
@Override
public void run() {
try {
while (!isInterrupted()) {
testModel.setUp();
synchronized (renderLock) {
waitRefresh();
transform.set(nextTransform);
distance = nextDistance;
}
synchronized (backBuffer) {
raytrace();
if (!targetFile.isEmpty()) {
writeBufferToFile(backBuffer, targetFile);
return;
} else {
// flip buffers
BufferedImage tmp = backBuffer;
backBuffer = buffer;
buffer = tmp;
}
}
view.getCanvas().repaint();
}
} catch (InterruptedException e) {
}
}
/** helper to set preference to an invalid format and verify. */
void setInvalidPreferenceAndVerify() {
fViewerListener.reset();
fViewerListener.addUpdates(
TreePath.EMPTY,
((TestElementVMContext) fViewer.getInput()).getElement(),
-1,
ALL_UPDATES_COMPLETE | PROPERTY_UPDATES);
fVMListener.reset();
fVMListener.addUpdates(
TreePath.EMPTY, fModel.getRootElement(), -1, ALL_UPDATES_COMPLETE | PROPERTY_UPDATES);
fViewer
.getPresentationContext()
.setProperty(PROP_FORMATTED_VALUE_FORMAT_PREFERENCE, "invalid format");
while (!fViewerListener.isFinished(ALL_UPDATES_COMPLETE | PROPERTY_UPDATES)
|| !fVMListener.isFinished(CONTENT_UPDATES | PROPERTY_UPDATES)) {
if (!fDisplay.readAndDispatch()) {
fDisplay.sleep();
}
}
validateModel(
IFormattedValues.HEX_FORMAT,
" (" + FormattedValueVMUtil.getFormatLabel(IFormattedValues.HEX_FORMAT) + ")",
DummyFormattedValueService.DUMMY_FORMAT,
" (" + DummyFormattedValueService.DUMMY_FORMAT + ")");
}
/** helper to set element to an invalid format */
void setElementInvalidFormat() {
fViewerListener.reset();
fViewerListener.addUpdates(
TreePath.EMPTY,
((TestElementVMContext) fViewer.getInput()).getElement(),
-1,
ALL_UPDATES_COMPLETE | PROPERTY_UPDATES);
fVMListener.reset();
fVMListener.addUpdates(
TreePath.EMPTY, fModel.getRootElement(), -1, ALL_UPDATES_COMPLETE | PROPERTY_UPDATES);
HashMap<String, ElementFormatSetting> map = new HashMap<String, ElementFormatSetting>();
String[] format = {"invalid element format"};
makeElementFormatSetting(fViewer, TreePath.EMPTY, format, -1, 0, map);
ArrayList<ElementFormatSetting> elementFormats =
new ArrayList<ElementFormatSetting>(map.values());
if (fVMProvider instanceof IElementFormatProvider) {
IElementFormatProvider ep = ((IElementFormatProvider) fVMProvider);
for (ElementFormatSetting es : elementFormats) {
ep.setActiveFormat(
fViewer.getPresentationContext(),
es.nodes.toArray(new IVMNode[es.nodes.size()]),
fViewer.getInput(),
es.elementPaths.toArray(new TreePath[es.elementPaths.size()]),
es.formatId);
}
}
while (!fViewerListener.isFinished(ALL_UPDATES_COMPLETE | PROPERTY_UPDATES)
|| !fVMListener.isFinished(CONTENT_UPDATES | PROPERTY_UPDATES)) {
if (!fDisplay.readAndDispatch()) {
fDisplay.sleep();
}
}
}
public void testBogusDoubleArgument1() {
TestModel testModel = new TestModel("root");
testModel.addNode("root", "child");
Target target = new Target(testModel, TestModel.STRINGS_TREE, new String[] {"root", "child"});
boolean exCaught = false;
try {
TreeChangeListener listener =
ReflectiveChangeListener.buildTreeChangeListener(
target, "collectionChangedDoubleArgument");
fail("bogus listener: " + listener);
} catch (RuntimeException ex) {
if (ex.getCause().getClass() == NoSuchMethodException.class) {
exCaught = true;
}
}
assertTrue(exCaught);
}
/**
* Test that when the preference format is invalid, each element can still change to a format.
* Also, each element can restore to the invalid preference format such that the element uses
* first available format from service.
*/
public void testChangeElementFormatWithInvalidPreference() {
recreateViewModel();
String preferenceFormat = IFormattedValues.NATURAL_FORMAT;
setInput(preferenceFormat);
// set preference format to an invalid format and verify
setInvalidPreferenceAndVerify();
// set each element to a format, and verify
HashMap<String, ElementFormatSetting> map = new HashMap<String, ElementFormatSetting>();
String[] format = {
IFormattedValues.HEX_FORMAT,
IFormattedValues.DECIMAL_FORMAT,
IFormattedValues.OCTAL_FORMAT,
IFormattedValues.BINARY_FORMAT,
IFormattedValues.NATURAL_FORMAT
};
makeElementFormatSetting(fViewer, TreePath.EMPTY, format, -1, 0, map);
ArrayList<ElementFormatSetting> elementFormats =
new ArrayList<ElementFormatSetting>(map.values());
setFormatAndValidate("invalid format", elementFormats, elementFormats, false, false, false);
// Restore each element to preference format which is an invalid format
for (ElementFormatSetting e : elementFormats) {
e.formatId = null;
}
fViewerListener.reset();
fViewerListener.addUpdates(
TreePath.EMPTY,
((TestElementVMContext) fViewer.getInput()).getElement(),
-1,
ALL_UPDATES_COMPLETE | PROPERTY_UPDATES);
fVMListener.reset();
fVMListener.addUpdates(
TreePath.EMPTY, fModel.getRootElement(), -1, ALL_UPDATES_COMPLETE | PROPERTY_UPDATES);
if (fVMProvider instanceof IElementFormatProvider) {
IElementFormatProvider ep = ((IElementFormatProvider) fVMProvider);
for (ElementFormatSetting es : elementFormats) {
ep.setActiveFormat(
fViewer.getPresentationContext(),
es.nodes.toArray(new IVMNode[es.nodes.size()]),
fViewer.getInput(),
es.elementPaths.toArray(new TreePath[es.elementPaths.size()]),
es.formatId);
}
}
while (!fViewerListener.isFinished(ALL_UPDATES_COMPLETE | PROPERTY_UPDATES)
|| !fVMListener.isFinished(CONTENT_UPDATES | PROPERTY_UPDATES)) {
if (!fDisplay.readAndDispatch()) {
fDisplay.sleep();
}
}
// verify service's first available format is used
validateModel(
IFormattedValues.HEX_FORMAT,
" (" + FormattedValueVMUtil.getFormatLabel(IFormattedValues.HEX_FORMAT) + ")",
DummyFormattedValueService.DUMMY_FORMAT,
" (" + DummyFormattedValueService.DUMMY_FORMAT + ")");
}
/** @throws java.lang.Exception */
@Override
protected void setUp() throws Exception {
fDsfExecutor = new DefaultDsfExecutor();
fDsfSession = DsfSession.startSession(fDsfExecutor, getClass().getName());
fDisplay = PlatformUI.getWorkbench().getDisplay();
fShell = new Shell(fDisplay /*, SWT.ON_TOP | SWT.SHELL_TRIM*/);
fShell.setMaximized(true);
fShell.setLayout(new FillLayout());
fViewer = createViewer(fDisplay, fShell);
fModel = new TestModel(fDsfSession);
initializeService(fModel);
fDummyValuesService = new DummyFormattedValueService(fDsfSession);
initializeService(fDummyValuesService);
fViewerListener = new TestModelUpdatesListener(fViewer, true, false);
fModel.setRoot(new TestElement(fModel, "root", new TestElement[0]));
fModel.setElementChildren(
TreePath.EMPTY, makeModelElements(fModel, getTestModelDepth(), "model"));
fVMAdapter =
new AbstractVMAdapter() {
@Override
protected IVMProvider createViewModelProvider(IPresentationContext context) {
return fVMProvider;
}
};
fVMProvider =
new TestModelCachingVMProvider(fVMAdapter, fViewer.getPresentationContext(), fDsfSession);
fVMListener = new TestModelUpdatesListener();
fVMProvider.getNode().setVMUpdateListener(fVMListener);
fVMProvider.getNode().getLabelProvider().addPropertiesUpdateListener(fViewerListener);
fFormattedValuesListener = new FormattedValuesListener(fModel);
fVMProvider.getNode().setFormattedValuesListener(fFormattedValuesListener);
fModel.setTestModelListener(fFormattedValuesListener);
fShell.open();
}
public void testListenerMismatch() {
TestModel testModel = new TestModel(7);
Target target = new Target(testModel, TestModel.VALUE_PROPERTY, 7, 99);
// build a PROPERTY change listener and hack it so we
// can add it as a STATE change listener
Object listener =
ReflectiveChangeListener.buildPropertyChangeListener(
target, "propertyChangedSingleArgument");
testModel.addStateChangeListener((StateChangeListener) listener);
boolean exCaught = false;
try {
testModel.setValue(99);
fail("listener mismatch: " + listener);
} catch (IllegalArgumentException ex) {
exCaught = true;
}
assertTrue(exCaught);
}
public void testListenerMismatch() {
TestModel testModel = new TestModel("root");
testModel.addNode("root", "child");
Target target = new Target(testModel, TestModel.STRINGS_TREE, new String[] {"root", "child"});
// build a TREE change listener and hack it so we
// can add it as a COLLECTION change listener
Object listener =
ReflectiveChangeListener.buildTreeChangeListener(target, "nodeAddedSingleArgument");
testModel.addCollectionChangeListener((CollectionChangeListener) listener);
boolean exCaught = false;
try {
testModel.changeCollection();
fail("listener mismatch: " + listener);
} catch (IllegalArgumentException ex) {
exCaught = true;
}
assertTrue(exCaught);
}
private void validateModel(
final ArrayList<ElementFormatSetting> elementFormats,
final String formatId,
final String suffix,
final String dummyFormatId,
final String dummySuffix) {
fModel.validateData(
fViewer,
TreePath.EMPTY,
new TestElementValidator() {
@Override
public void validate(
TestElement modelElement, TestElement viewerElement, TreePath viewerPath) {
ViewerLabel label =
fViewer.getElementLabel(viewerPath, TestModelCachingVMProvider.COLUMN_ID);
assertEquals(modelElement.getID(), label.getText());
ElementFormatSetting elementFormat = null;
if (elementFormats != null) {
for (ElementFormatSetting es : elementFormats) {
if (es.elementPaths.indexOf(viewerPath) >= 0) {
elementFormat = es;
break;
}
}
}
label =
fViewer.getElementLabel(
viewerPath, TestModelCachingVMProvider.COLUMN_FORMATTED_VALUE);
if (elementFormat == null || elementFormat.formatId == null) {
assertEquals(
fModel.getFormattedValueText(modelElement, formatId) + suffix, label.getText());
} else {
String suffix =
elementFormat.formatId.equals(formatId)
? ""
: " (" + FormattedValueVMUtil.getFormatLabel(elementFormat.formatId) + ")";
assertEquals(
fModel.getFormattedValueText(modelElement, elementFormat.formatId) + suffix,
label.getText());
}
label =
fViewer.getElementLabel(viewerPath, TestModelCachingVMProvider.COLUMN_DUMMY_VALUE);
if (elementFormat == null || elementFormat.formatId == null) {
assertEquals(dummyFormatId + dummySuffix, label.getText());
} else {
String suffix =
elementFormat.formatId.equals(formatId)
? ""
: " (" + FormattedValueVMUtil.getFormatLabel(elementFormat.formatId) + ")";
assertEquals(elementFormat.formatId + suffix, label.getText());
}
}
});
}
/** Test for chain binding */
@Test
public void chainTest() {
TestModel model = new TestModel();
new PropertyBindingLink(
new ChainedBindingSource(model, "currentSelection", "currentName"),
new PropertyBindingTarget() {
@Override
public void updateTarget(Object newValue) {
receptedValue = newValue;
}
});
// awaiting null
Assert.assertEquals(null, receptedValue);
// setting the first chain element
TestSelection testSelection1 = new TestSelection();
model.setCurrentSelection(testSelection1);
// no update
Assert.assertEquals(null, receptedValue);
testSelection1.setCurrentName("my.test.1");
// new value : my.test.1
Assert.assertEquals("my.test.1", receptedValue);
// changing model selection
TestSelection testSelection2 = new TestSelection();
testSelection2.setCurrentName("my.test.2");
model.setCurrentSelection(testSelection2);
Assert.assertEquals("my.test.2", receptedValue);
// verifying terminated links
testSelection1.setCurrentName("changed.test.1");
Assert.assertNotSame("changed.test1", receptedValue);
// verifying link termination
model.setCurrentSelection(null);
Assert.assertEquals(null, receptedValue);
}
public void testBogusDoubleArgument2() throws Exception {
TestModel testModel = new TestModel("root");
testModel.addNode("root", "child");
Target target = new Target(testModel, TestModel.STRINGS_TREE, new String[] {"root", "child"});
Method method =
ClassTools.method(
target,
"collectionChangedDoubleArgument",
new Class[] {TreeChangeEvent.class, Object.class});
boolean exCaught = false;
try {
TreeChangeListener listener =
ReflectiveChangeListener.buildTreeChangeListener(target, method);
fail("bogus listener: " + listener);
} catch (RuntimeException ex) {
if (ex.getMessage().equals(method.toString())) {
exCaught = true;
}
}
assertTrue(exCaught);
}
/** @throws java.lang.Exception */
@Override
protected void tearDown() throws Exception {
fVMProvider.getNode().setFormattedValuesListener(null);
fModel.setTestModelListener(null);
fVMProvider.getNode().getLabelProvider().removePropertiesUpdateListener(fViewerListener);
fVMProvider.getNode().setVMUpdateListener(null);
fVMAdapter.dispose();
fVMListener.dispose();
fViewerListener.dispose();
shutdownService(fDummyValuesService);
shutdownService(fModel);
fViewer.getPresentationContext().dispose();
// Close the shell and exit.
fShell.close();
while (!fShell.isDisposed()) if (!fDisplay.readAndDispatch()) fDisplay.sleep();
DsfSession.endSession(fDsfSession);
fDsfExecutor.shutdown();
}
private void setUpdatePolicy(String policyId) {
IVMUpdatePolicy[] policies = fVMProvider.getAvailableUpdatePolicies();
IVMUpdatePolicy newPolicy = null;
for (IVMUpdatePolicy policy : policies) {
if (policyId.equals(policy.getID())) {
newPolicy = policy;
break;
}
}
if (newPolicy != null) {
fVMProvider.setActiveUpdatePolicy(newPolicy);
} else {
throw new RuntimeException("Update policy " + policyId + " not available");
}
fViewerListener.reset();
fViewerListener.addUpdates(
TreePath.EMPTY, fModel.getRootElement(), -1, ALL_UPDATES_COMPLETE | PROPERTY_UPDATES);
fVMListener.setFailOnRedundantUpdates(false);
while (!fViewerListener.isFinished(ALL_UPDATES_COMPLETE | PROPERTY_UPDATES))
if (!fDisplay.readAndDispatch()) fDisplay.sleep();
fVMListener.setFailOnRedundantUpdates(true);
}
/** Initial format is NATURAL. */
private void setInput(String formatId) {
// Set the new number format to the viewer.
fViewer.getPresentationContext().setProperty(PROP_FORMATTED_VALUE_FORMAT_PREFERENCE, formatId);
fViewer.setAutoExpandLevel(-1);
TestElementVMContext rootVMC =
fVMProvider.getElementVMContext(fViewer.getPresentationContext(), fModel.getRootElement());
// Create the listener
fViewerListener.reset();
fViewerListener.addUpdates(
TreePath.EMPTY, rootVMC.getElement(), -1, ALL_UPDATES_COMPLETE | PROPERTY_UPDATES);
fVMListener.reset();
fVMListener.addUpdates(
TreePath.EMPTY, rootVMC.getElement(), -1, ALL_UPDATES_COMPLETE | PROPERTY_UPDATES);
fFormattedValuesListener.reset();
fViewer.setInput(rootVMC);
while (!fViewerListener.isFinished(ALL_UPDATES_COMPLETE | PROPERTY_UPDATES)
|| !fVMListener.isFinished(CONTENT_COMPLETE | PROPERTY_UPDATES))
if (!fDisplay.readAndDispatch()) fDisplay.sleep();
assertTrue(fFormattedValuesListener.isFinished());
}
private void renderTestModel(Ray ray) {
renderCompass(ray);
ray.t = Double.POSITIVE_INFINITY;
testModel.intersect(ray);
}
private void setFormatAndValidate(
String formatId,
ArrayList<ElementFormatSetting> setElementFormats,
ArrayList<ElementFormatSetting> expectElementFormats,
boolean expectContentCached,
boolean expectFormattedValuesCached,
boolean expectCacheMissError) {
fViewerListener.reset();
fViewerListener.addUpdates(
TreePath.EMPTY,
((TestElementVMContext) fViewer.getInput()).getElement(),
-1,
ALL_UPDATES_COMPLETE | PROPERTY_UPDATES);
fVMListener.reset();
int vmUpdateFlags = PROPERTY_UPDATES;
if (!expectContentCached) {
vmUpdateFlags |= ALL_UPDATES_COMPLETE;
}
fVMListener.addUpdates(TreePath.EMPTY, fModel.getRootElement(), vmListenerLevel, vmUpdateFlags);
fFormattedValuesListener.reset();
if (expectFormattedValuesCached && !expectCacheMissError) {
fFormattedValuesListener.setCachedFormats(new String[] {formatId});
}
if (fVMProvider instanceof IElementFormatProvider && setElementFormats != null) {
IElementFormatProvider ep = ((IElementFormatProvider) fVMProvider);
for (ElementFormatSetting es : setElementFormats) {
ep.setActiveFormat(
fViewer.getPresentationContext(),
es.nodes.toArray(new IVMNode[es.nodes.size()]),
fViewer.getInput(),
es.elementPaths.toArray(new TreePath[es.elementPaths.size()]),
es.formatId);
}
} else {
// Set the new number format to the viewer.
fViewer
.getPresentationContext()
.setProperty(PROP_FORMATTED_VALUE_FORMAT_PREFERENCE, formatId);
}
while (!fViewerListener.isFinished(ALL_UPDATES_COMPLETE | PROPERTY_UPDATES)
|| !fVMListener.isFinished(CONTENT_UPDATES | PROPERTY_UPDATES))
if (!fDisplay.readAndDispatch()) fDisplay.sleep();
if (expectCacheMissError) {
try {
validateModel(expectElementFormats, formatId, "", formatId, "");
throw new RuntimeException("Expected validateModel to fail");
} catch (AssertionFailedError e) {
// expected
}
} else {
validateModel(expectElementFormats, formatId, "", formatId, "");
}
if (expectCacheMissError) {
String formatProperty = FormattedValueVMUtil.getPropertyForFormatId(formatId);
assertTrue(fFormattedValuesListener.getFormattedValuesCompleted().isEmpty());
assertFalse(fFormattedValuesListener.getPropertiesUpdates().isEmpty());
for (IPropertiesUpdate update : fFormattedValuesListener.getPropertiesUpdates()) {
PropertiesUpdateStatus status = (PropertiesUpdateStatus) update.getStatus();
assertEquals(IDsfStatusConstants.INVALID_STATE, status.getCode());
ElementFormatSetting elementFormat = null;
if (expectElementFormats != null) {
TreePath viewerPath = update.getElementPath();
for (ElementFormatSetting es : expectElementFormats) {
if (es.elementPaths.indexOf(viewerPath) >= 0) {
elementFormat = es;
break;
}
}
}
if (elementFormat != null) {
assertEquals(
"Cache contains stale data. Refresh view.",
status
.getStatus(FormattedValueVMUtil.getPropertyForFormatId(elementFormat.formatId))
.getMessage());
} else {
assertEquals(
"Cache contains stale data. Refresh view.",
status.getStatus(formatProperty).getMessage());
}
assertEquals(
"Cache contains stale data. Refresh view.",
status.getStatus(PROP_FORMATTED_VALUE_ACTIVE_FORMAT_VALUE).getMessage());
assertEquals(1, status.getChildren().length);
}
} else {
assertTrue(fFormattedValuesListener.isFinished());
}
}
/**
* Helper method to build a test instance without ID, but a value.
*
* @param value
* @return
*/
private TestModel buildTestInstanceWithValue(String value) {
TestModel tm = new TestModel();
tm.setTestValue(value);
return tm;
}
@Test
public void testMerge() throws Exception {
_sourceInputsBuffer = new DataOutputBuffer(16348 * 4);
_sourceInputsTrackingFilter = new URLFPBloomFilter(100000, NUM_HASH_FUNCTIONS, NUM_BITS);
MockCollectorReporter collector = new MockCollectorReporter();
TestModel inputModel = new TestModel();
TestModel outputModel = new TestModel();
ArrayList<Pair<TextBytes, TextBytes>> initialTupleList =
new ArrayList<Pair<TextBytes, TextBytes>>();
///////////////////////////
// STEP:1
///////////////////////////
// populate an initial list of tuples ...
// crawl url 1 with http 200 crawl status
initialTupleList.add(
generateTestRecord(
inputModel,
CANNED_CRAWL_URL_1,
CANNED_TIMESTAMP_2,
false,
TestRecordType.CRAWL_STATUS,
null));
// crawl url 1 with failure
initialTupleList.add(
generateTestRecord(
inputModel,
CANNED_CRAWL_URL_1,
CANNED_TIMESTAMP_1,
true,
TestRecordType.CRAWL_STATUS,
null));
// inlinks into crawl url 1 ...
initialTupleList.add(
generateTestRecord(
inputModel,
CANNED_CRAWL_URL_1,
CANNED_TIMESTAMP_1,
true,
TestRecordType.INLINK,
new ImmutableMap.Builder<String, String>()
.put(
EXTRA_PROPERTY_LINK_SOURCE,
sourceURLToLinkingHostURL(CANNED_CRAWL_URL_1, CANNED_LINKING_HOST_1))
.build()));
initialTupleList.add(
generateTestRecord(
inputModel,
CANNED_CRAWL_URL_1,
CANNED_TIMESTAMP_1,
true,
TestRecordType.INLINK,
new ImmutableMap.Builder<String, String>()
.put(
EXTRA_PROPERTY_LINK_SOURCE,
sourceURLToLinkingHostURL(CANNED_CRAWL_URL_1, CANNED_LINKING_HOST_2))
.build()));
// crawl url 2 crawl status
initialTupleList.add(
generateTestRecord(
inputModel,
CANNED_CRAWL_URL_2,
CANNED_TIMESTAMP_1,
true,
TestRecordType.CRAWL_STATUS,
null));
// inlink into crawl url 3 with no crawl status
initialTupleList.add(
generateTestRecord(
inputModel,
CANNED_CRAWL_URL_3,
CANNED_TIMESTAMP_1,
true,
TestRecordType.INLINK,
new ImmutableMap.Builder<String, String>()
.put(
EXTRA_PROPERTY_LINK_SOURCE,
sourceURLToLinkingHostURL(CANNED_CRAWL_URL_3, CANNED_LINKING_HOST_1))
.build()));
initialTupleList.add(
generateTestRecord(
inputModel,
CANNED_CRAWL_URL_3,
CANNED_TIMESTAMP_1,
true,
TestRecordType.INLINK,
new ImmutableMap.Builder<String, String>()
.put(
EXTRA_PROPERTY_LINK_SOURCE,
sourceURLToLinkingHostURL(CANNED_CRAWL_URL_3, CANNED_LINKING_HOST_2))
.build()));
initialTupleList.add(
generateTestRecord(
inputModel,
CANNED_CRAWL_URL_3,
CANNED_TIMESTAMP_1,
true,
TestRecordType.INLINK,
new ImmutableMap.Builder<String, String>()
.put(
EXTRA_PROPERTY_LINK_SOURCE,
sourceURLToLinkingHostURL(CANNED_CRAWL_URL_3, CANNED_URL_3_HOST))
.build()));
// run reducer ...
reduceTestTuples(initialTupleList, collector, collector);
close();
System.out.println("STEP:1 DONE#########################################");
///////////////////////////
// STEP:2
///////////////////////////
// reset bloom filter ...
_sourceInputsTrackingFilter = new URLFPBloomFilter(100000, NUM_HASH_FUNCTIONS, NUM_BITS);
// swap items ...
ArrayList<Pair<TextBytes, TextBytes>> tuples = collector.items;
collector.items = new ArrayList<Pair<TextBytes, TextBytes>>();
// tuples for step 2.
// another failure for crawl url 1
tuples.add(
generateTestRecord(
inputModel,
CANNED_CRAWL_URL_1,
CANNED_TIMESTAMP_3,
true,
TestRecordType.CRAWL_STATUS,
null));
// inlink to crawl url 1
tuples.add(
generateTestRecord(
inputModel,
CANNED_CRAWL_URL_1,
CANNED_TIMESTAMP_3,
true,
TestRecordType.INLINK,
new ImmutableMap.Builder<String, String>()
.put(
EXTRA_PROPERTY_LINK_SOURCE,
sourceURLToLinkingHostURL(CANNED_CRAWL_URL_1, CANNED_LINKING_HOST_3))
.build()));
// crawl status from crawl url4 with a redirect from crawl url 5
tuples.add(
generateTestRecord(
inputModel,
CANNED_CRAWL_URL_4,
CANNED_TIMESTAMP_1,
true,
TestRecordType.CRAWL_STATUS_WITH_REDIRECT,
new ImmutableMap.Builder<String, String>()
.put(EXTRA_PROPERTY_REDIRECT_SOURCE, CANNED_CRAWL_URL_5)
.build()));
// reduce
reduceTestTuples(tuples, collector, collector);
close();
System.out.println("STEP:2 DONE#########################################");
///////////////////////////
// STEP:3
///////////////////////////
// reset bloom filter ...
_sourceInputsTrackingFilter = new URLFPBloomFilter(100000, NUM_HASH_FUNCTIONS, NUM_BITS);
// swap items ...
tuples = collector.items;
collector.items = new ArrayList<Pair<TextBytes, TextBytes>>();
// run reducer again to pick up redirect record
reduceTestTuples(tuples, collector, collector);
close();
System.out.println("STEP:3 DONE#########################################");
// dump tuples
System.out.println("TUPLES DUMP STARTING#########################################");
dumpTuples(collector.items);
System.out.println("TUPLES DUMP COMPLETE#########################################");
// feed final tuple set to output model ...
outputModel.buildModelFromOutputTuples(collector.items);
// model comparison
System.out.println("MODEL COMP STARTING#########################################");
Assert.assertEquals(inputModel.compareTo(outputModel), 0);
System.out.println("MODEL COMP DONE #########################################");
}
static Pair<TextBytes, TextBytes> generateTestRecord(
TestModel model,
String url,
long timestamp,
boolean success,
TestRecordType recordType,
Map<String, String> extraProperties)
throws Exception {
Pair<TextBytes, TextBytes> result = null;
if (recordType == TestRecordType.CRAWL_STATUS
|| recordType == TestRecordType.CRAWL_STATUS_WITH_REDIRECT) {
JsonObject topObject = new JsonObject();
topObject.addProperty("source_url", url);
topObject.addProperty("disposition", (success) ? "SUCCESS" : "FAILURE");
topObject.addProperty("attempt_time", timestamp);
if (success) {
topObject.addProperty("http_result", 200);
topObject.addProperty("server_ip", CANNED_IP);
topObject.addProperty("content_len", CANNED_CONTENT_LEN);
topObject.addProperty("mime_type", CANNED_MIME_TYPE);
topObject.addProperty("md5", CANNED_MD5_VALUE);
topObject.addProperty("text_simhash", CANNED_SIMHASH_VALUE);
JsonObject headers = new JsonObject();
headers.addProperty("date", timestamp);
topObject.add("http_headers", headers);
topObject.addProperty("parsed_as", "html");
JsonObject content = new JsonObject();
content.addProperty("title", CANNED_TITLE);
JsonArray metaTags = new JsonArray();
JsonObject metaTag = new JsonObject();
metaTag.addProperty(CANNED_META_PROPERTY_NAME, CANNED_META_PROPERTY_VALUE);
metaTags.add(metaTag);
content.add("meta_tags", metaTags);
topObject.add("content", content);
JsonArray links = new JsonArray();
JsonObject link1 = new JsonObject();
link1.addProperty("href", sourceURLToLinkingHostURL(url, CANNED_LINKING_HOST_1));
JsonObject link2 = new JsonObject();
link2.addProperty("href", sourceURLToLinkingHostURL(url, CANNED_LINKING_HOST_2));
links.add(link1);
links.add(link2);
topObject.add("links", links);
if (recordType == TestRecordType.CRAWL_STATUS_WITH_REDIRECT) {
JsonObject redirectObject = new JsonObject();
redirectObject.addProperty(
"source_url", extraProperties.get(EXTRA_PROPERTY_REDIRECT_SOURCE));
redirectObject.addProperty("http_result", 301);
redirectObject.addProperty("server_ip", CANNED_IP);
topObject.add("redirect_from", redirectObject);
}
} else {
topObject.addProperty("failure_reason", CANNED_FAILURE_REASON);
topObject.addProperty("failure_detail", CANNED_FAILURE_DETAIL);
}
TextBytes keyOut = new TextBytes(CrawlDBKey.generateCrawlStatusKey(new Text(url), timestamp));
TextBytes valueOut = new TextBytes(topObject.toString());
result = new Pair<TextBytes, TextBytes>(keyOut, valueOut);
} else {
JsonObject linkData = new JsonObject();
linkData.addProperty("href", url);
linkData.addProperty("source_url", extraProperties.get(EXTRA_PROPERTY_LINK_SOURCE));
linkData.addProperty("http_result", 200);
linkData.addProperty("server_ip", CANNED_IP);
linkData.addProperty("source_type", "html");
linkData.addProperty("type", "a");
linkData.addProperty("rel", "text/html");
TextBytes keyOut =
new TextBytes(
CrawlDBKey.generateLinkKey(
new TextBytes(url),
CrawlDBKey.Type.KEY_TYPE_HTML_LINK,
MD5Hash.digest(extraProperties.get(EXTRA_PROPERTY_LINK_SOURCE)).toString()));
TextBytes valueOut = new TextBytes(linkData.toString());
result = new Pair<TextBytes, TextBytes>(keyOut, valueOut);
}
model.updateModelFromInputTuple(result);
return result;
}
