public static Triple read(final ObjectInputStream in) throws IOException { try { return new Triple(in.readUTF(), in.readUTF(), in.readUTF(), (ObjectType) in.readObject()); } catch (final ClassNotFoundException e) { throw new IOException("Cannot read triple", e); } }
@Override public void endRecord() { assert !isClosed(); nestingLevel = 0; if (nestingLevel == encodeLevel) { endEncode(); } if (redirect) { for (int i = 0; i < nameBuffer.size(); ++i) { getReceiver().process(new Triple(currentId, nameBuffer.get(i), valueBuffer.get(i), typeBuffer.get(i))); } nameBuffer.clear(); valueBuffer.clear(); typeBuffer.clear(); } }
@Override protected void processCount(final String varA, final String varB, final int countA, final int countB, final int countAandB) { for (Metric metric : metrics) { final double value = metric.calculate(countA, countB, countAandB, getTotal()); getReceiver().process(new Triple(varA + "&" + varB, metric.toString(), String.valueOf(value))); } } }
@SuppressWarnings("unchecked") @Test public void testAll() { final CooccurrenceMetricCalculator calculator = new CooccurrenceMetricCalculator("X2, F"); final ObjectReceiver<Triple> receiver = Mockito.mock(ObjectReceiver.class); calculator.setReceiver(receiver); calculator.process(new Triple("1:", "", Integer.toString(TOTAL))); calculator.process(new Triple("1:A", "", Integer.toString(COUNT_A))); calculator.process(new Triple("1:B", "", Integer.toString(COUNT_B))); calculator.process(new Triple("2:A&B", "", Integer.toString(COUNT_A_AND_B))); Mockito.verify(receiver).process(new Triple("A&B", CooccurrenceMetricCalculator.Metric.X2.toString(), Double.toString(CooccurrenceMetricCalculator.Metric.X2.calculate(COUNT_A, COUNT_B, COUNT_A_AND_B, TOTAL)))); }
@Override public void process(final String file) { final String digest; InputStream stream = null; try { stream = new FileInputStream(file); digest = bytesToHex(getDigest(stream, messageDigest)); } catch (IOException e) { throw new MetafactureException(e); } finally { if (stream != null) { try { stream.close(); } catch (final IOException e) { } } } getReceiver().process(new Triple(file, algorithm.name(), digest)); }
@Test public void shouldSkipTriplesWithObjectTypeEntity() { tripleObjectRetriever.process( new Triple(SUBJECT, PREDICATE, ENTITY, ObjectType.ENTITY)); verifyZeroInteractions(receiver); }
@Test public void shouldWriteObjectOfTripleIntoFile() throws IOException { tripleObjectWriter.process(new Triple(SUBJECT1, PREDICATE, OBJECT1)); tripleObjectWriter.process(new Triple(SUBJECT2, PREDICATE, OBJECT2)); final Path file1 = baseDir.resolve(Paths.get(SUBJECT1, PREDICATE)); final Path file2 = baseDir.resolve(Paths.get(SUBJECT2, PREDICATE)); assertEquals(OBJECT1, readFileContents(file1)); assertEquals(OBJECT2, readFileContents(file2)); }
@Test(expected=IllegalArgumentException.class) public void testIllegalArgument() { final CooccurrenceMetricCalculator calculator = new CooccurrenceMetricCalculator("X2"); calculator.setReceiver(new DefaultObjectReceiver<Triple>()); calculator.process(new Triple("2:x&x", "", Integer.toString(COUNT_A_AND_B))); calculator.process(new Triple("1:x", "", Integer.toString(COUNT_B))); } }
@Test public void shouldMapStructuredSubjectsToDirectories() throws IOException { tripleObjectWriter.process(new Triple(STRUCTURED_SUBJECT, PREDICATE, OBJECT1)); final Path file = baseDir.resolve(Paths.get(STRUCTURED_SUBJECT_A, STRUCTURED_SUBJECT_B, PREDICATE)); assertEquals(readFileContents(file), OBJECT1); }
@Test public void testShouldBuildRecords() { collect.process(new Triple(REC_ID, NAME, VALUE1)); collect.process(new Triple(REC_ID, NAME, VALUE2)); collect.process(new Triple(REC_ALT_ID, NAME, VALUE1)); collect.closeStream(); final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(REC_ID); ordered.verify(receiver).literal(NAME, VALUE1); ordered.verify(receiver).literal(NAME, VALUE2); ordered.verify(receiver).endRecord(); ordered.verify(receiver).startRecord(REC_ALT_ID); ordered.verify(receiver).literal(NAME, VALUE1); ordered.verify(receiver).endRecord(); }
@Test public void testShouldDecodeEntities() { collect.process(new Triple(REC_ID, ENTITY_NAME, Formeta.GROUP_START +NAME + Formeta.NAME_VALUE_SEPARATOR + VALUE + Formeta.ITEM_SEPARATOR + ENTITY_NAME + Formeta.GROUP_START + NAME + Formeta.NAME_VALUE_SEPARATOR + VALUE + Formeta.GROUP_END + Formeta.GROUP_END, ObjectType.ENTITY)); collect.closeStream(); final InOrder ordered = Mockito.inOrder(receiver); ordered.verify(receiver).startRecord(REC_ID); ordered.verify(receiver).startEntity(ENTITY_NAME); ordered.verify(receiver).literal(NAME, VALUE); ordered.verify(receiver).startEntity(ENTITY_NAME); ordered.verify(receiver).literal(NAME, VALUE); ordered.verify(receiver, Mockito.times(2)).endEntity(); ordered.verify(receiver).endRecord(); }
@Override public void process(final Triple triple) { assert !isClosed(); if (triple.getObjectType() != ObjectType.STRING) { return; } final String objectValue = retrieveObjectValue(triple.getObject()); getReceiver().process(new Triple(triple.getSubject(), triple.getPredicate(), objectValue)); }
@Test public void shouldBuildTripleFromLiteral() { streamToTriples.startRecord("id"); streamToTriples.literal("literal", "value"); streamToTriples.endRecord(); Mockito.verify(receiver).process(new Triple("id", "literal", "value")); }
@Override public void process(final Triple triple) { final String[] elements = { triple.getSubject(), triple.getPredicate(), triple.getObject(), }; getReceiver().process(new Triple( elements[subjectFrom.ordinal()], elements[predicateFrom.ordinal()], elements[objectFrom.ordinal()] )); }
@Test public void shouldRedirectOnMoveToInName() { streamToTriples.setRedirect(true); streamToTriples.startRecord("id"); streamToTriples.literal("{to:altId}literal", "value"); streamToTriples.endRecord(); Mockito.verify(receiver).process(new Triple("altId", "literal", "value")); }
@Test public void shouldRedirectIfAltIdGiven() { streamToTriples.setRedirect(true); streamToTriples.startRecord("id"); streamToTriples.literal(StandardEventNames.ID, "altId"); streamToTriples.literal("literal", "value"); streamToTriples.endRecord(); Mockito.verify(receiver).process(new Triple("altId", "literal", "value")); }
@Test public void shouldRedirectEvenIfRecordPredicateIsGiven() { streamToTriples.setRecordPredicate("record"); streamToTriples.setRedirect(true); streamToTriples.startRecord("id"); streamToTriples.literal(StandardEventNames.ID, "altId"); streamToTriples.literal("literal", "value"); streamToTriples.endRecord(); final String encodedRecord = "{literal:value}"; Mockito.verify(receiver).process( new Triple("altId", "record", encodedRecord, ObjectType.ENTITY)); }
@Test public void shouldEncodeEntities() { streamToTriples.startRecord("id"); streamToTriples.startEntity("entity1"); streamToTriples.literal("literal1", "value1"); streamToTriples.startEntity("entity2"); streamToTriples.literal("literal2", "value2"); streamToTriples.endEntity(); streamToTriples.endEntity(); streamToTriples.endRecord(); final String encodedEntity = "{literal1:value1,entity2{literal2:value2}}"; Mockito.verify(receiver).process( new Triple("id", "entity1", encodedEntity, ObjectType.ENTITY)); }
@Test public void shouldEncodeWholeRecordsIfRecordPredicateIsGiven() { streamToTriples.setRecordPredicate("record"); streamToTriples.startRecord("id"); streamToTriples.startEntity("entity1"); streamToTriples.literal("literal1", "value1"); streamToTriples.endEntity(); streamToTriples.startEntity("entity2"); streamToTriples.literal("literal2", "value2"); streamToTriples.endEntity(); streamToTriples.endRecord(); final String encodedRecord = "{entity1{literal1:value1}entity2{literal2:value2}}"; Mockito.verify(receiver).process( new Triple("id", "record", encodedRecord, ObjectType.ENTITY)); }