src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
ListPropertyCommandFilter implements ListPropertyCommandExecutor { @Override public void execute(final AddToList command) { referenceKeeper.cleanReferenceCache(); if (couldBeExecuted(command)) { executor.execute(command); } else { keepReferenceIfObservable(command.getValue()); } } ListPropertyCommandFilter(final ListPropertyCommandExecutor executor,
final TemporaryReferenceKeeper referenceKeeper, final ListPropertyMetaDataStore listVersions,
final WeakObjectRegistry objectRegistry, final boolean useLocalVerision); @Override void execute(final AddToList command); @Override void execute(final RemoveFromList command); @Override void execute(final ReplaceInList command); }
|
@Test public void droppsCommandsThatsVersionDifferFromTheApprovedVersionOfTheListProperty() { when(listVersions.getMetaDataOrFail(EXEMPLARY_LIST_ID)).thenReturn(new ListPropertyMetaData(null, randomUUID())) .thenReturn(new ListPropertyMetaData(null, randomUUID())) .thenReturn(new ListPropertyMetaData(null, randomUUID())); cut.execute(exemplaryAddToListCommand); cut.execute(exemplaryRemoveFromListCommand); cut.execute(exemlaryReplaceInListCommand); verifyNoMoreInteractions(executor); }
@Test public void canUseLocalVersionInsteadOfApprovedVersionWhenRequested() { cut = new ListPropertyCommandFilter(executor, referenceKeeper, listVersions, objectRegistry, true); when(listVersions.getMetaDataOrFail(EXEMPLARY_LIST_ID)) .thenReturn(new ListPropertyMetaData(EXEMPLARY_VERSION_FOR_ADD, null)) .thenReturn(new ListPropertyMetaData(null, EXEMPLARY_VERSION_FOR_REMOVE)); cut.execute(exemplaryAddToListCommand); cut.execute(exemplaryRemoveFromListCommand); verify(executor).execute(exemplaryAddToListCommand); verifyNoMoreInteractions(executor); }
@Test public void cachesObservableObjectsOfAddToListAndReplaceInListCommands() { when(listVersions.getMetaDataOrFail(EXEMPLARY_LIST_ID)).thenReturn(new ListPropertyMetaData(null, randomUUID())) .thenReturn(new ListPropertyMetaData(null, randomUUID())); final Object observableObjectForAdd = new Object(); final Object observableObjectForReplace = new Object(); when(objectRegistry.getByIdOrFail(EXEMPLARY_OBSERVABLE_OBJECT_ID_1)).thenReturn(observableObjectForAdd); when(objectRegistry.getByIdOrFail(EXEMPLARY_OBSERVABLE_OBJECT_ID_2)).thenReturn(observableObjectForReplace); cut.execute(exemplaryAddToListCommand); cut.execute(exemlaryReplaceInListCommand); verify(referenceKeeper).keepReferenceTo(observableObjectForAdd); verify(referenceKeeper).keepReferenceTo(observableObjectForReplace); }
@Test public void doesntCacheSimpleObjectsOfAddToListAndReplaceInListCommands() { when(listVersions.getMetaDataOrFail(EXEMPLARY_LIST_ID)).thenReturn(new ListPropertyMetaData(null, randomUUID())) .thenReturn(new ListPropertyMetaData(null, randomUUID())); final AddToList addCommandWithSimpleObject = new AddToList(EXEMPLARY_LIST_ID, new ListVersionChange(randomUUID(), randomUUID()), new Value("some simple object"), 6); final ReplaceInList replaceCommandWithSimpleObject = new ReplaceInList(EXEMPLARY_LIST_ID, new ListVersionChange(randomUUID(), randomUUID()), new Value("other simple object"), 7); cut.execute(addCommandWithSimpleObject); cut.execute(replaceCommandWithSimpleObject); verify(referenceKeeper, never()).keepReferenceTo(any()); verifyNoMoreInteractions(objectRegistry, executor); }
@Test public void cleansUpReferenceCacheOnEveryCommand() { when(listVersions.getMetaDataOrFail(EXEMPLARY_LIST_ID)) .thenReturn(new ListPropertyMetaData(null, randomUUID())); cut.execute(exemplaryAddToListCommand); cut.execute(exemplaryRemoveFromListCommand); cut.execute(exemlaryReplaceInListCommand); verify(referenceKeeper, times(3)).cleanReferenceCache(); }
@Test public void executesCommandsThatsVersionMatchesTheVersionOfTheLocalListProperty() { when(listVersions.getMetaDataOrFail(EXEMPLARY_LIST_ID)) .thenReturn(new ListPropertyMetaData(null, EXEMPLARY_VERSION_FOR_ADD)) .thenReturn(new ListPropertyMetaData(null, EXEMPLARY_VERSION_FOR_REMOVE)) .thenReturn(new ListPropertyMetaData(null, EXEMPLARY_VERSION_FOR_REPLACE)); cut.execute(exemplaryAddToListCommand); cut.execute(exemplaryRemoveFromListCommand); cut.execute(exemlaryReplaceInListCommand); verify(executor).execute(exemplaryAddToListCommand); verify(executor).execute(exemplaryRemoveFromListCommand); verify(executor).execute(exemlaryReplaceInListCommand); verify(referenceKeeper, never()).keepReferenceTo(any()); }
|
AddToListRepairer { public AddToList repairLocalCommand(final AddToList toRepair, final AddToList repairAgainst) { if (toRepair.getPosition() == repairAgainst.getPosition()) { return createCommand(toRepair, toRepair.getPosition() + 1); } return repairRemoteCommand(toRepair, repairAgainst); } AddToList repairLocalCommand(final AddToList toRepair, final AddToList repairAgainst); AddToList repairRemoteCommand(final AddToList toRepair, final AddToList repairAgainst); AddToList repairCommand(final AddToList toRepair, final RemoveFromList repairAgainst); AddToList repairCommand(final AddToList toRepair, final ReplaceInList repairAgainst); }
|
@Test public void shouldIncreaseIndexOfLocalAddToListCommandIfIndexIsSameAsRemoteAddToListIndex() { final AddToList toRepair1 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 53); final AddToList repairAgainst1 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 53); final AddToList repaired1 = cut.repairLocalCommand(toRepair1, repairAgainst1); assertThat(repaired1.getPosition()).isEqualTo(54); }
|
AddToListRepairer { public AddToList repairRemoteCommand(final AddToList toRepair, final AddToList repairAgainst) { if (toRepair.getPosition() >= repairAgainst.getPosition()) { return createCommand(toRepair, toRepair.getPosition() + 1); } return toRepair; } AddToList repairLocalCommand(final AddToList toRepair, final AddToList repairAgainst); AddToList repairRemoteCommand(final AddToList toRepair, final AddToList repairAgainst); AddToList repairCommand(final AddToList toRepair, final RemoveFromList repairAgainst); AddToList repairCommand(final AddToList toRepair, final ReplaceInList repairAgainst); }
|
@Test public void shouldNotChangeIndexOfRemoteAddToListIfIndexIsSameAsLocalAddToListIndex() { final AddToList toRepair1 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 53); final AddToList repairAgainst1 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 53); final AddToList repaired1 = cut.repairRemoteCommand(toRepair1, repairAgainst1); assertThat(repaired1.getPosition()).isEqualTo(54); }
|
AddToListRepairer { public AddToList repairCommand(final AddToList toRepair, final RemoveFromList repairAgainst) { final int indicesBefore = toRepair.getPosition() - repairAgainst.getStartPosition(); if (indicesBefore <= 0) { return toRepair; } final int indicesToDecrese = indicesBefore < repairAgainst.getRemoveCount() ? indicesBefore : repairAgainst .getRemoveCount(); return createCommand(toRepair, toRepair.getPosition() - indicesToDecrese); } AddToList repairLocalCommand(final AddToList toRepair, final AddToList repairAgainst); AddToList repairRemoteCommand(final AddToList toRepair, final AddToList repairAgainst); AddToList repairCommand(final AddToList toRepair, final RemoveFromList repairAgainst); AddToList repairCommand(final AddToList toRepair, final ReplaceInList repairAgainst); }
|
@Test public void shouldDecreaseIndexOfAddToListByAsMuchElementsThatAreBeforOrAtTheIndexInARemoveFromListCommand() { final AddToList toRepair1 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 5); final RemoveFromList repairAgainst1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 2, 2); final AddToList repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1.getPosition()).isEqualTo(3); final AddToList toRepair2 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 65); final RemoveFromList repairAgainst2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 64, 3); final AddToList repaired2 = cut.repairCommand(toRepair2, repairAgainst2); assertThat(repaired2.getPosition()).isEqualTo(64); }
@Test public void shouldNotChangeIndexOfAddToListIfIndexIsLesserThanOrEqualToTheIndicesOfRemoveFromListCommand() { final AddToList toRepair1 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 5); final RemoveFromList repairAgainst1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 8, 92); final AddToList repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1.getPosition()).isEqualTo(5); final AddToList toRepair2 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 20); final RemoveFromList repairAgainst2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 20, 1); final AddToList repaired2 = cut.repairCommand(toRepair2, repairAgainst2); assertThat(repaired2.getPosition()).isEqualTo(20); }
@Test public void shouldNotChangeIndexOfAddToListIfOtherCommandIsReplaceInList() { final AddToList toRepair1 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 5); final ReplaceInList repairAgainst1 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 5); final AddToList repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1.getPosition()).isEqualTo(5); }
|
SimpleListPropertyCommandExecutor implements ListPropertyCommandExecutor { @Override public void execute(final AddToList command) { final List<Object> list = getListOrFail(command); final Object value = valueMapper.map(command.getValue()); silentChangeExecutor.execute(list, new Runnable() { @Override public void run() { list.add(command.getPosition(), value); } }); updateVersion(command); } SimpleListPropertyCommandExecutor(final WeakObjectRegistry objectRegistry,
final SilentChangeExecutor silentChangeExecutor, final ValueMapper valueMapper,
final ListPropertyMetaDataStore listVersions); @Override void execute(final AddToList command); @Override void execute(final RemoveFromList command); @Override void execute(final ReplaceInList command); }
|
@Test public void shouldExecuteAddToListCommands() { final AddToList command1 = new AddToList(exemplaryListId, exemplaryVersionChange, new Value("second"), 0); final AddToList command2 = new AddToList(exemplaryListId, exemplaryVersionChange, new Value("first"), 0); final AddToList command3 = new AddToList(exemplaryListId, exemplaryVersionChange, new Value("third"), 2); cut.execute(command1); cut.execute(command2); cut.execute(command3); assertThat(exemplaryList.get()).containsExactly("first", "second", "third"); }
@Test public void shouldExecuteRemoveFromListCommands() { exemplaryList.addAll("first", "second", "third", "forth", "fifth"); final RemoveFromList command1 = new RemoveFromList(exemplaryListId, exemplaryVersionChange, 1, 2); final RemoveFromList command2 = new RemoveFromList(exemplaryListId, exemplaryVersionChange, 2, 1); cut.execute(command1); cut.execute(command2); assertThat(exemplaryList.get()).containsExactly("first", "forth"); }
@Test public void shouldExecuteReplaceInListCommands() { exemplaryList.addAll("first", "second", "third", "forth"); final ReplaceInList command1 = new ReplaceInList(exemplaryListId, exemplaryVersionChange, new Value( "replaced second"), 1); final ReplaceInList command2 = new ReplaceInList(exemplaryListId, exemplaryVersionChange, new Value( "replaced forth"), 3); cut.execute(command1); cut.execute(command2); assertThat(exemplaryList.get()).containsExactly("first", "replaced second", "third", "replaced forth"); }
@Test public void shouldUseSilentChangeExecutorForAllExecutions() { exemplaryList.add("initial value"); doAnswer(new Answer<Object>() { @Override public Object answer(final InvocationOnMock invocation) { return null; } }).when(silentChangeExecutor).execute(any(), any(Runnable.class)); final AddToList addToList = new AddToList(exemplaryListId, exemplaryVersionChange, new Value( "should not be added"), 0); final RemoveFromList removeFromList = new RemoveFromList(exemplaryListId, exemplaryVersionChange, 0, 20); final ReplaceInList replaceInList = new ReplaceInList(exemplaryListId, exemplaryVersionChange, new Value( "replaced"), 0); cut.execute(addToList); cut.execute(removeFromList); cut.execute(replaceInList); assertThat(exemplaryList).containsExactly("initial value"); }
@Test public void shouldUpdateLocalListVersionWhenCommandWasExecuted() { final ListPropertyMetaData metaData = new ListPropertyMetaData(randomUUID(), randomUUID()); when(listMetaData.getMetaDataOrFail(exemplaryListId)).thenReturn(metaData); final AddToList command = new AddToList(exemplaryListId, exemplaryVersionChange, new Value("second"), 0); cut.execute(command); assertThat(metaData.getLocalVersion()).isEqualTo(exemplaryVersionChange.getToVersion()); }
|
ListCommandVersionRepairer { public void repairLocalCommandsVersion(final Queue<ListCommand> localCommands, final ListCommand originalRemoteCommand) { localCommands.add(repairCommand(localCommands.poll(), originalRemoteCommand.getListVersionChange() .getToVersion(), randomUUID())); final int count = localCommands.size(); for (int i = 1; i < count; i++) { localCommands.add(repairCommand(localCommands.poll(), randomUUID(), randomUUID())); } } void repairLocalCommandsVersion(final Queue<ListCommand> localCommands,
final ListCommand originalRemoteCommand); List<? extends ListCommand> repairRemoteCommandVersion(
final List<? extends ListCommand> indexRepairedRemoteCommands,
final List<ListCommand> versionRepairedLocalCommands); }
|
@Test public void repairedLocalListVersionsAllDifferFromTheirOriginial() { cut.repairLocalCommandsVersion(localCommands, someRemoteCommand); assertThat(localCommands).hasSize(3); final ListVersionChange version1 = localCommands.poll().getListVersionChange(); assertThat(version1.getFromVersion()).isNotEqualTo(addToList.getListVersionChange().getFromVersion()); assertThat(version1.getToVersion()).isNotEqualTo(addToList.getListVersionChange().getToVersion()); final ListVersionChange version2 = localCommands.poll().getListVersionChange(); assertThat(version2.getFromVersion()).isNotEqualTo(removeFromList.getListVersionChange().getFromVersion()); assertThat(version2.getToVersion()).isNotEqualTo(removeFromList.getListVersionChange().getToVersion()); final ListVersionChange version3 = localCommands.poll().getListVersionChange(); assertThat(version3.getFromVersion()).isNotEqualTo(replaceInList.getListVersionChange().getFromVersion()); assertThat(version3.getToVersion()).isNotEqualTo(replaceInList.getListVersionChange().getToVersion()); }
@Test public void firstRepairedLocalListVersionStartsFromToVersionOfRemoteCommand() { cut.repairLocalCommandsVersion(localCommands, someRemoteCommand); assertThat(localCommands).hasSize(3); assertThat(localCommands.poll().getListVersionChange().getFromVersion()).isEqualTo( someRemoteCommand.getListVersionChange().getToVersion()); }
|
ListCommandVersionRepairer { public List<? extends ListCommand> repairRemoteCommandVersion( final List<? extends ListCommand> indexRepairedRemoteCommands, final List<ListCommand> versionRepairedLocalCommands) { final int commandCount = indexRepairedRemoteCommands.size(); final ListCommand lastLocalCommand = versionRepairedLocalCommands.get(versionRepairedLocalCommands.size() - 1); if (commandCount == 0) { return asList(new RemoveFromList(lastLocalCommand.getListId(), new ListVersionChange(randomUUID(), lastLocalCommand.getListVersionChange().getToVersion()), 0, 0)); } final List<ListCommand> repaired = new ArrayList<ListCommand>(commandCount); for (int i = 0; i < commandCount - 1; i++) { repaired.add(indexRepairedRemoteCommands.get(i)); } repaired.add(repairCommand(indexRepairedRemoteCommands.get(commandCount - 1), randomUUID(), lastLocalCommand .getListVersionChange().getToVersion())); return repaired; } void repairLocalCommandsVersion(final Queue<ListCommand> localCommands,
final ListCommand originalRemoteCommand); List<? extends ListCommand> repairRemoteCommandVersion(
final List<? extends ListCommand> indexRepairedRemoteCommands,
final List<ListCommand> versionRepairedLocalCommands); }
|
@Test public void toVersionOfLastRemoteCommandEqualsToVersionOfLastLocalCommand() { final List<? extends ListCommand> repairRemoteCommands = cut.repairRemoteCommandVersion( asList(someRemoteCommand, someOtherRemoteCommand), localCommands); assertThat(repairRemoteCommands).hasSize(2); assertThat(repairRemoteCommands.get(1).getListVersionChange().getToVersion()).isEqualTo( replaceInList.getListVersionChange().getToVersion()); }
@Test public void whenThereAreNoRemoteCommandANewOneIsCreatedWhichDoesntChangeTheList() { final List<? extends ListCommand> repairRemoteCommands = cut.repairRemoteCommandVersion( new ArrayList<ListCommand>(0), localCommands); assertThat(repairRemoteCommands).hasSize(1); assertThat(repairRemoteCommands.get(0)).isInstanceOf(RemoveFromList.class); final RemoveFromList command = (RemoveFromList) repairRemoteCommands.get(0); assertThat(command.getListVersionChange().getToVersion()).isEqualTo( replaceInList.getListVersionChange().getToVersion()); assertThat(command.getStartPosition()).isEqualTo(0); assertThat(command.getRemoveCount()).isEqualTo(0); }
|
ListCommandIndexRepairer { public List<? extends ListCommand> repairCommands(final Queue<ListCommand> localCommands, final ListCommand remoteCommand) { this.localCommands = localCommands; if (remoteCommand instanceof AddToList) { return repairCommands((AddToList) remoteCommand); } else if (remoteCommand instanceof RemoveFromList) { return repairCommands((RemoveFromList) remoteCommand); } else if (remoteCommand instanceof ReplaceInList) { return repairCommands((ReplaceInList) remoteCommand); } else { throw failUnknownTyp(remoteCommand); } } ListCommandIndexRepairer(final AddToListRepairer addToListRepairer,
final RemoveFromListRepairer removeFromListRepairer, final ReplaceInListRepairer replaceInListRepairer); List<? extends ListCommand> repairCommands(final Queue<ListCommand> localCommands,
final ListCommand remoteCommand); }
|
@Test public void canRepairRemoteRemoveFromListCommands() { final RemoveFromList remote = mock(RemoveFromList.class); final RemoveFromList repairedRemote = mock(RemoveFromList.class); final RemoveFromList local = mock(RemoveFromList.class); final RemoveFromList repairedLocal = mock(RemoveFromList.class); final Queue<ListCommand> localQueue = queue(local); when(removeFromListRepairer.repairCommand(remote, local)).thenReturn(asList(repairedRemote)); when(removeFromListRepairer.repairCommand(local, remote)).thenReturn(asList(repairedLocal)); final List<? extends ListCommand> repairCommands = cut.repairCommands(localQueue, remote); assertThat(repairCommands).hasSize(1); assertThat(repairCommands.get(0)).isSameAs(repairedRemote); assertThat(localQueue).containsExactly(repairedLocal); }
|
RemoveFromListRepairer { public List<RemoveFromList> repairCommand(final RemoveFromList toRepair, final AddToList repairAgainst) { return repairAddOrReplace(toRepair, repairAgainst.getPosition()); } List<RemoveFromList> repairCommand(final RemoveFromList toRepair, final AddToList repairAgainst); List<RemoveFromList> repairCommand(final RemoveFromList toRepair, final RemoveFromList repairAgainst); List<RemoveFromList> repairCommand(final RemoveFromList toRepair, final ReplaceInList repairAgainst); }
|
@Test public void shouldNotChangeIndicesWhenTheyAreAllBeforeIndexOfAddToListCommand() { final RemoveFromList toRepair1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 5, 1); final AddToList repairAgainst1 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 6); final List<RemoveFromList> repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).hasSize(1); positionAndCountEquals(repaired1.get(0), 5, 1); final RemoveFromList toRepair2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 40, 15); final AddToList repairAgainst2 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 96); final List<RemoveFromList> repaired2 = cut.repairCommand(toRepair2, repairAgainst2); assertThat(repaired2).hasSize(1); positionAndCountEquals(repaired2.get(0), 40, 15); }
@Test public void shouldSkipIndexOfAddToListCommandButRemoveSameAmountOfElements() { final RemoveFromList toRepair1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 8, 10); final AddToList repairAgainst1 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 12); final List<RemoveFromList> repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).hasSize(2); positionAndCountEquals(repaired1.get(0), 8, 4); positionAndCountEquals(repaired1.get(1), 13, 6); final RemoveFromList toRepair2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 12, 6); final AddToList repairAgainst2 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 12); final List<RemoveFromList> repaired2 = cut.repairCommand(toRepair2, repairAgainst2); assertThat(repaired2).hasSize(1); positionAndCountEquals(repaired2.get(0), 13, 6); final RemoveFromList toRepair3 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 2, 4); final AddToList repairAgainst3 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 5); final List<RemoveFromList> repaired3 = cut.repairCommand(toRepair3, repairAgainst3); assertThat(repaired3).hasSize(2); positionAndCountEquals(repaired3.get(0), 2, 3); positionAndCountEquals(repaired3.get(1), 6, 1); }
@Test public void shouldIncreaseStartIndexWhenAllIndicesAreAfterAddToListCommand() { final RemoveFromList toRepair1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 23, 28); final AddToList repairAgainst1 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 16); final List<RemoveFromList> repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).hasSize(1); positionAndCountEquals(repaired1.get(0), 24, 28); }
@Test public void shouldNotChangeIndicesWhenTheyAreAllBeforeIndicesOfOtherRemoveFromListCommand() { final RemoveFromList toRepair1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 5, 10); final RemoveFromList repairAgainst1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 16, 8); final List<RemoveFromList> repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).hasSize(1); positionAndCountEquals(repaired1.get(0), 5, 10); }
@Test public void shouldNotRemoveIndicesAlreadyRemovedByOtherRemoveFromListCommand() { final RemoveFromList toRepair1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 2, 4); final RemoveFromList repairAgainst1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 4, 10); final List<RemoveFromList> repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).hasSize(1); positionAndCountEquals(repaired1.get(0), 2, 2); final RemoveFromList toRepair2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 2, 4); final RemoveFromList repairAgainst2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 4, 2); final List<RemoveFromList> repaired2 = cut.repairCommand(toRepair2, repairAgainst2); assertThat(repaired2).hasSize(1); positionAndCountEquals(repaired2.get(0), 2, 2); final RemoveFromList toRepair5 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 0, 20); final RemoveFromList repairAgainst5 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 4, 2); final List<RemoveFromList> repaired5 = cut.repairCommand(toRepair5, repairAgainst5); assertThat(repaired5).hasSize(1); positionAndCountEquals(repaired5.get(0), 0, 18); }
@Test public void shouldNotDropCommandCompletely() { final RemoveFromList toRepair1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 2, 4); final RemoveFromList repairAgainst1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 2, 4); final List<RemoveFromList> repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).hasSize(1); positionAndCountEquals(repaired1.get(0), 0, 0); final RemoveFromList toRepair2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 2, 4); final RemoveFromList repairAgainst2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 0, 20); final List<RemoveFromList> repaired2 = cut.repairCommand(toRepair2, repairAgainst2); assertThat(repaired2).hasSize(1); positionAndCountEquals(repaired2.get(0), 0, 0); }
@Test public void shouldDecreaseStartPositionWhenAllIndicesOfOtherRemoveFromListCommandAreBefore() { final RemoveFromList toRepair1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 10, 5); final RemoveFromList repairAgainst1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 3, 4); final List<RemoveFromList> repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).hasSize(1); positionAndCountEquals(repaired1.get(0), 6, 5); final RemoveFromList toRepair2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 3, 4); final RemoveFromList repairAgainst2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 0, 4); final List<RemoveFromList> repaired2 = cut.repairCommand(toRepair2, repairAgainst2); assertThat(repaired2).hasSize(1); positionAndCountEquals(repaired2.get(0), 0, 3); final RemoveFromList toRepair3 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 20, 10); final RemoveFromList repairAgainst3 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 20, 3); final List<RemoveFromList> repaired3 = cut.repairCommand(toRepair3, repairAgainst3); assertThat(repaired3).hasSize(1); positionAndCountEquals(repaired3.get(0), 20, 7); final RemoveFromList toRepair4 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 10, 10); final RemoveFromList repairAgainst4 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 5, 10); final List<RemoveFromList> repaired4 = cut.repairCommand(toRepair4, repairAgainst4); assertThat(repaired4).hasSize(1); positionAndCountEquals(repaired4.get(0), 5, 5); }
@Test public void shouldNotChangeIndicesWhenTheyAreAllBeforeIndexOfReplaceInListCommand() { final RemoveFromList toRepair1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 5, 1); final ReplaceInList repairAgainst1 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 6); final List<RemoveFromList> repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).hasSize(1); positionAndCountEquals(repaired1.get(0), 5, 1); final RemoveFromList toRepair2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 40, 15); final ReplaceInList repairAgainst2 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 96); final List<RemoveFromList> repaired2 = cut.repairCommand(toRepair2, repairAgainst2); assertThat(repaired2).hasSize(1); positionAndCountEquals(repaired2.get(0), 40, 15); }
@Test public void shouldSkipIndexOfReplaceInListCommandButRemoveSameAmountOfElements() { final RemoveFromList toRepair1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 8, 10); final ReplaceInList repairAgainst1 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 12); final List<RemoveFromList> repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).hasSize(2); positionAndCountEquals(repaired1.get(0), 8, 4); positionAndCountEquals(repaired1.get(1), 13, 6); final RemoveFromList toRepair2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 12, 6); final ReplaceInList repairAgainst2 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 12); final List<RemoveFromList> repaired2 = cut.repairCommand(toRepair2, repairAgainst2); assertThat(repaired2).hasSize(1); positionAndCountEquals(repaired2.get(0), 13, 6); final RemoveFromList toRepair3 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 2, 4); final ReplaceInList repairAgainst3 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 5); final List<RemoveFromList> repaired3 = cut.repairCommand(toRepair3, repairAgainst3); assertThat(repaired3).hasSize(2); positionAndCountEquals(repaired3.get(0), 2, 3); positionAndCountEquals(repaired3.get(1), 6, 1); }
@Test public void shouldIncreaseStartIndexWhenAllIndicesAreAfterReplaceInListCommand() { final RemoveFromList toRepair1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 23, 28); final ReplaceInList repairAgainst1 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 16); final List<RemoveFromList> repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).hasSize(1); positionAndCountEquals(repaired1.get(0), 24, 28); }
@Test public void shouldNotChangeListIdOrVersion() { final RemoveFromList toRepair2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 12, 6); final AddToList repairAgainst2 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 12); final List<RemoveFromList> repaired2 = cut.repairCommand(toRepair2, repairAgainst2); assertThat(repaired2).hasSize(1); assertThat(repaired2.get(0).getListId()).isEqualTo(SOME_LIST); assertThat(repaired2.get(0).getListVersionChange()).isEqualTo(SOME_CHANGE); final RemoveFromList toRepair1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 2, 4); final RemoveFromList repairAgainst1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 4, 10); final List<RemoveFromList> repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).hasSize(1); assertThat(repaired1.get(0).getListId()).isEqualTo(SOME_LIST); assertThat(repaired1.get(0).getListVersionChange()).isEqualTo(SOME_CHANGE); final RemoveFromList toRepair3 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 2, 4); final ReplaceInList repairAgainst3 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 5); final List<RemoveFromList> repaired3 = cut.repairCommand(toRepair3, repairAgainst3); assertThat(repaired3).hasSize(2); assertThat(repaired3.get(0).getListId()).isEqualTo(SOME_LIST); assertThat(repaired3.get(0).getListVersionChange()).isEqualTo(SOME_CHANGE); assertThat(repaired3.get(1).getListId()).isEqualTo(SOME_LIST); assertThat(repaired3.get(1).getListVersionChange()).isEqualTo(SOME_CHANGE); }
|
ReparingListPropertyCommandExecutor implements ListPropertyCommandExecutor { @Override public void execute(final AddToList command) { execute((ListCommand) command); } ReparingListPropertyCommandExecutor(final ListPropertyMetaDataStore listMetaDataStore,
final ListCommandIndexRepairer indexRepairer, final ListCommandVersionRepairer versionRepairer,
final SimpleListPropertyCommandExecutor simpleExecutor, final TopologyLayerCallback topologyLayerCallback); @Override void execute(final AddToList command); @Override void execute(final RemoveFromList command); @Override void execute(final ReplaceInList command); void logLocalCommand(final ListCommand localCommand); }
|
@Test public void shouldExecuteRemoteCommandWhenLogIsEmpty() { cut.execute(EXEMPLARY_ADD_COMMAND); verify(simpleExecutor).execute(argThat(new SameIdAndVersion<>(EXEMPLARY_ADD_COMMAND))); }
@Test public void shouldUpdateApprovedVersionWhenExecutingACommand() { final ListPropertyMetaData listMetaData = new ListPropertyMetaData(null, null); when(listVersions.getMetaDataOrFail(EXEMPLARY_ADD_COMMAND.getListId())).thenReturn(listMetaData); cut.execute(EXEMPLARY_ADD_COMMAND); assertThat(listMetaData.getApprovedVersion()).isEqualTo(EXEMPLARY_CHANGE.getToVersion()); }
|
ReplaceInListRepairer { public ReplaceInList repairCommand(final ReplaceInList toRepair, final AddToList repairAgainst) { if (repairAgainst.getPosition() > toRepair.getPosition()) { return toRepair; } return new ReplaceInList(toRepair.getListId(), toRepair.getListVersionChange(), toRepair.getValue(), toRepair.getPosition() + 1); } ReplaceInList repairCommand(final ReplaceInList toRepair, final AddToList repairAgainst); ListCommand repairCommand(final ReplaceInList toRepair, final RemoveFromList repairAgainst); Optional<ReplaceInList> repairLocalCommand(final ReplaceInList toRepair, final ReplaceInList repairAgainst); ReplaceInList repairRemoteCommand(final ReplaceInList toRepair, final ReplaceInList repairAgainst); }
|
@Test public void shouldIncreaseIndexIfIndexOfAddToListIsLessOrEqual() { final ReplaceInList toRepair1 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 6); final AddToList repairAgainst1 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 3); final ReplaceInList repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1.getPosition()).isEqualTo(7); final ReplaceInList toRepair2 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 9); final AddToList repairAgainst2 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 9); final ReplaceInList repaired2 = cut.repairCommand(toRepair2, repairAgainst2); assertThat(repaired2.getPosition()).isEqualTo(10); }
@Test public void shouldNotChangeIndexIfIndexOfAddToListIsGreater() { final ReplaceInList toRepair1 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 3); final AddToList repairAgainst1 = new AddToList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 6); final ReplaceInList repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1.getPosition()).isEqualTo(3); }
@Test public void shouldDecreaseIndexOfAddToListByAsMuchElementsThatAreBeforOrAtTheIndexInARemoveFromListCommand() { final ReplaceInList toRepair1 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 5); final RemoveFromList repairAgainst1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 2, 2); final ListCommand repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).isInstanceOf(ReplaceInList.class); assertThat(((ReplaceInList) repaired1).getPosition()).isEqualTo(3); final ReplaceInList toRepair2 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 20); final RemoveFromList repairAgainst2 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 18, 2); final ListCommand repaired2 = cut.repairCommand(toRepair2, repairAgainst2); assertThat(repaired2).isInstanceOf(ReplaceInList.class); assertThat(((ReplaceInList) repaired2).getPosition()).isEqualTo(18); }
@Test public void shouldReturnAddToListWithDecreasedIndexWhenIndexOfReplaceInListWasRemoved() { final ReplaceInList toRepair1 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 65); final RemoveFromList repairAgainst1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 64, 3); final ListCommand repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).isInstanceOf(AddToList.class); assertThat(((AddToList) repaired1).getPosition()).isEqualTo(64); }
@Test public void shouldNotChangeIndexOfAddToListIfIndexIsLesserThanToTheIndicesOfRemoveFromListCommand() { final ReplaceInList toRepair1 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 5); final RemoveFromList repairAgainst1 = new RemoveFromList(SOME_LIST, SOME_CHANGE, 8, 92); final ListCommand repaired1 = cut.repairCommand(toRepair1, repairAgainst1); assertThat(repaired1).isInstanceOf(ReplaceInList.class); assertThat(((ReplaceInList) repaired1).getPosition()).isEqualTo(5); }
|
ReplaceInListRepairer { public Optional<ReplaceInList> repairLocalCommand(final ReplaceInList toRepair, final ReplaceInList repairAgainst) { if (toRepair.getPosition() == repairAgainst.getPosition()) { return Optional.empty(); } return Optional.of(toRepair); } ReplaceInList repairCommand(final ReplaceInList toRepair, final AddToList repairAgainst); ListCommand repairCommand(final ReplaceInList toRepair, final RemoveFromList repairAgainst); Optional<ReplaceInList> repairLocalCommand(final ReplaceInList toRepair, final ReplaceInList repairAgainst); ReplaceInList repairRemoteCommand(final ReplaceInList toRepair, final ReplaceInList repairAgainst); }
|
@Test public void shouldDropLocalCommandWhenIndicesAreEqual() { final ReplaceInList toRepair1 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 4); final ReplaceInList repairAgainst1 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 4); final Optional<ReplaceInList> repaired1 = cut.repairLocalCommand(toRepair1, repairAgainst1); assertThat(repaired1.isPresent()).isFalse(); }
|
ReplaceInListRepairer { public ReplaceInList repairRemoteCommand(final ReplaceInList toRepair, final ReplaceInList repairAgainst) { return toRepair; } ReplaceInList repairCommand(final ReplaceInList toRepair, final AddToList repairAgainst); ListCommand repairCommand(final ReplaceInList toRepair, final RemoveFromList repairAgainst); Optional<ReplaceInList> repairLocalCommand(final ReplaceInList toRepair, final ReplaceInList repairAgainst); ReplaceInList repairRemoteCommand(final ReplaceInList toRepair, final ReplaceInList repairAgainst); }
|
@Test public void shouldNotChangeRemoteCommandEvenWhenIndicesAreEqual() { final ReplaceInList toRepair2 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 86); final ReplaceInList repairAgainst2 = new ReplaceInList(SOME_LIST, SOME_CHANGE, SOME_VALUE, 86); final ReplaceInList repairRemoteCommand2 = cut.repairRemoteCommand(toRepair2, repairAgainst2); assertThat(repairRemoteCommand2.getPosition()).isEqualTo(86); }
|
SilentChangeExecutor { public void execute(final Object observable, final Runnable change) { listeners.disableFor(observable); change.run(); listeners.enableFor(observable); } SilentChangeExecutor(); void execute(final Object observable, final Runnable change); void registerListenersToSilence(final Listeners listeners); }
|
@Test public void shouldDisableAndReanableChangeNotificationWhenChangingThePropertyValue() { cut.execute(dummyObservable, new Runnable() { @Override public void run() { dummyObservable.setValue(NEW_VALUE); } }); final InOrder inOrder = inOrder(listeners, dummyObservable); inOrder.verify(listeners).disableFor(dummyObservable); inOrder.verify(dummyObservable).setValue(NEW_VALUE); inOrder.verify(listeners).enableFor(dummyObservable); }
|
SimpleSingleValuePropertyCommandExecutor implements SingleValuePropertyCommandExecutor { @Override public void execute(final SetPropertyValue command) { @SuppressWarnings("unchecked") final Property<Object> property = (Property<Object>) objectRegistry.getByIdOrFail(command.getPropertyId()); changeExecutor.execute(property, new Runnable() { @Override public void run() { property.setValue(valueMapper.map(command.getValue())); } }); } SimpleSingleValuePropertyCommandExecutor(final WeakObjectRegistry objectRegistry,
final SilentChangeExecutor changeExecutor, final ValueMapper valueMapper); @Override void execute(final SetPropertyValue command); }
|
@Test public void shouldChangeTheValueOfAProperty() { cut.execute(exemplaryProperty1Change); assertThat(exemplaryProperty1.get()).isEqualTo("changed value"); }
@Test public void shouldChangeTheDomainModelOfTheUserWithoutNotifingTheListeners() { doAnswer(new Answer<Object>() { @Override public Object answer(final InvocationOnMock invocation) { return null; } }).when(silentChangeExecutor).execute(any(), any(Runnable.class)); cut.execute(exemplaryProperty1Change); verify(silentChangeExecutor).execute(any(), any(Runnable.class)); assertThat(exemplaryProperty1.get()).isEqualTo(exemplaryProperty1Value); }
|
CommandLogDispatcher { public void logLocalCommands(final List<Command> commands) { if (singleValue == null) { return; } for (final Command command : commands) { if (command instanceof SetPropertyValue) { singleValue.logLocalCommand((SetPropertyValue) command); } else if (command instanceof ListCommand) { lists.logLocalCommand((ListCommand) command); } } } CommandLogDispatcher(final RepairingSingleValuePropertyCommandExecutor singleValue,
final ReparingListPropertyCommandExecutor lists); CommandLogDispatcher(); void logLocalCommands(final List<Command> commands); }
|
@Test public void dispatchesSetPropertyValueToSingleValuePropertyCommandExecutor() { final SetPropertyValue msg1 = new SetPropertyValue(UUID.randomUUID(), new Value("exampleValue")); final SetPropertyValue msg2 = new SetPropertyValue(UUID.randomUUID(), new Value(UUID.randomUUID())); final List<Command> commands = Arrays.asList(new PutToMap(), mock(ReplaceInList.class), msg1, new Command() { }, msg2); cut.logLocalCommands(commands); verify(singleValue, times(2)).logLocalCommand(setPropertyValueCaptor.capture()); assertThat(setPropertyValueCaptor.getAllValues().get(0)).isEqualTo(msg1); assertThat(setPropertyValueCaptor.getAllValues().get(1)).isEqualTo(msg2); }
@Test public void dispatchesListCommandsToReparingListPropertyCommandExecutor() { final AddToList msg1 = mock(AddToList.class); final RemoveFromList msg2 = mock(RemoveFromList.class); final ReplaceInList msg3 = mock(ReplaceInList.class); final List<Command> commands = Arrays.asList(new PutToMap(), msg1, mock(SetPropertyValue.class), msg2, new Command() { }, msg3); cut.logLocalCommands(commands); verify(lists, times(3)).logLocalCommand(listCommandCaptor.capture()); assertThat(listCommandCaptor.getAllValues().get(0)).isEqualTo(msg1); assertThat(listCommandCaptor.getAllValues().get(1)).isEqualTo(msg2); assertThat(listCommandCaptor.getAllValues().get(2)).isEqualTo(msg3); }
@Test public void doesNotFailWhenNoExecutorsAreRegisteredForCommands() { cut = new CommandLogDispatcher(); cut.logLocalCommands(Arrays.asList(new PutToMap(), mock(ReplaceInList.class), mock(SetPropertyValue.class))); }
|
ListPropertyMetaDataStore { public void storeMetaDataOrFail(final List<?> list, final ListPropertyMetaData metaData) throws ObjectToIdMappingException { if (listToData.get(list) != null) { throw new ObjectToIdMappingException("Meta data for a known property should be registered twice. " + "The clients may no longer be synchron."); } listToData.put(list, metaData); } ListPropertyMetaDataStore(final WeakObjectRegistry objectRegistry); ListPropertyMetaData getMetaDataOrFail(final List<?> list); ListPropertyMetaData getMetaDataOrFail(final UUID listId); void storeMetaDataOrFail(final List<?> list, final ListPropertyMetaData metaData); boolean hasMetaDataFor(final List<?> list); }
|
@Test(expected = ObjectToIdMappingException.class) public void failsWhenMetaDataShouldBeStoredForAPropertyThatAlreadyHasMetaData() { cut.storeMetaDataOrFail(list1, exampleMetaData1); cut.storeMetaDataOrFail(list1, exampleMetaData2); }
|
ListPropertyMetaDataStore { public ListPropertyMetaData getMetaDataOrFail(final List<?> list) { final ListPropertyMetaData metaData = listToData.get(list); if (metaData == null) { throw new ObjectToIdMappingException("Meta data for an unknown property was requested. " + "The clients may no longer be synchron."); } return metaData; } ListPropertyMetaDataStore(final WeakObjectRegistry objectRegistry); ListPropertyMetaData getMetaDataOrFail(final List<?> list); ListPropertyMetaData getMetaDataOrFail(final UUID listId); void storeMetaDataOrFail(final List<?> list, final ListPropertyMetaData metaData); boolean hasMetaDataFor(final List<?> list); }
|
@Test(expected = ObjectToIdMappingException.class) public void failsWhenMetaDataShouldBeRetrivedForAPropertyThatHasNoKnownMetaData() { cut.getMetaDataOrFail(list1); }
|
WeakObjectRegistry { public Optional<UUID> getId(final Object object) { return Optional.ofNullable(objectToId.get(object)); } Optional<Object> getById(final UUID id); Object getByIdOrFail(final UUID id); Optional<UUID> getId(final Object object); UUID getIdOrFail(final Object object); UUID registerIfUnknown(final Object object); void registerObject(final Object object, final UUID id); }
|
@Test public void shouldReturnEmptyOptionalForUnknownObject() { Object unknownObject = "example unknown object"; Optional<UUID> id = cut.getId(unknownObject); assertThat(id.isPresent()).isFalse(); }
|
WeakObjectRegistry { public Optional<Object> getById(final UUID id) { return Optional.ofNullable(idToObject.get(id)); } Optional<Object> getById(final UUID id); Object getByIdOrFail(final UUID id); Optional<UUID> getId(final Object object); UUID getIdOrFail(final Object object); UUID registerIfUnknown(final Object object); void registerObject(final Object object, final UUID id); }
|
@Test public void shouldReturnEmptyOptionalForUnknownId() { UUID unknownId = UUID.randomUUID(); Optional<Object> object = cut.getById(unknownId); assertThat(object.isPresent()).isFalse(); }
|
WeakObjectRegistry { public UUID getIdOrFail(final Object object) throws ObjectToIdMappingException { Optional<UUID> id = getId(object); if (!id.isPresent()) { throw new ObjectToIdMappingException(format( "An id for the object [%s] was expected to be known but it was not. %s", object.toString(), SYNCRONISM_LOST)); } return id.get(); } Optional<Object> getById(final UUID id); Object getByIdOrFail(final UUID id); Optional<UUID> getId(final Object object); UUID getIdOrFail(final Object object); UUID registerIfUnknown(final Object object); void registerObject(final Object object, final UUID id); }
|
@Test(expected = ObjectToIdMappingException.class) public void shouldFailWhenIdForAnUnregisteredObjectIsRequested() { Object unknownObject = "example unknown object"; cut.getIdOrFail(unknownObject); }
|
WeakObjectRegistry { public Object getByIdOrFail(final UUID id) throws ObjectToIdMappingException { Optional<Object> object = getById(id); if (!object.isPresent()) { throw new ObjectToIdMappingException(format( "An object with the id [%s] was expected to be known but it was not. %s", id.toString(), SYNCRONISM_LOST)); } return object.get(); } Optional<Object> getById(final UUID id); Object getByIdOrFail(final UUID id); Optional<UUID> getId(final Object object); UUID getIdOrFail(final Object object); UUID registerIfUnknown(final Object object); void registerObject(final Object object, final UUID id); }
|
@Test(expected = ObjectToIdMappingException.class) public void shouldFailWhenObjectForAnUnknownIdIsRequested() { UUID unknownId = UUID.randomUUID(); cut.getByIdOrFail(unknownId); }
|
LeaderElectionMetrics extends RatisMetrics { public void onNewLeaderElection() { registry.counter(LEADER_ELECTION_COUNT_METRIC).inc(); } private LeaderElectionMetrics(RaftServerImpl raftServer); static LeaderElectionMetrics getLeaderElectionMetrics(RaftServerImpl raftServer); void onNewLeaderElection(); void onLeaderElectionCompletion(long elapsedTime); void onLeaderElectionTimeout(); static final String RATIS_LEADER_ELECTION_METRICS; static final String RATIS_LEADER_ELECTION_METRICS_DESC; static final String LEADER_ELECTION_COUNT_METRIC; static final String LEADER_ELECTION_TIMEOUT_COUNT_METRIC; static final String LEADER_ELECTION_LATENCY; static final String LAST_LEADER_ELAPSED_TIME; }
|
@Test public void testOnNewLeaderElection() throws Exception { long numLeaderElections = ratisMetricRegistry.counter( LEADER_ELECTION_COUNT_METRIC).getCount(); assertTrue(numLeaderElections == 0); leaderElectionMetrics.onNewLeaderElection(); numLeaderElections = ratisMetricRegistry.counter(LEADER_ELECTION_COUNT_METRIC).getCount(); assertEquals(1, numLeaderElections); }
|
LogServiceProtoUtil { public static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t) { GetLogStartIndexReplyProto.Builder builder = GetLogStartIndexReplyProto.newBuilder(); if (t != null) { builder.setException(toLogException(t)); } else { builder.setStartIndex(length); } return builder.build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testGetStartIndexReply() { long index = 100; GetLogStartIndexReplyProto proto = LogServiceProtoUtil.toGetLogStartIndexReplyProto(index, null); assertEquals(index, proto.getStartIndex()); }
|
LogServiceProtoUtil { public static LogServiceRequestProto toSyncLogRequestProto(LogName name) { LogNameProto logNameProto = LogNameProto.newBuilder().setName(name.getName()).build(); SyncLogRequestProto.Builder builder = SyncLogRequestProto.newBuilder(); builder.setLogName(logNameProto); return LogServiceRequestProto.newBuilder().setSyncRequest(builder.build()).build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testSyncRequest() { LogName name = LogName.of("test"); LogServiceRequestProto proto = LogServiceProtoUtil.toSyncLogRequestProto(name); SyncLogRequestProto request = proto.getSyncRequest(); assertEquals(name.getName(), request.getLogName().getName()); }
|
LogServiceProtoUtil { public static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t) { SyncLogReplyProto.Builder builder = SyncLogReplyProto.newBuilder(); if (t != null) { builder.setException(toLogException(t)); } else { builder.setLastRecordId(index); } return builder.build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testSyncReply() { IOException ioException = new IOException("test"); StackTraceElement[] trace = ioException.getStackTrace(); StringBuffer buf = new StringBuffer(); for (StackTraceElement el: trace) { buf.append(el.toString()).append("\n"); } String strace = buf.toString(); LogServiceException expectedLogServiceException = LogServiceException.newBuilder() .setExceptionClassName("java.io.IOException") .setErrorMsg("test") .setStacktrace(ByteString.copyFrom(strace, Charset.defaultCharset())) .build(); SyncLogReplyProto proto1 = LogServiceProtoUtil.toSyncLogReplyProto(0, null); assertEquals(LogServiceException.getDefaultInstance(), proto1.getException()); assertEquals(0, proto1.getLastRecordId()); SyncLogReplyProto proto2 = LogServiceProtoUtil.toSyncLogReplyProto(1, ioException); assertEquals(expectedLogServiceException, proto2.getException()); assertEquals(0, proto2.getLastRecordId()); }
|
LogServiceProtoUtil { public static LogServiceRequestProto toGetStateRequestProto(LogName logName) { LogNameProto logNameProto = LogNameProto.newBuilder().setName(logName.getName()).build(); GetStateRequestProto getState = GetStateRequestProto.newBuilder().setLogName(logNameProto).build(); return LogServiceRequestProto.newBuilder().setGetState(getState).build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testGetStateRequest() { LogName name = LogName.of("test"); LogServiceRequestProto proto = LogServiceProtoUtil.toGetStateRequestProto(name); GetStateRequestProto request = proto.getGetState(); assertEquals(name.getName(), request.getLogName().getName()); }
|
LogServiceProtoUtil { public static GetStateReplyProto toGetStateReplyProto(State state) { return GetStateReplyProto.newBuilder().setState(LogStreamState.valueOf(state.name())).build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testGetStateReply() { GetStateReplyProto protoOpen = LogServiceProtoUtil.toGetStateReplyProto(LogStream.State.OPEN); assertEquals(LogStreamState.OPEN, protoOpen.getState()); GetStateReplyProto protoClosed = LogServiceProtoUtil.toGetStateReplyProto(State.CLOSED); assertEquals(LogStreamState.CLOSED, protoClosed.getState()); GetStateReplyProto protoArchiving= LogServiceProtoUtil.toGetStateReplyProto(LogStream.State.ARCHIVING); assertEquals(LogStreamState.ARCHIVING, protoArchiving.getState()); GetStateReplyProto protoArchived = LogServiceProtoUtil.toGetStateReplyProto(State.ARCHIVED); assertEquals(LogStreamState.ARCHIVED, protoArchived.getState()); GetStateReplyProto protoDeleted = LogServiceProtoUtil.toGetStateReplyProto(LogStream.State.DELETED); assertEquals(LogStreamState.DELETED, protoDeleted.getState()); }
|
LogServiceProtoUtil { public static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state, boolean force) { LogNameProto logNameProto = LogNameProto.newBuilder().setName(logName.getName()).build(); ChangeStateLogRequestProto changeLog = ChangeStateLogRequestProto.newBuilder().setLogName(logNameProto) .setState(LogStreamState.valueOf(state.name())).setForce(force).build(); return LogServiceRequestProto.newBuilder().setChangeState(changeLog).build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testCloseLogRequest() { LogName name = LogName.of("test"); LogServiceRequestProto proto = LogServiceProtoUtil.toChangeStateRequestProto(name, LogStream.State.CLOSED); ChangeStateLogRequestProto request = proto.getChangeState(); assertEquals(name.getName(), request.getLogName().getName()); assertEquals(LogStreamState.CLOSED, request.getState()); }
|
BaseServer implements Closeable { void validateRaftProperties(RaftProperties properties) { if (RaftServerConfigKeys.Snapshot.autoTriggerEnabled(properties)) { throw new IllegalStateException("Auto triggering snapshots is disallowed by the LogService"); } } BaseServer(ServerOpts opts); ServerOpts getServerOpts(); LogServiceConfiguration getConfig(); }
|
@Test public void testDefaultPropertiesAreValid() { RaftProperties props = new RaftProperties(); try (MockServer server = new MockServer()) { server.validateRaftProperties(props); } }
@Test(expected = IllegalStateException.class) public void testAutoSnapshotIsInvalid() { RaftProperties props = new RaftProperties(); RaftServerConfigKeys.Snapshot.setAutoTriggerEnabled(props, true); try (MockServer server = new MockServer()) { server.validateRaftProperties(props); } }
|
MetricRegistriesLoader { public static MetricRegistries load() { List<MetricRegistries> availableImplementations = getDefinedImplemantations(); return load(availableImplementations); } private MetricRegistriesLoader(); static MetricRegistries load(); }
|
@Test public void testLoadSinleInstance() { MetricRegistries loader = mock(MetricRegistries.class); MetricRegistries instance = MetricRegistriesLoader.load(Lists.newArrayList(loader)); assertEquals(loader, instance); }
@Test public void testLoadMultipleInstances() { MetricRegistries loader1 = mock(MetricRegistries.class); MetricRegistries loader2 = mock(MetricRegistries.class); MetricRegistries loader3 = mock(MetricRegistries.class); MetricRegistries instance = MetricRegistriesLoader.load(Lists.newArrayList(loader1, loader2, loader3)); assertEquals(loader1, instance); assertNotEquals(loader2, instance); assertNotEquals(loader3, instance); }
|
LeaderElectionMetrics extends RatisMetrics { public void onLeaderElectionCompletion(long elapsedTime) { this.leaderElectionCompletionLatency = elapsedTime; } private LeaderElectionMetrics(RaftServerImpl raftServer); static LeaderElectionMetrics getLeaderElectionMetrics(RaftServerImpl raftServer); void onNewLeaderElection(); void onLeaderElectionCompletion(long elapsedTime); void onLeaderElectionTimeout(); static final String RATIS_LEADER_ELECTION_METRICS; static final String RATIS_LEADER_ELECTION_METRICS_DESC; static final String LEADER_ELECTION_COUNT_METRIC; static final String LEADER_ELECTION_TIMEOUT_COUNT_METRIC; static final String LEADER_ELECTION_LATENCY; static final String LAST_LEADER_ELAPSED_TIME; }
|
@Test public void testOnLeaderElectionCompletion() throws Exception { leaderElectionMetrics.onLeaderElectionCompletion(500L); Long leaderElectionLatency = (Long) ratisMetricRegistry.getGauges((s, metric) -> s.contains(LEADER_ELECTION_LATENCY)).values().iterator().next().getValue(); assertEquals(500L, leaderElectionLatency.longValue()); }
|
RefCountingMap { int size() { return map.size(); } }
|
@Test public void testSize() { assertEquals(0, map.size()); map.put("foo", () -> "foovalue"); assertEquals(1, map.size()); map.put("bar", () -> "foovalue2"); assertEquals(2, map.size()); map.put("bar", () -> "foovalue3"); assertEquals(2, map.size()); }
|
RefCountingMap { void clear() { map.clear(); } }
|
@Test public void testClear() { map.put("foo", () -> "foovalue"); map.put("bar", () -> "foovalue2"); map.put("baz", () -> "foovalue3"); map.clear(); assertEquals(0, map.size()); }
|
RefCountingMap { Set<K> keySet() { return map.keySet(); } }
|
@Test public void testKeySet() { map.put("foo", () -> "foovalue"); map.put("bar", () -> "foovalue2"); map.put("baz", () -> "foovalue3"); Set<String> keys = map.keySet(); assertEquals(3, keys.size()); Lists.newArrayList("foo", "bar", "baz").stream().forEach(v -> assertTrue(keys.contains(v))); }
|
RefCountingMap { Collection<V> values() { return map.values().stream().map(v -> v.v).collect(Collectors.toList()); } }
|
@Test public void testValues() { map.put("foo", () -> "foovalue"); map.put("foo", () -> "foovalue2"); map.put("bar", () -> "foovalue3"); map.put("baz", () -> "foovalue4"); Collection<String> values = map.values(); assertEquals(3, values.size()); Lists.newArrayList("foovalue", "foovalue3", "foovalue4").stream() .forEach(v -> assertTrue(values.contains(v))); }
|
LeaderElectionMetrics extends RatisMetrics { public void onLeaderElectionTimeout() { registry.counter(LEADER_ELECTION_TIMEOUT_COUNT_METRIC).inc(); } private LeaderElectionMetrics(RaftServerImpl raftServer); static LeaderElectionMetrics getLeaderElectionMetrics(RaftServerImpl raftServer); void onNewLeaderElection(); void onLeaderElectionCompletion(long elapsedTime); void onLeaderElectionTimeout(); static final String RATIS_LEADER_ELECTION_METRICS; static final String RATIS_LEADER_ELECTION_METRICS_DESC; static final String LEADER_ELECTION_COUNT_METRIC; static final String LEADER_ELECTION_TIMEOUT_COUNT_METRIC; static final String LEADER_ELECTION_LATENCY; static final String LAST_LEADER_ELAPSED_TIME; }
|
@Test public void testOnLeaderElectionTimeout() throws Exception { long numLeaderElectionTimeouts = ratisMetricRegistry.counter( LEADER_ELECTION_TIMEOUT_COUNT_METRIC).getCount(); assertTrue(numLeaderElectionTimeouts == 0); leaderElectionMetrics.onLeaderElectionTimeout(); numLeaderElectionTimeouts = ratisMetricRegistry.counter(LEADER_ELECTION_TIMEOUT_COUNT_METRIC).getCount(); assertEquals(1, numLeaderElectionTimeouts); }
|
LogServiceProtoUtil { public static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name, List<byte[]> entries) { LogNameProto logNameProto = LogNameProto.newBuilder().setName(name.getName()).build(); AppendLogEntryRequestProto.Builder builder = AppendLogEntryRequestProto.newBuilder(); builder.setLogName(logNameProto); for (int i=0; i < entries.size(); i++) { builder.addData(ByteString.copyFrom(entries.get(i))); } return LogServiceRequestProto.newBuilder().setAppendRequest(builder.build()).build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testAppendRequest() { LogName name = LogName.of("test"); List<byte[]> entries = new ArrayList<>(); byte[] e1 = new byte[] {1,1}; byte[] e2 = new byte[] {2,2}; entries.add(e1); entries.add(e2); LogServiceRequestProto proto = LogServiceProtoUtil.toAppendEntryLogRequestProto(name, entries); AppendLogEntryRequestProto request = proto.getAppendRequest(); assertEquals(name.getName(), request.getLogName().getName()); assertEquals(2, request.getDataCount()); assertTrue(TestUtils.equals(e1, request.getData(0).toByteArray())); assertTrue(TestUtils.equals(e2, request.getData(1).toByteArray())); }
|
LogServiceProtoUtil { public static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t) { AppendLogEntryReplyProto.Builder builder = AppendLogEntryReplyProto.newBuilder(); if (t != null) { builder.setException(toLogException(t)); } else if (ids != null) { for (long id: ids) { builder.addRecordId(id); } } return builder.build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testAppendReply() { List<Long> ids = Arrays.asList(1L, 2L, 3L); IOException ioException = new IOException("test"); StackTraceElement[] trace = ioException.getStackTrace(); StringBuffer buf = new StringBuffer(); for (StackTraceElement el: trace) { buf.append(el.toString()).append("\n"); } String strace = buf.toString(); LogServiceException expectedLogServiceException = LogServiceException.newBuilder() .setExceptionClassName("java.io.IOException") .setErrorMsg("test") .setStacktrace(ByteString.copyFrom(strace, Charset.defaultCharset())) .build(); AppendLogEntryReplyProto proto1 = LogServiceProtoUtil.toAppendLogReplyProto(ids, null); assertEquals(LogServiceException.getDefaultInstance(), proto1.getException()); assertEquals(ids, proto1.getRecordIdList()); AppendLogEntryReplyProto proto2 = LogServiceProtoUtil.toAppendLogReplyProto(null, ioException); assertEquals(expectedLogServiceException, proto2.getException()); assertEquals(Collections.EMPTY_LIST, proto2.getRecordIdList()); AppendLogEntryReplyProto proto3 = LogServiceProtoUtil.toAppendLogReplyProto(ids, ioException); assertEquals(expectedLogServiceException, proto3.getException()); assertEquals(Collections.EMPTY_LIST, proto3.getRecordIdList()); AppendLogEntryReplyProto proto4 = LogServiceProtoUtil.toAppendLogReplyProto(null, null); assertEquals(LogServiceException.getDefaultInstance(), proto4.getException()); assertEquals(Collections.EMPTY_LIST, proto4.getRecordIdList()); }
|
LogServiceProtoUtil { public static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total) { LogNameProto logNameProto = LogNameProto.newBuilder().setName(name.getName()).build(); ReadLogRequestProto.Builder builder = ReadLogRequestProto.newBuilder(); builder.setLogName(logNameProto); builder.setStartRecordId(start); builder.setNumRecords(total); return LogServiceRequestProto.newBuilder().setReadNextQuery(builder.build()).build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testReadRequest() { LogName name = LogName.of("test"); long start = 100; int total = 5; LogServiceRequestProto proto = LogServiceProtoUtil.toReadLogRequestProto(name, start, total); ReadLogRequestProto request = proto.getReadNextQuery(); assertEquals(name.getName(), request.getLogName().getName()); assertEquals(100, request.getStartRecordId()); assertEquals(5, request.getNumRecords()); }
|
LogServiceProtoUtil { public static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t) { ReadLogReplyProto.Builder builder = ReadLogReplyProto.newBuilder(); if (t != null) { builder.setException(toLogException(t)); } else { for(byte[] record: entries) { builder.addLogRecord( ByteString.copyFrom(record)); } } return builder.build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testReadReply() { List<byte[]> entries = new ArrayList<>(); byte[] e1 = new byte[] {1,1}; byte[] e2 = new byte[] {2,2}; entries.add(e1); entries.add(e2); ReadLogReplyProto proto = LogServiceProtoUtil.toReadLogReplyProto(entries, null); assertEquals(2, proto.getLogRecordCount()); assertTrue(TestUtils.equals(e1, proto.getLogRecord(0).toByteArray())); assertTrue(TestUtils.equals(e2, proto.getLogRecord(1).toByteArray())); }
|
LogServiceProtoUtil { public static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t) { GetLogLengthReplyProto.Builder builder = GetLogLengthReplyProto.newBuilder(); if (t != null) { builder.setException(toLogException(t)); } else { builder.setLength(length); } return builder.build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testGetLengthReply() { long len = 100; GetLogLengthReplyProto proto = LogServiceProtoUtil.toGetLogLengthReplyProto(len, null); assertEquals(len, proto.getLength()); }
|
LogServiceProtoUtil { public static LogServiceRequestProto toGetLengthRequestProto(LogName name) { LogNameProto logNameProto = LogNameProto.newBuilder().setName(name.getName()).build(); GetLogLengthRequestProto.Builder builder = GetLogLengthRequestProto.newBuilder(); builder.setLogName(logNameProto); return LogServiceRequestProto.newBuilder().setLengthQuery(builder.build()).build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testGetLengthRequest() { LogName name = LogName.of("test"); LogServiceRequestProto proto = LogServiceProtoUtil.toGetLengthRequestProto(name); GetLogLengthRequestProto request = proto.getLengthQuery(); assertEquals(name.getName(), request.getLogName().getName()); }
|
LogServiceProtoUtil { public static LogServiceRequestProto toGetStartIndexProto(LogName name) { LogNameProto logNameProto = LogNameProto.newBuilder().setName(name.getName()).build(); GetLogStartIndexRequestProto.Builder builder = GetLogStartIndexRequestProto.newBuilder(); builder.setLogName(logNameProto); return LogServiceRequestProto.newBuilder().setStartIndexQuery(builder.build()).build(); } static LogNameProto toLogNameProto(LogName logName); static LogName toLogName(LogServiceProtos.LogNameProto logNameProto); static LogStreamProto toLogStreamProto(LogStream logStream); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state,
boolean force); static LogServiceRequestProto toChangeStateRequestProto(LogName logName, State state); static LogServiceRequestProto toGetStateRequestProto(LogName logName); static ArchiveLogReplyProto toArchiveLogReplyProto(Throwable t); static LogServiceRequestProto toGetSizeRequestProto(LogName name); static LogServiceRequestProto toGetLengthRequestProto(LogName name); static LogServiceRequestProto toGetLastCommittedIndexRequestProto(LogName name); static LogServiceRequestProto toGetStartIndexProto(LogName name); static LogServiceRequestProto toReadLogRequestProto(LogName name, long start, int total); static LogServiceRequestProto toSyncLogRequestProto(LogName name); static LogServiceRequestProto toAppendEntryLogRequestProto(LogName name,
List<byte[]> entries); static LogServiceRequestProto toAppendBBEntryLogRequestProto(LogName name,
List<ByteBuffer> entries); static List<byte[]> toListByteArray(List<ByteString> list); static GetStateReplyProto toGetStateReplyProto(State state); static GetLogLengthReplyProto toGetLogLengthReplyProto(long length, Throwable t); static GetLogSizeReplyProto toGetLogSizeReplyProto(long size, Throwable t); static GetLogStartIndexReplyProto toGetLogStartIndexReplyProto(long length, Throwable t); static GetLogLastCommittedIndexReplyProto toGetLogLastIndexReplyProto(long lastIndex, Throwable t); static ReadLogReplyProto toReadLogReplyProto(List<byte[]> entries, Throwable t); static AppendLogEntryReplyProto toAppendLogReplyProto(List<Long> ids, Throwable t); static SyncLogReplyProto toSyncLogReplyProto(long index, Throwable t); static ArchiveLogRequestProto toExportInfoProto(ArchivalInfo info); static ArchivalInfo toExportInfo(ArchiveLogRequestProto proto); GetLogLengthReplyProto toGetLogLengthReplyProto(long length); static LogServiceException toLogException(Throwable t); static LogServiceRequestProto toExportInfoRequestProto(LogName logName); static LogServiceRequestProto toArchiveLogRequestProto(LogName logName, String location,
long raftIndex, boolean isArchival, ArchivalInfo.ArchivalStatus status); }
|
@Test public void testGetStartIndexRequest() { LogName name = LogName.of("test"); LogServiceRequestProto proto = LogServiceProtoUtil.toGetStartIndexProto(name); GetLogStartIndexRequestProto request = proto.getStartIndexQuery(); assertEquals(name.getName(), request.getLogName().getName()); }
|
Hack { public static HackedObject into(final Object source) { return new HackedMirrorObject(source); } private Hack(); static HackedObject into(final Object source); static R mirrorStaticMethod(final String tag, final R fallback, final Object... args); static void verifyAllMirrorsIn(final Class<?> enclosing); static HackedClass<T> into(final @NonNull Class<T> clazz); static HackedClass<T> into(final String class_name); @SuppressWarnings("unchecked") static Hack.HackedClass<C> onlyIf(final boolean condition, final Hacking<Hack.HackedClass<C>> hacking); static ConditionalHack onlyIf(final boolean condition); static AssertionFailureHandler setAssertionFailureHandler(final @Nullable AssertionFailureHandler handler); static Class<?> ANY_TYPE; }
|
@Test public void testBasicMethodAndConstructor() throws IOException { final Hack.HackedMethod1<Simple, Void, IOException, Unchecked, Unchecked, Integer> constructor = Hack.into(Simple.class).constructor().throwing(IOException.class).withParam(int.class); assertNotNull(constructor); final Simple simple = constructor.invoke(0).statically(); assertNotNull(simple); final Hack.HackedMethod0<Integer, Simple, Unchecked, Unchecked, Unchecked> foo = Hack.into(Simple.class).method("foo").returning(int.class).withoutParams(); assertNotNull(foo); assertEquals(7, (int) foo.invoke().on(simple)); final Hack.HackedMethod0<Integer, Simple, RuntimeException, Unchecked, Unchecked> foo_rt_ex = Hack.into(Simple.class).method("foo").returning(int.class).throwing(RuntimeException.class).withoutParams(); assertNotNull(foo_rt_ex); assertEquals(7, (int) foo_rt_ex.invoke().on(simple)); final Hack.HackedMethod0<Integer, Simple, IOException, Unchecked, Unchecked> foo_ex = Hack.into(Simple.class).method("foo").returning(int.class).throwing(IOException.class).withoutParams(); assertNotNull(foo_ex); assertEquals(7, (int) foo_ex.invoke().on(simple)); final Hack.HackedMethod3<Void, Void, IOException, Unchecked, Unchecked, Integer, String, Simple> bar = Hack.into(Simple.class).staticMethod("bar").throwing(IOException.class).withParams(int.class, String.class, Simple.class); assertNotNull(bar); bar.invoke(-1, "xyz", simple).statically(); assertFail(null, Hack.into(Simple.class).method("bar").throwing(UnsupportedOperationException.class, FileNotFoundException.class).withParams(int.class, String.class, Simple.class)); assertFail(NoSuchMethodException.class, Hack.into(Simple.class).method("notExist").withoutParams()); assertFail(NoSuchMethodException.class, Hack.into(Simple.class).method("foo").withParam(int.class)); assertFail(null, Hack.into(Simple.class).staticMethod("foo").withoutParams()); assertFail(null, Hack.into(Simple.class).method("foo").returning(Void.class).withoutParams()); }
@Test public void testMethodReturningAnyType() throws IOException { final Hack.HackedMethod0<?, Simple, Unchecked, Unchecked, Unchecked> foo = Hack.into(Simple.class).method("foo").returning(ANY_TYPE).withoutParams(); assertNotNull(foo); assertEquals(7, foo.invoke().on(new Simple(0))); }
@Test public void testMethodFallback() throws IOException { final Hack.HackedMethod1<Integer, Simple, IOException, Unchecked, Unchecked, Void> foo_wrong = Hack.into(Simple.class).method("foo").throwing(IOException.class).returning(int.class).fallbackReturning(-1).withParam(Void.class); assertTrue(foo_wrong.isAbsent()); assertEquals(-1, (int) foo_wrong.invoke().on(new Simple(0))); final Hack.HackedMethod1<Integer, Simple, Unchecked, Unchecked, Unchecked, Void> foo_absent = Hack.into(Simple.class).method("foo").returning(int.class).fallbackReturning(-1).withParam(Void.class); assertTrue(foo_absent.isAbsent()); assertEquals(-1, (int) foo_absent.invoke().on(new Simple(0))); }
@Test public void testConstructorFallback() { final Hack.HackedMethod1<Simple, Void, Unchecked, Unchecked, Unchecked, Integer> constructor = Hack.into(Simple.class).constructor().withParam(int.class); assertTrue(constructor.isAbsent()); final Hack.HackedMethod0<Simple, Void, Unchecked, Unchecked, Unchecked> absent_constructor = Hack.into(Simple.class).constructor().withoutParams(); assertTrue(absent_constructor.isAbsent()); }
@Test public void testBasicField() throws IOException { final Simple simple = new Simple(0); final Hack.HackedField<Simple, Integer> field = Hack.into(Simple.class).field("mIntField").ofType(int.class); assertNotNull(field); field.set(simple, 3); assertEquals(3, (int) field.get(simple)); assertFail(null, Hack.into(Simple.class).staticField("mIntField").ofType(ANY_TYPE)); }
@Test public void testFieldFallback() { final Hack.HackedTargetField<Integer> field = Hack.into(Simple.class).staticField("mIntField").fallbackTo(-1); assertEquals(-1, (int) field.get()); field.set(0); assertEquals(-1, (int) field.get()); }
@Test public void testClassNotFound() { assertFail(ClassNotFoundException.class, Hack.into("NoSuchClass").method("nonSense").withoutParams()); assertFail(ClassNotFoundException.class, Hack.into(Simple.class).field("mIntField").ofType("NoSuchType")); assertFail(ClassNotFoundException.class, Hack.into(Simple.class).staticField("mStaticField").ofType("NoSuchType")); }
|
Hack { @SuppressWarnings("unchecked") public static <C> Hack.HackedClass<C> onlyIf(final boolean condition, final Hacking<Hack.HackedClass<C>> hacking) { if (condition) return hacking.hack(); return (Hack.HackedClass<C>) FALLBACK; } private Hack(); static HackedObject into(final Object source); static R mirrorStaticMethod(final String tag, final R fallback, final Object... args); static void verifyAllMirrorsIn(final Class<?> enclosing); static HackedClass<T> into(final @NonNull Class<T> clazz); static HackedClass<T> into(final String class_name); @SuppressWarnings("unchecked") static Hack.HackedClass<C> onlyIf(final boolean condition, final Hacking<Hack.HackedClass<C>> hacking); static ConditionalHack onlyIf(final boolean condition); static AssertionFailureHandler setAssertionFailureHandler(final @Nullable AssertionFailureHandler handler); static Class<?> ANY_TYPE; }
|
@Test public void testOnlyIf() throws IOException { final Hack.HackedMethod1<Simple, Void, IOException, Unchecked, Unchecked, Integer> constructor = Hack.onlyIf(true).into(Simple.class).constructor().throwing(IOException.class).withParam(int.class); assertNotNull(constructor); final Simple simple = constructor.invoke(0).statically(); assertNotNull(simple); final Hack.HackedMethod1<Simple, Void, IOException, Unchecked, Unchecked, Integer> fallback_constructor = Hack.onlyIf(false).into(Simple.class).constructor().throwing(IOException.class).withParam(int.class); assertNotNull(fallback_constructor); final Simple value = fallback_constructor.invoke(0).statically(); assertNull(value); final Hack.HackedMethod1<Integer, Simple, IOException, Unchecked, Unchecked, Void> foo_wrong = Hack.into(Simple.class).method("foo").throwing(IOException.class).returning(int.class).withParam(Void.class); assertNull(foo_wrong); final Hack.HackedField<Simple, Integer> field = Hack.onlyIf(true).into(Simple.class).field("mIntField").ofType(int.class); assertNotNull(field); field.set(simple, 3); assertEquals(3, (int) field.get(simple)); final Hack.HackedField<Simple, Integer> absent_field = Hack.onlyIf(false).into(Simple.class).field("mIntField").ofType(int.class); assertNull(absent_field); final Hack.HackedField<Simple, Integer> fallback_field = Hack.onlyIf(false).into(Simple.class).field("mIntField").fallbackTo(-1); assertNotNull(fallback_field); fallback_field.set(simple, 3); assertEquals(-1, (int) fallback_field.get(simple)); }
|
EventSerializer implements Serializer<CoffeeEvent> { @Override public byte[] serialize(final String topic, final CoffeeEvent event) { try { if (event == null) return null; final JsonbConfig config = new JsonbConfig() .withAdapters(new UUIDAdapter()) .withSerializers(new EventJsonbSerializer()); final Jsonb jsonb = JsonbBuilder.create(config); return jsonb.toJson(event, CoffeeEvent.class).getBytes(StandardCharsets.UTF_8); } catch (Exception e) { logger.severe("Could not serialize event: " + e.getMessage()); throw new SerializationException("Could not serialize event", e); } } @Override void configure(final Map<String, ?> configs, final boolean isKey); @Override byte[] serialize(final String topic, final CoffeeEvent event); @Override void close(); }
|
@Test public void test() { final String actual = new String(cut.serialize(null, event), StandardCharsets.UTF_8); assertEquals(expected, actual); }
|
EventDeserializer implements Deserializer<CoffeeEvent> { @Override public CoffeeEvent deserialize(final String topic, final byte[] data) { try (ByteArrayInputStream input = new ByteArrayInputStream(data)) { final JsonObject jsonObject = Json.createReader(input).readObject(); final Class<? extends CoffeeEvent> eventClass = (Class<? extends CoffeeEvent>) Class.forName(jsonObject.getString("class")); return eventClass.getConstructor(JsonObject.class).newInstance(jsonObject.getJsonObject("data")); } catch (Exception e) { logger.severe("Could not deserialize event: " + e.getMessage()); throw new SerializationException("Could not deserialize event", e); } } @Override void configure(final Map<String, ?> configs, final boolean isKey); @Override CoffeeEvent deserialize(final String topic, final byte[] data); @Override void close(); }
|
@Test public void test() { final CoffeeEvent actual = cut.deserialize(null, data.getBytes(StandardCharsets.UTF_8)); assertEventEquals(actual, expected); }
|
EmptyDataPacket implements DataPacket { @Override public Map<String, String> getAttributes() { return attributes; } EmptyDataPacket(Map<String, String> attributes); @Override Map<String, String> getAttributes(); @Override InputStream getData(); @Override long getSize(); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); static final Creator<EmptyDataPacket> CREATOR; }
|
@Test public void testAttributes() { assertEquals(attributes, emptyDataPacket.getAttributes()); }
|
OrFileFilter implements ParcelableFileFilter { @Override public boolean accept(File pathname) { for (FileFilter delegate : delegates) { if (delegate.accept(pathname)) { return true; } } return false; } OrFileFilter(ParcelableFileFilter... delegates); @Override boolean accept(File pathname); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); static final Creator<OrFileFilter> CREATOR; }
|
@Test public void testBothAccept() { when(delegate1.accept(file)).thenReturn(true); assertTrue(orFileFilter.accept(file)); verify(delegate1).accept(file); verify(delegate2, never()).accept(file); }
@Test public void testFirstDoesntAccept() { when(delegate1.accept(file)).thenReturn(false); when(delegate2.accept(file)).thenReturn(true); assertTrue(orFileFilter.accept(file)); verify(delegate1).accept(file); verify(delegate2).accept(file); }
@Test public void testNeitherAccept() { when(delegate1.accept(file)).thenReturn(false); when(delegate2.accept(file)).thenReturn(false); assertFalse(orFileFilter.accept(file)); verify(delegate1).accept(file); verify(delegate2).accept(file); }
|
RegexFileFilter implements ParcelableFileFilter { @Override public boolean accept(File pathname) { String pathToMatch = matchAbsolutePath ? pathname.getAbsolutePath() : pathname.getName(); return pattern.matcher(pathToMatch).matches(); } RegexFileFilter(String regex, boolean matchAbsolutePath); @Override boolean accept(File pathname); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); static final Creator<RegexFileFilter> CREATOR; }
|
@Test public void testRegexMatchJustName() { when(file.getName()).thenReturn("testMe.java"); assertTrue(regexFileFilter.accept(file)); }
@Test public void testRegexNoMatchJustName() { when(file.getName()).thenReturn("testMe.jar"); assertFalse(regexFileFilter.accept(file)); }
@Test public void testRegexMatchAbsolutePath() { regex = ".*test.*\\.java"; matchAbsolutePath = true; regexFileFilter = new RegexFileFilter(regex, matchAbsolutePath); when(file.getAbsolutePath()).thenReturn("/abs/path/to/testMe.java"); assertTrue(regexFileFilter.accept(file)); }
@Test public void testRegexNoMatchAbsolutePath() { matchAbsolutePath = true; regexFileFilter = new RegexFileFilter(regex, matchAbsolutePath); when(file.getAbsolutePath()).thenReturn("/abs/path/to/testMe.java"); assertFalse(regexFileFilter.accept(file)); }
|
DirectoryFileFilter implements ParcelableFileFilter { @Override public boolean accept(File pathname) { return pathname.isDirectory(); } @Override boolean accept(File pathname); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); static final Creator<DirectoryFileFilter> CREATOR; }
|
@Test public void testAcceptsDirectory() { when(file.isDirectory()).thenReturn(true); assertTrue(directoryFileFilter.accept(file)); }
@Test public void testDoesntAcceptFile() { when(file.isDirectory()).thenReturn(false); assertFalse(directoryFileFilter.accept(file)); }
|
LastModifiedFileFilter implements ParcelableFileFilter { @Override public boolean accept(File pathname) { long lastModified = pathname.lastModified(); if (lastModified >= minLastModified && lastModified <= maxLastModified) { return true; } return false; } LastModifiedFileFilter(long minLastModified, long maxLastModified); @Override boolean accept(File pathname); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); static final Creator<LastModifiedFileFilter> CREATOR; }
|
@Test public void testDoesntAcceptBeforeMin() { when(file.lastModified()).thenReturn(99L); assertFalse(lastModifiedFileFilter.accept(file)); }
@Test public void testAcceptsMin() { when(file.lastModified()).thenReturn(100L); assertTrue(lastModifiedFileFilter.accept(file)); }
@Test public void testAcceptsMiddle() { when(file.lastModified()).thenReturn(150L); assertTrue(lastModifiedFileFilter.accept(file)); }
@Test public void testAcceptsMax() { when(file.lastModified()).thenReturn(200L); assertTrue(lastModifiedFileFilter.accept(file)); }
@Test public void testDoesntAcceptGreaterThanMax() { when(file.lastModified()).thenReturn(201L); assertFalse(lastModifiedFileFilter.accept(file)); }
|
EmptyDataPacket implements DataPacket { @Override public InputStream getData() { return new ByteArrayInputStream(new byte[0]); } EmptyDataPacket(Map<String, String> attributes); @Override Map<String, String> getAttributes(); @Override InputStream getData(); @Override long getSize(); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); static final Creator<EmptyDataPacket> CREATOR; }
|
@Test public void testGetData() throws IOException { InputStream data = emptyDataPacket.getData(); try { assertEquals(-1, data.read()); } finally { data.close(); } }
|
AndFileFilter implements ParcelableFileFilter { @Override public boolean accept(File pathname) { for (FileFilter delegate : delegates) { if (!delegate.accept(pathname)) { return false; } } return true; } AndFileFilter(ParcelableFileFilter... delegates); @Override boolean accept(File pathname); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); static final Creator<AndFileFilter> CREATOR; }
|
@Test public void testBothAccept() { when(delegate1.accept(file)).thenReturn(true); when(delegate2.accept(file)).thenReturn(true); assertTrue(andFileFilter.accept(file)); verify(delegate1).accept(file); verify(delegate2).accept(file); }
@Test public void testFirstDoesntAccept() { when(delegate1.accept(file)).thenReturn(false); assertFalse(andFileFilter.accept(file)); verify(delegate1).accept(file); verify(delegate2, never()).accept(file); }
@Test public void testSecondDoesntAccept() { when(delegate1.accept(file)).thenReturn(true); when(delegate2.accept(file)).thenReturn(false); assertFalse(andFileFilter.accept(file)); verify(delegate1).accept(file); verify(delegate2).accept(file); }
|
SocketPeerConnector { public SocketPeerConnector(Peer peer, SiteToSiteClientConfig siteToSiteClientConfig, SiteToSiteRemoteCluster siteToSiteRemoteCluster) { this.peer = peer; this.siteToSiteClientConfig = siteToSiteClientConfig; this.siteToSiteRemoteCluster = siteToSiteRemoteCluster; } SocketPeerConnector(Peer peer, SiteToSiteClientConfig siteToSiteClientConfig, SiteToSiteRemoteCluster siteToSiteRemoteCluster); SocketPeerConnection openConnection(boolean negotiateCodec); static final byte[] MAGIC_BYTES; static final int RESOURCE_OK; static final int DIFFERENT_RESOURCE_VERSION; static final int ABORT; static final String SOCKET_FLOW_FILE_PROTOCOL; static final String GZIP; static final String PORT_IDENTIFIER; static final String REQUEST_EXPIRATION_MILLIS; static final String BATCH_COUNT; static final String BATCH_SIZE; static final String BATCH_DURATION; static final String STANDARD_FLOW_FILE_CODEC; }
|
@Test public void testSocketPeerConnector() throws Exception { final String portIdentifier = "abcd"; final ServerSocket serverSocket = new ServerSocket(0); final SiteToSiteClientConfig siteToSiteClientConfig = new SiteToSiteClientConfig(); siteToSiteClientConfig.setPortIdentifier(portIdentifier); final Peer peer = new Peer("localhost", 0, serverSocket.getLocalPort(), false, 0); final Future<Exception> future = startServer(serverSocket, peer, siteToSiteClientConfig, true); SocketPeerConnector connector = new SocketPeerConnector(peer, siteToSiteClientConfig, new SiteToSiteRemoteCluster()); SocketPeerConnection socketPeerConnection = connector.openConnection(true); Exception exception = future.get(); if (exception != null) { throw exception; } assertEquals(6, socketPeerConnection.getFlowFileProtocolVersion()); assertEquals(1, (int) socketPeerConnection.getFlowFileCodecVersion()); }
|
SocketPeerConnector { public SocketPeerConnection openConnection(boolean negotiateCodec) throws IOException { Socket socket; if (peer.isSecure()) { SSLContext sslContext = siteToSiteRemoteCluster.getSslContext(); if (sslContext == null) { throw new IOException("SSL not configured but peer is set to secure"); } socket = sslContext.getSocketFactory().createSocket(peer.getHostname(), peer.getRawPort()); } else { socket = new Socket(peer.getHostname(), peer.getRawPort()); } try { socket.setSoTimeout((int) siteToSiteClientConfig.getTimeout(TimeUnit.MILLISECONDS)); socket.getOutputStream().write(MAGIC_BYTES); int protocolVersion = negotiateVersion(socket, SOCKET_FLOW_FILE_PROTOCOL, new int[] {6, 5, 4, 3, 2, 1}); if (protocolVersion < 5 && siteToSiteClientConfig.getPortIdentifier() == null) { throw new IOException("Unable to find port identifier and it is required for this protocol version (" + protocolVersion + ")"); } protocolHandshake(socket, protocolVersion); Integer codecVersion = null; if (negotiateCodec) { RequestType.NEGOTIATE_FLOWFILE_CODEC.writeRequestType(new DataOutputStream(socket.getOutputStream())); codecVersion = negotiateVersion(socket, STANDARD_FLOW_FILE_CODEC, new int[] {1}); } return new SocketPeerConnection(socket, protocolVersion, codecVersion); } catch (IOException e) { socket.close(); throw e; } } SocketPeerConnector(Peer peer, SiteToSiteClientConfig siteToSiteClientConfig, SiteToSiteRemoteCluster siteToSiteRemoteCluster); SocketPeerConnection openConnection(boolean negotiateCodec); static final byte[] MAGIC_BYTES; static final int RESOURCE_OK; static final int DIFFERENT_RESOURCE_VERSION; static final int ABORT; static final String SOCKET_FLOW_FILE_PROTOCOL; static final String GZIP; static final String PORT_IDENTIFIER; static final String REQUEST_EXPIRATION_MILLIS; static final String BATCH_COUNT; static final String BATCH_SIZE; static final String BATCH_DURATION; static final String STANDARD_FLOW_FILE_CODEC; }
|
@Test public void testSocketPeerConnectorNoCodec() throws Exception { final String portIdentifier = "abcd"; final ServerSocket serverSocket = new ServerSocket(0); final SiteToSiteClientConfig siteToSiteClientConfig = new SiteToSiteClientConfig(); siteToSiteClientConfig.setPortIdentifier(portIdentifier); final Peer peer = new Peer("localhost", 0, serverSocket.getLocalPort(), false, 0); final Future<Exception> future = startServer(serverSocket, peer, siteToSiteClientConfig, false); SocketPeerConnector connector = new SocketPeerConnector(peer, siteToSiteClientConfig, new SiteToSiteRemoteCluster()); SocketPeerConnection socketPeerConnection = connector.openConnection(false); Exception exception = future.get(); if (exception != null) { throw exception; } assertEquals(6, socketPeerConnection.getFlowFileProtocolVersion()); assertNull(socketPeerConnection.getFlowFileCodecVersion()); }
|
EmptyDataPacket implements DataPacket { @Override public long getSize() { return 0; } EmptyDataPacket(Map<String, String> attributes); @Override Map<String, String> getAttributes(); @Override InputStream getData(); @Override long getSize(); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); static final Creator<EmptyDataPacket> CREATOR; }
|
@Test public void testGetSize() { assertEquals(0, emptyDataPacket.getSize()); }
|
DataPacketGetDataException extends RuntimeException { @Override public synchronized IOException getCause() { return (IOException) super.getCause(); } DataPacketGetDataException(IOException cause); @Override synchronized IOException getCause(); }
|
@Test public void testGetCause() { IOException cause = new IOException(); assertEquals(cause, new DataPacketGetDataException(cause).getCause()); }
|
FileDataPacket implements DataPacket { @Override public Map<String, String> getAttributes() { final Map<String, String> attributes = new HashMap<>(); attributes.put("path", file.getParentFile().getPath()); attributes.put("absolute.path", file.getParentFile().getAbsolutePath()); attributes.put("filename", file.getName()); return attributes; } FileDataPacket(File file); @Override Map<String, String> getAttributes(); @Override InputStream getData(); @Override long getSize(); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); static final Creator<FileDataPacket> CREATOR; }
|
@Test public void testAttributes() { Map<String, String> attributes = fileDataPacket.getAttributes(); assertEquals(tempFile.getName(), attributes.get("filename")); assertEquals(tempFile.getParentFile().getPath(), attributes.get("path")); assertEquals(tempFile.getParentFile().getAbsolutePath(), attributes.get("absolute.path")); }
|
FileDataPacket implements DataPacket { @Override public InputStream getData() { try { return new FileInputStream(file); } catch (FileNotFoundException e) { throw new DataPacketGetDataException(e); } } FileDataPacket(File file); @Override Map<String, String> getAttributes(); @Override InputStream getData(); @Override long getSize(); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); static final Creator<FileDataPacket> CREATOR; }
|
@Test public void testGetData() throws IOException { byte[] bytes = new byte[(int) tempFile.length()]; int index = 0; int read = 0; InputStream data = fileDataPacket.getData(); try { while ((read = data.read(bytes, index, bytes.length - index)) != -1 && index < bytes.length) { index += read; } } finally { data.close(); } assertEquals(new String(SOME_TEST_DATA, Charset.defaultCharset()), new String(bytes, Charset.defaultCharset())); }
|
FileDataPacket implements DataPacket { @Override public long getSize() { return file.length(); } FileDataPacket(File file); @Override Map<String, String> getAttributes(); @Override InputStream getData(); @Override long getSize(); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); static final Creator<FileDataPacket> CREATOR; }
|
@Test public void testGetSize() { assertEquals(tempFile.length(), fileDataPacket.getSize()); }
|
ListFileCollector implements DataCollector { @Override public Iterable<DataPacket> getDataPackets() { long maxLastModified = System.currentTimeMillis() - 1; List<DataPacket> dataPackets = new ArrayList<>(); FileFilter fileFilter; if (filterModified) { ParcelableFileFilter modifiedCompoundFilter = new OrFileFilter(new DirectoryFileFilter(), new LastModifiedFileFilter(minModifiedTime, maxLastModified)); fileFilter = new AndFileFilter(modifiedCompoundFilter, this.fileFilter); } else { fileFilter = this.fileFilter; } listRecursive(baseDir, fileFilter, dataPackets); minModifiedTime = maxLastModified + 1; return dataPackets; } ListFileCollector(File baseDir, ParcelableFileFilter fileFilter); ListFileCollector(File baseDir, ParcelableFileFilter fileFilter, long minModifiedTime); protected ListFileCollector(File baseDir, ParcelableFileFilter fileFilter, boolean filterModified, long minModifiedTime); @Override Iterable<DataPacket> getDataPackets(); @Override int describeContents(); @Override void writeToParcel(Parcel dest, int flags); static final Creator<ListFileCollector> CREATOR; }
|
@Test public void testFindsFileInDir() { File childFile = mock(File.class); when(file.listFiles(fileFilter)).thenReturn(new File[]{childFile}); String childFileName = "childFile"; when(childFile.getName()).thenReturn(childFileName); when(childFile.isFile()).thenReturn(true); when(childFile.getParentFile()).thenReturn(file); Iterable<DataPacket> dataPackets = listFileCollector.getDataPackets(); Iterator<DataPacket> iterator = dataPackets.iterator(); assertTrue(iterator.hasNext()); assertEquals(childFileName, iterator.next().getAttributes().get("filename")); assertFalse(iterator.hasNext()); }
@Test public void testRecursive() { File childFile = mock(File.class); File childDir = mock(File.class); when(file.listFiles(fileFilter)).thenReturn(new File[]{childFile, childDir}); String childFileName = "childFile"; when(childFile.getName()).thenReturn(childFileName); when(childFile.isFile()).thenReturn(true); when(childFile.getParentFile()).thenReturn(file); when(childDir.isDirectory()).thenReturn(true); File grandChildFile = mock(File.class); when(grandChildFile.getParentFile()).thenReturn(childDir); String grandChildFileName = "grandChildFile"; when(grandChildFile.getName()).thenReturn(grandChildFileName); when(grandChildFile.isFile()).thenReturn(true); when(childDir.listFiles(fileFilter)).thenReturn(new File[]{grandChildFile}); Iterable<DataPacket> dataPackets = listFileCollector.getDataPackets(); Iterator<DataPacket> iterator = dataPackets.iterator(); assertTrue(iterator.hasNext()); assertEquals(childFileName, iterator.next().getAttributes().get("filename")); assertTrue(iterator.hasNext()); assertEquals(grandChildFileName, iterator.next().getAttributes().get("filename")); assertFalse(iterator.hasNext()); }
@Test public void testModifiedFilter() throws InterruptedException { final long currentTimeMillis = System.currentTimeMillis(); final String validName = "valid"; when(fileFilter.accept(any(File.class))).thenReturn(true); when(file.listFiles(any(FileFilter.class))).thenAnswer(new Answer<File[]>() { @Override public File[] answer(InvocationOnMock invocationOnMock) throws Throwable { File tooOld = mock(File.class); when(tooOld.lastModified()).thenReturn(currentTimeMillis - 1); when(tooOld.isFile()).thenReturn(true); File valid = mock(File.class); when(valid.getName()).thenReturn(validName); when(valid.getParentFile()).thenReturn(file); when(valid.lastModified()).thenReturn(currentTimeMillis); when(valid.isFile()).thenReturn(true); File tooNew = mock(File.class); when(tooNew.lastModified()).thenReturn(System.currentTimeMillis() + TimeUnit.HOURS.toMillis(1)); when(tooNew.isFile()).thenReturn(true); FileFilter filter = (FileFilter) invocationOnMock.getArguments()[0]; List<File> result = new ArrayList<File>(); for (File file : new File[]{tooOld, valid, tooNew}) { if (filter.accept(file)) { result.add(file); } } return result.toArray(new File[result.size()]); } }); listFileCollector = new ListFileCollector(file, fileFilter, currentTimeMillis); Thread.sleep(1); Iterable<DataPacket> dataPackets = listFileCollector.getDataPackets(); Iterator<DataPacket> iterator = dataPackets.iterator(); assertTrue(iterator.hasNext()); assertEquals(validName, iterator.next().getAttributes().get("filename")); assertFalse(iterator.hasNext()); }
|
LoadGeneratorStarter { public static void main(String[] args) { LoadGeneratorStarterArgs starterArgs = parse(args); if (starterArgs == null) { return; } LoadGenerator.Builder builder = prepare(starterArgs); GlobalSummaryListener globalSummaryListener = new GlobalSummaryListener(); builder = builder.resourceListener(globalSummaryListener).requestListener(globalSummaryListener); run(builder); if (starterArgs.isDisplayStats()) { displayGlobalSummaryListener(globalSummaryListener); } } static void main(String[] args); static LoadGeneratorStarterArgs parse(String[] args); static T parse(String[] args, Supplier<T> argsSupplier); static LoadGenerator.Builder prepare(LoadGeneratorStarterArgs starterArgs); static void run(LoadGenerator.Builder builder); static void run(LoadGenerator loadGenerator); }
|
@Test public void simpleTest() throws Exception { String[] args = new String[]{ "--warmup-iterations", "10", "-h", "localhost", "--port", Integer.toString(connector.getLocalPort()), "--running-time", "10", "--running-time-unit", "s", "--resource-rate", "3", "--transport", "http", "--users", "3", "--resource-groovy-path", "src/test/resources/tree_resources.groovy" }; LoadGeneratorStarter.main(args); int getNumber = testServlet.getNumber.get(); LOGGER.debug("received get: {}", getNumber); Assert.assertTrue("getNumber return: " + getNumber, getNumber > 10); }
|
LoadGenerator extends ContainerLifeCycle { public CompletableFuture<Void> begin() { if (logger.isDebugEnabled()) { logger.debug("generating load, {}", config); } return proceed().thenCompose(x -> { CompletableFuture[] futures = new CompletableFuture[config.getThreads()]; for (int i = 0; i < futures.length; ++i) { futures[i] = CompletableFuture.supplyAsync(this::process, executorService).thenCompose(Function.identity()); } return CompletableFuture.allOf(futures); }).thenComposeAsync(x -> halt(), executorService); } private LoadGenerator(Config config); Config getConfig(); CompletableFuture<Void> begin(); @ManagedOperation(value = "Interrupts this LoadGenerator", impact = "ACTION") void interrupt(); }
|
@Test public void testRateIsRespected() throws Exception { int rate = 2000; if (connectionFactory instanceof HTTP2CServerConnectionFactory) { ((HTTP2CServerConnectionFactory)connectionFactory).setMaxConcurrentStreams(rate); } prepare(new TestHandler()); int iterations = 5 * rate; AtomicLong requests = new AtomicLong(); LoadGenerator loadGenerator = new LoadGenerator.Builder() .port(connector.getLocalPort()) .httpClientTransportBuilder(clientTransportBuilder) .iterationsPerThread(iterations) .resourceRate(rate) .socketAddressResolver(new SocketAddressResolver.Sync()) .requestListener(new Request.Listener.Adapter() { @Override public void onBegin(Request request) { requests.incrementAndGet(); } }) .build(); long start = System.nanoTime(); loadGenerator.begin().get(10 * rate, TimeUnit.MILLISECONDS); long elapsed = System.nanoTime() - start; long expected = TimeUnit.SECONDS.toNanos(iterations / rate); Assert.assertTrue(Math.abs(elapsed - expected) < expected / 10); Assert.assertEquals(iterations, requests.intValue()); }
@Test public void testRateRampUp() throws Exception { prepare(new TestHandler()); int rate = 10; long ramp = 5; AtomicLong requests = new AtomicLong(); LoadGenerator loadGenerator = new LoadGenerator.Builder() .port(connector.getLocalPort()) .httpClientTransportBuilder(clientTransportBuilder) .resourceRate(rate) .rateRampUpPeriod(ramp) .requestListener(new Request.Listener.Adapter() { @Override public void onBegin(Request request) { requests.incrementAndGet(); } }) .runFor(ramp, TimeUnit.SECONDS) .build(); loadGenerator.begin().get(); long expected = rate * ramp / 2; Assert.assertTrue(expected - 1 <= requests.get()); Assert.assertTrue(requests.get() <= expected + 1); }
@Test public void testDefaultConfiguration() throws Exception { prepare(new TestHandler()); LoadGenerator loadGenerator = new LoadGenerator.Builder() .port(connector.getLocalPort()) .httpClientTransportBuilder(clientTransportBuilder) .build(); loadGenerator.begin().get(5, TimeUnit.SECONDS); }
@Test public void testMultipleThreads() throws Exception { prepare(new TestHandler()); Set<String> threads = Collections.newSetFromMap(new ConcurrentHashMap<>()); LoadGenerator loadGenerator = new LoadGenerator.Builder() .port(connector.getLocalPort()) .httpClientTransportBuilder(clientTransportBuilder) .threads(2) .iterationsPerThread(1) .requestListener(new Request.Listener.Adapter() { @Override public void onBegin(Request request) { threads.add(Thread.currentThread().getName()); } }) .build(); loadGenerator.begin().get(5, TimeUnit.SECONDS); Assert.assertEquals(2, threads.size()); }
@Test public void testRunFor() throws Exception { prepare(new TestHandler()); long time = 2; TimeUnit unit = TimeUnit.SECONDS; LoadGenerator loadGenerator = new LoadGenerator.Builder() .port(connector.getLocalPort()) .httpClientTransportBuilder(clientTransportBuilder) .runFor(time, unit) .resourceRate(5) .build(); loadGenerator.begin().get(2 * time, unit); }
@Test public void testResourceTree() throws Exception { prepare(new TestHandler()); Queue<String> resources = new ConcurrentLinkedDeque<>(); List<Resource.Info> infos = new ArrayList<>(); LoadGenerator loadGenerator = new LoadGenerator.Builder() .port(connector.getLocalPort()) .httpClientTransportBuilder(clientTransportBuilder) .resource(new Resource("/", new Resource("/1", new Resource("/11").responseLength(1024)) .responseLength(10 * 1024)) .responseLength(16 * 1024)) .resourceListener((Resource.NodeListener)info -> { resources.offer(info.getResource().getPath()); infos.add(info); }) .resourceListener((Resource.TreeListener)info -> resources.offer(info.getResource().getPath())) .build(); loadGenerator.begin().get(5, TimeUnit.SECONDS); Assert.assertEquals("/,/1,/11,/", resources.stream().collect(Collectors.joining(","))); Assert.assertTrue(infos.stream().allMatch(info -> info.getStatus() == 200)); }
@Test public void testResourceGroup() throws Exception { prepare(new TestHandler()); Queue<String> resources = new ConcurrentLinkedDeque<>(); LoadGenerator loadGenerator = new LoadGenerator.Builder() .port(connector.getLocalPort()) .httpClientTransportBuilder(clientTransportBuilder) .resource(new Resource(new Resource("/1").responseLength(10 * 1024))) .resourceListener((Resource.NodeListener)info -> resources.offer(info.getResource().getPath())) .resourceListener((Resource.TreeListener)info -> { if (info.getResource().getPath() == null) { if (resources.size() == 1) { resources.offer("<group>"); } } }) .build(); loadGenerator.begin().get(5, TimeUnit.SECONDS); Assert.assertEquals("/1,<group>", resources.stream().collect(Collectors.joining(","))); }
@Test public void testWarmupDoesNotNotifyResourceListeners() throws Exception { prepare(new TestHandler()); AtomicLong requests = new AtomicLong(); AtomicLong resources = new AtomicLong(); LoadGenerator loadGenerator = new LoadGenerator.Builder() .port(connector.getLocalPort()) .httpClientTransportBuilder(clientTransportBuilder) .warmupIterationsPerThread(2) .iterationsPerThread(3) .resourceRate(5) .resource(new Resource("/").method("POST").responseLength(1024)) .requestListener(new Request.Listener.Adapter() { @Override public void onBegin(Request request) { requests.incrementAndGet(); } }) .resourceListener((Resource.NodeListener)info -> resources.incrementAndGet()) .build(); loadGenerator.begin().get(5, TimeUnit.SECONDS); Assert.assertEquals(5, requests.get()); Assert.assertEquals(3, resources.get()); }
@Test public void testTwoRuns() throws Exception { prepare(new TestHandler()); AtomicLong requests = new AtomicLong(); AtomicLong resources = new AtomicLong(); LoadGenerator loadGenerator = new LoadGenerator.Builder() .port(connector.getLocalPort()) .httpClientTransportBuilder(clientTransportBuilder) .iterationsPerThread(3) .resourceRate(5) .resource(new Resource("/").responseLength(1024)) .requestListener(new Request.Listener.Adapter() { @Override public void onBegin(Request request) { requests.incrementAndGet(); } }) .resourceListener((Resource.NodeListener)info -> resources.incrementAndGet()) .build(); loadGenerator.begin().get(5, TimeUnit.SECONDS); Assert.assertEquals(3, requests.get()); Assert.assertEquals(3, resources.get()); requests.set(0); resources.set(0); loadGenerator.begin().get(5, TimeUnit.SECONDS); Assert.assertEquals(3, requests.get()); Assert.assertEquals(3, resources.get()); }
@Test public void testJMX() throws Exception { prepare(new TestHandler()); LoadGenerator loadGenerator = new LoadGenerator.Builder() .port(connector.getLocalPort()) .httpClientTransportBuilder(clientTransportBuilder) .iterationsPerThread(0) .resourceRate(5) .build(); MBeanContainer mbeanContainer = new MBeanContainer(ManagementFactory.getPlatformMBeanServer()); loadGenerator.addBean(mbeanContainer); ObjectName pattern = new ObjectName(LoadGenerator.class.getPackage().getName() + ":*"); Set<ObjectName> objectNames = mbeanContainer.getMBeanServer().queryNames(pattern, null); Assert.assertTrue(objectNames.size() > 0); Optional<ObjectName> objectNameOpt = objectNames.stream() .filter(o -> o.getKeyProperty("type").equalsIgnoreCase(LoadGenerator.class.getSimpleName())) .findAny(); Assert.assertTrue(objectNameOpt.isPresent()); ObjectName objectName = objectNameOpt.get(); CompletableFuture<Void> cf = loadGenerator.begin(); Thread.sleep(1000); mbeanContainer.getMBeanServer().invoke(objectName, "interrupt", null, new String[]{}); cf.handle((r, x) -> { Throwable cause = x.getCause(); if (cause instanceof InterruptedException) { return null; } else { throw new CompletionException(cause); } }).get(5, TimeUnit.SECONDS); }
|
LoadGenerator extends ContainerLifeCycle { @ManagedOperation(value = "Interrupts this LoadGenerator", impact = "ACTION") public void interrupt() { interrupt = true; } private LoadGenerator(Config config); Config getConfig(); CompletableFuture<Void> begin(); @ManagedOperation(value = "Interrupts this LoadGenerator", impact = "ACTION") void interrupt(); }
|
@Test public void testInterrupt() throws Exception { prepare(new TestHandler()); LoadGenerator loadGenerator = new LoadGenerator.Builder() .port(connector.getLocalPort()) .httpClientTransportBuilder(clientTransportBuilder) .iterationsPerThread(0) .resourceRate(5) .build(); CompletableFuture<Void> cf = loadGenerator.begin(); Thread.sleep(1000); loadGenerator.interrupt(); cf.handle((r, x) -> { Throwable cause = x.getCause(); if (cause instanceof InterruptedException) { return null; } else { throw new CompletionException(cause); } }).get(5, TimeUnit.SECONDS); }
|
SmileEnvelopeEvent implements Event { @Override public DateTime getEventDateTime() { return eventDateTime; } @Deprecated SmileEnvelopeEvent(); SmileEnvelopeEvent(final String eventName, final Map<String, Object> map); SmileEnvelopeEvent(final String eventName, final DateTime eventDateTime,
final Map<String, Object> map); SmileEnvelopeEvent(final String eventName, final Granularity granularity,
final DateTime eventDateTime,
final Map<String, Object> map); @Deprecated SmileEnvelopeEvent(final String eventName, final JsonNode node); @Deprecated SmileEnvelopeEvent(final String eventName, final Granularity granularity,
final JsonNode node); protected SmileEnvelopeEvent(final String eventName, final Granularity granularity,
final DateTime eventDateTime, final JsonNode node); SmileEnvelopeEvent(final String eventName, final byte[] inputBytes, final DateTime eventDateTime, final Granularity granularity); @SuppressWarnings("deprecation") SmileEnvelopeEvent(final JsonNode node); static SmileEnvelopeEvent fromPOJO(final String eventName, final Granularity granularity,
final Object pojo); static SmileEnvelopeEvent fromPOJO(final String eventName, final Granularity granularity,
final DateTime eventDateTime,
final Object pojo); @Override DateTime getEventDateTime(); @Override String getName(); @Override Granularity getGranularity(); @Override String getVersion(); @Override String getOutputDir(final String prefix); @Override Object getData(); ObjectMapper getObjectMapper(); @Override byte[] getSerializedEvent(); @Override void writeExternal(final ObjectOutput out); @Override void readExternal(final ObjectInput in); void writeToJsonGenerator(final JsonGenerator gen); boolean isPlainJson(); void setPlainJson(final boolean plainJson); static DateTime getEventDateTimeFromJson(final JsonNode node); @SuppressWarnings("deprecation") static Granularity getGranularityFromJson(final JsonNode node); @Override String toString(); @Override boolean equals(final Object obj); static final Charset CHARSET; static final Charset NAME_CHARSET; static final String SMILE_EVENT_DATETIME_TOKEN_NAME; static final String SMILE_EVENT_GRANULARITY_TOKEN_NAME; }
|
@Test(groups = "fast") public void testGetEventDateTime() throws Exception { final SmileEnvelopeEvent event = createEvent(); Assert.assertEquals(event.getEventDateTime(), eventDateTime); }
|
IntegerDataItem implements DataItem { @Override public Double getDouble() { return value.doubleValue(); } IntegerDataItem(); IntegerDataItem(final int value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToDouble() throws Exception { Assert.assertEquals(value0.getDouble(), 0.0); Assert.assertEquals(value1.getDouble(), 1.0); Assert.assertEquals(value1000000.getDouble(), 1000000.0); Assert.assertEquals(valueMinus1000000.getDouble(), -1000000.0); }
|
IntegerDataItem implements DataItem { @Override public String getString() { return String.valueOf(value); } IntegerDataItem(); IntegerDataItem(final int value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToStringOk() throws Exception { Assert.assertEquals(value0.getString(), "0"); Assert.assertEquals(value1.getString(), "1"); Assert.assertEquals(value1000000.getString(), "1000000"); Assert.assertEquals(valueMinus1000000.getString(), "-1000000"); }
|
IntegerDataItem implements DataItem { @Override public String toString() { return getString(); } IntegerDataItem(); IntegerDataItem(final int value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testToString() throws Exception { Assert.assertEquals(value0.toString(), "0"); Assert.assertEquals(value1.toString(), "1"); Assert.assertEquals(value1000000.toString(), "1000000"); Assert.assertEquals(valueMinus1000000.toString(), "-1000000"); }
|
BooleanDataItem implements DataItem { @Override public Boolean getBoolean() { return value; } BooleanDataItem(); BooleanDataItem(boolean value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(Object o); @Override boolean equals(Object o); @Override int hashCode(); @Override void write(DataOutput out); @Override void readFields(DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testNoArgConstructor() throws Exception { final DataItem item = new BooleanDataItem(); Assert.assertEquals(item.getBoolean().booleanValue(), true); }
@Test(groups = "fast") public void testConstructor() throws Exception { final DataItem item1 = new BooleanDataItem(true); Assert.assertEquals(item1.getBoolean().booleanValue(), true); final DataItem item2 = new BooleanDataItem(false); Assert.assertEquals(item2.getBoolean().booleanValue(), false); }
@Test(groups = "fast") public void testConvertToBoolean() throws Exception { Assert.assertEquals(trueDataItem.getBoolean().booleanValue(), true); Assert.assertEquals(falseDataItem.getBoolean().booleanValue(), false); }
|
BooleanDataItem implements DataItem { @Override public Byte getByte() { return (byte) (value ? 1 : 0); } BooleanDataItem(); BooleanDataItem(boolean value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(Object o); @Override boolean equals(Object o); @Override int hashCode(); @Override void write(DataOutput out); @Override void readFields(DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToByte() throws Exception { Assert.assertEquals(trueDataItem.getByte().byteValue(), (byte) 1); Assert.assertEquals(falseDataItem.getByte().byteValue(), (byte) 0); }
|
BooleanDataItem implements DataItem { @Override public Short getShort() { return getByte().shortValue(); } BooleanDataItem(); BooleanDataItem(boolean value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(Object o); @Override boolean equals(Object o); @Override int hashCode(); @Override void write(DataOutput out); @Override void readFields(DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToShort() throws Exception { Assert.assertEquals(trueDataItem.getShort().shortValue(), (short) 1); Assert.assertEquals(falseDataItem.getShort().shortValue(), (short) 0); }
|
BooleanDataItem implements DataItem { @Override public Integer getInteger() { return getByte().intValue(); } BooleanDataItem(); BooleanDataItem(boolean value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(Object o); @Override boolean equals(Object o); @Override int hashCode(); @Override void write(DataOutput out); @Override void readFields(DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToInteger() throws Exception { Assert.assertEquals(trueDataItem.getInteger().intValue(), 1); Assert.assertEquals(falseDataItem.getInteger().intValue(), 0); }
|
BooleanDataItem implements DataItem { @Override public Long getLong() { return getByte().longValue(); } BooleanDataItem(); BooleanDataItem(boolean value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(Object o); @Override boolean equals(Object o); @Override int hashCode(); @Override void write(DataOutput out); @Override void readFields(DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToLong() throws Exception { Assert.assertEquals(trueDataItem.getLong().longValue(), 1L); Assert.assertEquals(falseDataItem.getLong().longValue(), 0L); }
|
SmileEnvelopeEvent implements Event { @Override public String getName() { return eventName; } @Deprecated SmileEnvelopeEvent(); SmileEnvelopeEvent(final String eventName, final Map<String, Object> map); SmileEnvelopeEvent(final String eventName, final DateTime eventDateTime,
final Map<String, Object> map); SmileEnvelopeEvent(final String eventName, final Granularity granularity,
final DateTime eventDateTime,
final Map<String, Object> map); @Deprecated SmileEnvelopeEvent(final String eventName, final JsonNode node); @Deprecated SmileEnvelopeEvent(final String eventName, final Granularity granularity,
final JsonNode node); protected SmileEnvelopeEvent(final String eventName, final Granularity granularity,
final DateTime eventDateTime, final JsonNode node); SmileEnvelopeEvent(final String eventName, final byte[] inputBytes, final DateTime eventDateTime, final Granularity granularity); @SuppressWarnings("deprecation") SmileEnvelopeEvent(final JsonNode node); static SmileEnvelopeEvent fromPOJO(final String eventName, final Granularity granularity,
final Object pojo); static SmileEnvelopeEvent fromPOJO(final String eventName, final Granularity granularity,
final DateTime eventDateTime,
final Object pojo); @Override DateTime getEventDateTime(); @Override String getName(); @Override Granularity getGranularity(); @Override String getVersion(); @Override String getOutputDir(final String prefix); @Override Object getData(); ObjectMapper getObjectMapper(); @Override byte[] getSerializedEvent(); @Override void writeExternal(final ObjectOutput out); @Override void readExternal(final ObjectInput in); void writeToJsonGenerator(final JsonGenerator gen); boolean isPlainJson(); void setPlainJson(final boolean plainJson); static DateTime getEventDateTimeFromJson(final JsonNode node); @SuppressWarnings("deprecation") static Granularity getGranularityFromJson(final JsonNode node); @Override String toString(); @Override boolean equals(final Object obj); static final Charset CHARSET; static final Charset NAME_CHARSET; static final String SMILE_EVENT_DATETIME_TOKEN_NAME; static final String SMILE_EVENT_GRANULARITY_TOKEN_NAME; }
|
@Test(groups = "fast") public void testGetName() throws Exception { final SmileEnvelopeEvent event = createEvent(); Assert.assertEquals(event.getName(), SCHEMA_NAME); }
|
BooleanDataItem implements DataItem { @Override public Double getDouble() { return getByte().doubleValue(); } BooleanDataItem(); BooleanDataItem(boolean value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(Object o); @Override boolean equals(Object o); @Override int hashCode(); @Override void write(DataOutput out); @Override void readFields(DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToDouble() throws Exception { Assert.assertEquals(trueDataItem.getDouble(), 1.0); Assert.assertEquals(falseDataItem.getDouble(), 0.0); }
|
BooleanDataItem implements DataItem { @Override public String getString() { return value ? "1" : "0"; } BooleanDataItem(); BooleanDataItem(boolean value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(Object o); @Override boolean equals(Object o); @Override int hashCode(); @Override void write(DataOutput out); @Override void readFields(DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToStringOk() throws Exception { Assert.assertEquals(trueDataItem.getString(), "1"); Assert.assertEquals(falseDataItem.getString(), "0"); }
|
BooleanDataItem implements DataItem { @Override public String toString() { return getString(); } BooleanDataItem(); BooleanDataItem(boolean value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(Object o); @Override boolean equals(Object o); @Override int hashCode(); @Override void write(DataOutput out); @Override void readFields(DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testToString() throws Exception { Assert.assertEquals(trueDataItem.toString(), trueDataItem.getString()); Assert.assertEquals(falseDataItem.toString(), falseDataItem.getString()); }
|
DoubleDataItem implements DataItem { @Override public Double getDouble() { return value; } DoubleDataItem(); DoubleDataItem(final double value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testNoArgConstructor() throws Exception { final DataItem item = new DoubleDataItem(); Assert.assertEquals(item.getDouble(), 0.0); }
@Test(groups = "fast") public void testConstructor() throws Exception { final DataItem item1 = new DoubleDataItem(2.72); Assert.assertEquals(item1.getDouble(), 2.72); }
@Test(groups = "fast") public void testConvertToDouble() throws Exception { Assert.assertEquals(value0.getDouble(), 0.0); Assert.assertEquals(value1.getDouble(), 1.0); Assert.assertEquals(valueWithDecimal.getDouble(), 1.1415); Assert.assertEquals(valueBigPositive.getDouble(), 1000000000.11111); Assert.assertEquals(valueBigNegative.getDouble(), -1000000000.11111); }
|
DoubleDataItem implements DataItem { @Override public Boolean getBoolean() { return !value.equals(0.0); } DoubleDataItem(); DoubleDataItem(final double value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToBoolean() throws Exception { Assert.assertEquals(value0.getBoolean().booleanValue(), false); Assert.assertEquals(value1.getBoolean().booleanValue(), true); Assert.assertEquals(valueWithDecimal.getBoolean().booleanValue(), true); Assert.assertEquals(valueBigPositive.getBoolean().booleanValue(), true); Assert.assertEquals(valueBigNegative.getBoolean().booleanValue(), true); }
|
DoubleDataItem implements DataItem { @Override public Byte getByte() { return value.byteValue(); } DoubleDataItem(); DoubleDataItem(final double value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToByte() throws Exception { Assert.assertEquals(value0.getByte(), Byte.valueOf((byte) 0)); Assert.assertEquals(value1.getByte(), Byte.valueOf((byte) 1)); Assert.assertEquals(valueWithDecimal.getByte(), Byte.valueOf((byte) 1)); Assert.assertEquals(valueBigPositive.getByte(), Byte.valueOf((byte) 0)); Assert.assertEquals(valueBigNegative.getByte(), Byte.valueOf((byte) 0)); }
|
DoubleDataItem implements DataItem { @Override public Short getShort() { return value.shortValue(); } DoubleDataItem(); DoubleDataItem(final double value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToShort() throws Exception { Assert.assertEquals(value0.getShort(), Short.valueOf((short) 0)); Assert.assertEquals(value1.getShort(), Short.valueOf((short) 1)); Assert.assertEquals(valueWithDecimal.getShort(), Short.valueOf((short) 1)); Assert.assertEquals(valueBigPositive.getShort(), Short.valueOf((short) -13824)); Assert.assertEquals(valueBigNegative.getShort(), Short.valueOf((short) 13824)); }
|
DoubleDataItem implements DataItem { @Override public Integer getInteger() { return value.intValue(); } DoubleDataItem(); DoubleDataItem(final double value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToInteger() throws Exception { Assert.assertEquals(value0.getInteger(), Integer.valueOf(0)); Assert.assertEquals(value1.getInteger(), Integer.valueOf(1)); Assert.assertEquals(valueWithDecimal.getInteger(), Integer.valueOf(1)); Assert.assertEquals(valueBigPositive.getInteger(), Integer.valueOf(1000000000)); Assert.assertEquals(valueBigNegative.getInteger(), Integer.valueOf(-1000000000)); }
|
DoubleDataItem implements DataItem { @Override public Long getLong() { return value.longValue(); } DoubleDataItem(); DoubleDataItem(final double value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToLong() throws Exception { Assert.assertEquals(value0.getLong(), Long.valueOf(0)); Assert.assertEquals(value1.getLong(), Long.valueOf(1)); Assert.assertEquals(valueWithDecimal.getLong(), Long.valueOf(1)); Assert.assertEquals(valueBigPositive.getLong(), Long.valueOf(1000000000)); Assert.assertEquals(valueBigNegative.getLong(), Long.valueOf(-1000000000)); }
|
GranularityPathMapper implements Serializable { public Collection<String> getPathsForInterval(final ReadableInterval interval) { final Collection<String> paths = new ArrayList<String>(); granularity.stepThroughInterval(interval, new Granularity.Callback<RuntimeException>() { public void step(final ReadableInterval stepInterval) throws RuntimeException { paths.add(getPathForDateTime(stepInterval.getStart())); } }); return paths; } GranularityPathMapper(final String prefix, final Granularity granularity); String getPrefix(); String getRootPath(); Granularity getGranularity(); Collection<String> getPathsForInterval(final ReadableInterval interval); String getPathForDateTime(final ReadableDateTime dateTime); }
|
@Test(groups = "fast") public void testInterval() { final GranularityPathMapper prefix = new GranularityPathMapper(PREFIX, Granularity.DAILY); final Collection<String> paths = prefix.getPathsForInterval(new MutableInterval(new DateTime("2010-10-01").getMillis(), new DateTime("2010-10-04").getMillis())); final Object[] pathsArray = paths.toArray(); Assert.assertEquals(pathsArray.length, 3); Assert.assertEquals((String) pathsArray[0], String.format("%s/2010/10/01", PREFIX)); Assert.assertEquals((String) pathsArray[1], String.format("%s/2010/10/02", PREFIX)); Assert.assertEquals((String) pathsArray[2], String.format("%s/2010/10/03", PREFIX)); }
|
DoubleDataItem implements DataItem { @Override public String getString() { if (value - value.longValue() == 0) { return String.valueOf(value.longValue()); } else { return String.valueOf(value); } } DoubleDataItem(); DoubleDataItem(final double value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToStringOk() throws Exception { Assert.assertEquals(value0.getString(), "0"); Assert.assertEquals(value1.getString(), "1"); Assert.assertEquals(valueWithDecimal.getString(), "1.1415"); Assert.assertEquals(valueBigPositive.getString(), "1.00000000011111E9"); Assert.assertEquals(valueBigNegative.getString(), "-1.00000000011111E9"); }
|
DoubleDataItem implements DataItem { @Override public String toString() { return getString(); } DoubleDataItem(); DoubleDataItem(final double value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testToString() throws Exception { Assert.assertEquals(value0.toString(), "0"); Assert.assertEquals(value1.toString(), "1"); Assert.assertEquals(valueWithDecimal.toString(), "1.1415"); Assert.assertEquals(valueBigPositive.toString(), "1.00000000011111E9"); Assert.assertEquals(valueBigNegative.toString(), "-1.00000000011111E9"); }
|
ByteDataItem implements DataItem { @Override public Byte getByte() { return value; } ByteDataItem(); ByteDataItem(final byte value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testNoArgConstructor() throws Exception { final DataItem item = new ByteDataItem(); Assert.assertEquals(item.getByte(), Byte.valueOf((byte) 0)); }
@Test(groups = "fast") public void testConstructor() throws Exception { final DataItem item1 = new ByteDataItem((byte) 2); Assert.assertEquals(item1.getByte(), Byte.valueOf((byte) 2)); }
@Test(groups = "fast") public void testConvertToByte() throws Exception { Assert.assertEquals(value0.getByte(), Byte.valueOf((byte) 0)); Assert.assertEquals(value1.getByte(), Byte.valueOf((byte) 1)); Assert.assertEquals(value127.getByte(), Byte.valueOf((byte) 127)); Assert.assertEquals(valueMinus128.getByte(), Byte.valueOf((byte) -128)); }
|
ByteDataItem implements DataItem { @Override public Boolean getBoolean() { return !value.equals((byte) 0); } ByteDataItem(); ByteDataItem(final byte value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToBoolean() throws Exception { Assert.assertEquals(value0.getBoolean().booleanValue(), false); Assert.assertEquals(value1.getBoolean().booleanValue(), true); Assert.assertEquals(value127.getBoolean().booleanValue(), true); Assert.assertEquals(valueMinus128.getBoolean().booleanValue(), true); }
|
ByteDataItem implements DataItem { @Override public Short getShort() { return value.shortValue(); } ByteDataItem(); ByteDataItem(final byte value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToShort() throws Exception { Assert.assertEquals(value0.getShort(), Short.valueOf((short) 0)); Assert.assertEquals(value1.getShort(), Short.valueOf((short) 1)); Assert.assertEquals(value127.getShort(), Short.valueOf((short) 127)); Assert.assertEquals(valueMinus128.getShort(), Short.valueOf((short) -128)); }
|
ByteDataItem implements DataItem { @Override public Integer getInteger() { return value.intValue(); } ByteDataItem(); ByteDataItem(final byte value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToInteger() throws Exception { Assert.assertEquals(value0.getInteger(), Integer.valueOf(0)); Assert.assertEquals(value1.getInteger(), Integer.valueOf(1)); Assert.assertEquals(value127.getInteger(), Integer.valueOf(127)); Assert.assertEquals(valueMinus128.getInteger(), Integer.valueOf(-128)); }
|
ByteDataItem implements DataItem { @Override public Long getLong() { return value.longValue(); } ByteDataItem(); ByteDataItem(final byte value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToLong() throws Exception { Assert.assertEquals(value0.getLong(), Long.valueOf(0L)); Assert.assertEquals(value1.getLong(), Long.valueOf(1L)); Assert.assertEquals(value127.getLong(), Long.valueOf(127L)); Assert.assertEquals(valueMinus128.getLong(), Long.valueOf(-128L)); }
|
IntegerDataItem implements DataItem { @Override public Integer getInteger() { return value; } IntegerDataItem(); IntegerDataItem(final int value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testNoArgConstructor() throws Exception { final DataItem item = new IntegerDataItem(); Assert.assertEquals(item.getInteger(), Integer.valueOf(0)); }
@Test(groups = "fast") public void testConstructor() throws Exception { final DataItem item1 = new IntegerDataItem(2000000); Assert.assertEquals(item1.getInteger(), Integer.valueOf(2000000)); }
@Test(groups = "fast") public void testConvertToInteger() throws Exception { Assert.assertEquals(value0.getInteger(), Integer.valueOf(0)); Assert.assertEquals(value1.getInteger(), Integer.valueOf(1)); Assert.assertEquals(value1000000.getInteger(), Integer.valueOf(1000000)); Assert.assertEquals(valueMinus1000000.getInteger(), Integer.valueOf(-1000000)); }
|
ByteDataItem implements DataItem { @Override public Double getDouble() { return value.doubleValue(); } ByteDataItem(); ByteDataItem(final byte value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToDouble() throws Exception { Assert.assertEquals(value0.getDouble(), 0.0); Assert.assertEquals(value1.getDouble(), 1.0); Assert.assertEquals(value127.getDouble(), 127.0); Assert.assertEquals(valueMinus128.getDouble(), -128.0); }
|
ByteDataItem implements DataItem { @Override public String getString() { return String.valueOf(value); } ByteDataItem(); ByteDataItem(final byte value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToStringOk() throws Exception { Assert.assertEquals(value0.getString(), "0"); Assert.assertEquals(value1.getString(), "1"); Assert.assertEquals(value127.getString(), "127"); Assert.assertEquals(valueMinus128.getString(), "-128"); }
|
ByteDataItem implements DataItem { @Override public String toString() { return getString(); } ByteDataItem(); ByteDataItem(final byte value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testToString() throws Exception { Assert.assertEquals(value0.toString(), value0.getString()); Assert.assertEquals(value1.toString(), value1.getString()); Assert.assertEquals(value127.toString(), value127.getString()); Assert.assertEquals(valueMinus128.toString(), valueMinus128.getString()); }
|
LongDataItem implements DataItem { @Override public Long getLong() { return value; } LongDataItem(); LongDataItem(final long value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testNoArgConstructor() throws Exception { final DataItem item = new LongDataItem(); Assert.assertEquals(item.getLong(), Long.valueOf(0)); }
@Test(groups = "fast") public void testConstructor() throws Exception { final DataItem item1 = new LongDataItem(10000000000L); Assert.assertEquals(item1.getLong(), Long.valueOf(10000000000L)); }
@Test(groups = "fast") public void testConvertToLong() throws Exception { Assert.assertEquals(value0.getLong(), Long.valueOf(0)); Assert.assertEquals(value1.getLong(), Long.valueOf(1)); Assert.assertEquals(valueBigPositive.getLong(), Long.valueOf(10000000000L)); Assert.assertEquals(valueBigNegative.getLong(), Long.valueOf(-10000000000L)); }
|
LongDataItem implements DataItem { @Override public Boolean getBoolean() { return !value.equals(0L); } LongDataItem(); LongDataItem(final long value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToBoolean() throws Exception { Assert.assertEquals(value0.getBoolean().booleanValue(), false); Assert.assertEquals(value1.getBoolean().booleanValue(), true); Assert.assertEquals(valueBigPositive.getBoolean().booleanValue(), true); Assert.assertEquals(valueBigNegative.getBoolean().booleanValue(), true); }
|
LongDataItem implements DataItem { @Override public Byte getByte() { return value.byteValue(); } LongDataItem(); LongDataItem(final long value); @Override Boolean getBoolean(); @Override Byte getByte(); @Override Integer getInteger(); @Override Short getShort(); @Override Long getLong(); @Override String getString(); @Override Double getDouble(); @Override Comparable getComparable(); @Override int compareTo(final Object o); @Override boolean equals(final Object o); @Override int hashCode(); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }
|
@Test(groups = "fast") public void testConvertToByte() throws Exception { Assert.assertEquals(value0.getByte(), Byte.valueOf((byte) 0)); Assert.assertEquals(value1.getByte(), Byte.valueOf((byte) 1)); Assert.assertEquals(valueBigPositive.getByte(), Byte.valueOf((byte) 0)); Assert.assertEquals(valueBigNegative.getByte(), Byte.valueOf((byte) 0)); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.