method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
NamespacesChangesService { public NamespaceChangesStatus cancelAll(String serviceName) { NamespaceChangesStatus namespaceChangesStatus = getNamespaceChangesStatus(serviceName); namespaceChangesStatus.clear(); save(serviceName, namespaceChangesStatus); return namespaceChangesStatus; } void save(String serviceName, NamespaceChangesStatus namespaceChangesStatus); NamespaceChangesStatus getNamespaceChangesStatus(String serviceName); NamespaceChangesStatus approve(String serviceName, NamespacedList namespacedList); NamespaceChangesStatus cancelAll(String serviceName); NamespaceChangesStatus cancel(String serviceName, NamespacedList namespacedList); NamespaceChangesStatus approveAll(String serviceName); }### Answer:
@Test public void cancelAllTest() { NamespaceChangesStatus namespacesChangesStatusReturned = namespacesChangesService.cancelAll(SERVICE_NAME); Assert.assertEquals(0, namespacesChangesStatusReturned.getNamespaceChanges().size()); verify(namespacedListsService, never()).addNamespacedList(namespacedList1); verify(namespacedListsService, never()).addNamespacedList(namespacedList2); verify(namespacedListsService, never()).deleteNamespacedList(namespacedList3.getName()); }
|
### Question:
SimpleServiceDAO extends BaseDAO<T> implements ISimpleServiceDAO<T>, ICacheableDAO { @Override public void delete(String serviceName) { try { deleteByPath(pathHelper.getPathByService(serviceName)); rebuildCache(serviceName); } catch (DataSourceConnectorException e){ throw new RedirectorDataSourceException(e); } } SimpleServiceDAO(Class<T> clazz,
Serializer marshalling,
IDataSourceConnector connector,
IPathHelper pathHelper,
boolean isCompressed,
boolean useCache,
boolean useCacheWhenNotConnectedToDataSource); SimpleServiceDAO(Class<T> clazz,
Serializer marshalling,
IDataSourceConnector zookeeperConnector,
IPathHelper pathHelper,
boolean isCompressed,
boolean useCache); @Override T get(String serviceName); @Override void save(T data, String serviceName); @Override void delete(String serviceName); @Override int getObjectVersion(String serviceName); @Override synchronized void rebuildCache(); @Override void addCacheListener(String serviceName, ICacheListener listener); @Override void close(); }### Answer:
@Test public void testDelete() throws Exception { String path = "/path"; setupPathHelperReturn(path); testee.delete(ANY_SERVICE); verify(connector, times(1)).delete(path); verify(cacheWrapper, times(1)).rebuild(); }
@Test(expected = RedirectorDataSourceException.class) public void testDeleteExceptionHappens() throws Exception { String path = "/path"; setupPathHelperReturn(path); setupExceptionOnDelete(new RedirectorDataSourceException(new Exception())); testee.delete(ANY_SERVICE); }
@Test(expected = RedirectorNoConnectionToDataSourceException.class) public void testDeleteNoConnection() throws Exception { String path = "/path"; setupPathHelperReturn(path); setupExceptionOnDelete(new RedirectorNoConnectionToDataSourceException(new Exception())); testee.delete(ANY_SERVICE); }
|
### Question:
SimpleServiceDAO extends BaseDAO<T> implements ISimpleServiceDAO<T>, ICacheableDAO { @Override public int getObjectVersion(String serviceName) { try { return getCache(serviceName).getCurrentDataVersion(); } catch (DataSourceConnectorException e) { throw new RedirectorDataSourceException(e); } } SimpleServiceDAO(Class<T> clazz,
Serializer marshalling,
IDataSourceConnector connector,
IPathHelper pathHelper,
boolean isCompressed,
boolean useCache,
boolean useCacheWhenNotConnectedToDataSource); SimpleServiceDAO(Class<T> clazz,
Serializer marshalling,
IDataSourceConnector zookeeperConnector,
IPathHelper pathHelper,
boolean isCompressed,
boolean useCache); @Override T get(String serviceName); @Override void save(T data, String serviceName); @Override void delete(String serviceName); @Override int getObjectVersion(String serviceName); @Override synchronized void rebuildCache(); @Override void addCacheListener(String serviceName, ICacheListener listener); @Override void close(); }### Answer:
@Test public void testGetObjectVersion() throws Exception { int version = 5; String path = "/path"; setupPathHelperReturn(path); setupReturnVersion(version); int result = testee.getObjectVersion(ANY_SERVICE); Assert.assertEquals(version, result); }
@Test(expected = RedirectorDataSourceException.class) public void testGetObjectVersionExceptionHappens() throws Exception { String path = "/path"; setupPathHelperReturn(path); setupVersionThrowsException(new RedirectorDataSourceException(new Exception())); testee.getObjectVersion(ANY_SERVICE); }
@Test(expected = RedirectorNoNodeInPathException.class) public void testGetObjectVersionNoConnection() throws Exception { String path = "/path"; setupPathHelperReturn(path); setupVersionThrowsException(new RedirectorNoNodeInPathException(new KeeperException.ConnectionLossException())); testee.getObjectVersion(ANY_SERVICE); }
|
### Question:
StacksDAO implements IStacksDAO { @Override public int getHostsCount(XreStackPath path) { try { return stacksCache.getHostsCount(path); } catch (DataSourceConnectorException e) { throw new RedirectorDataSourceException("failed to get hosts count", e); } } StacksDAO(IDataSourceConnector connector); @Override Set<XreStackPath> getAllStackPaths(); @Override Set<XreStackPath> getAllStackPaths(final Set<String> applicationsToExclude); @Override Collection<HostIPs> getHosts(XreStackPath path); @Override Collection<HostIPs> getHostsByStackOnlyPath(XreStackPath path); @Override List<String> getFlavorsByStackOnlyPath(XreStackPath path); @Override HostIPs getHostByIndex(XreStackPath path, int index); @Override void deleteStackPath(XreStackPath xreStackPath); @Override int getHostsCount(XreStackPath path); @Override Set<String> getAllAppNamesRegisteredInStacks(); @Override void addCacheListener(ICacheListener listener); }### Answer:
@Test public void testGetHostsCount() throws Exception { String path = "/PO/POC1/1.40/xreGuide"; when(connector.getBasePath()).thenReturn("/base"); setupGetChildrenResult("/base" + STACKS_PATH + path, Arrays.asList("host1", "host2", "host3")); setupNodeExists("/base" + STACKS_PATH + path, true); StacksDAO testee = new StacksDAO(connector); int result = testee.getHostsCount(new XreStackPath(path)); Assert.assertEquals(3, result); }
|
### Question:
ListDAO extends BaseListDAO<T> implements IListDAO<T> { @Override public T getById(String id) { try { return getByPath(pathHelper.getPath(id), getCache()); } catch (DataSourceConnectorException e) { throw new RedirectorDataSourceException(e); } } ListDAO(Class<T> clazz,
Serializer marshalling,
IDataSourceConnector connector,
IPathHelper pathHelper,
boolean isCompressed,
boolean useCache); @Override List<T> getAll(); @Override List<String> getAllIDs(); @Override T getById(String id); @Override void saveById(T data, String id); @Override void deleteById(String id); @Override void addCacheListener(ICacheListener listener); }### Answer:
@Test public void testGetById() throws Exception { String id = "id"; String resultSerialized = "testModel"; setupCacheReturnOne(resultSerialized); setupDeserialize(resultSerialized, new TestModel(id)); TestModel result = testee.getById(id); Assert.assertEquals(id, result.getId()); }
@Test(expected = RedirectorDataSourceException.class) public void testGetByIdExceptionHappens() throws Exception { setupExceptionOnGetOne(new RedirectorDataSourceException(new Exception())); testee.getById(ANY_ID); }
@Test(expected = RedirectorNoConnectionToDataSourceException.class) public void testGetByIdNoConnection() throws Exception { setupExceptionOnGetOne(new RedirectorNoConnectionToDataSourceException(new KeeperException.ConnectionLossException())); testee.getById(ANY_ID); }
@Test public void testGetByIdCantDeserialize() throws Exception { String id = "id"; String resultSerialized = "testModel"; setupCacheReturnOne(resultSerialized); setupDeserializeThrowsException(); TestModel result = testee.getById(id); Assert.assertNull(result); }
|
### Question:
ListDAO extends BaseListDAO<T> implements IListDAO<T> { @Override public List<T> getAll() { try { return getAll(getCache()); } catch (DataSourceConnectorException e){ throw new RedirectorDataSourceException(e); } } ListDAO(Class<T> clazz,
Serializer marshalling,
IDataSourceConnector connector,
IPathHelper pathHelper,
boolean isCompressed,
boolean useCache); @Override List<T> getAll(); @Override List<String> getAllIDs(); @Override T getById(String id); @Override void saveById(T data, String id); @Override void deleteById(String id); @Override void addCacheListener(ICacheListener listener); }### Answer:
@Test public void testGetAll() throws Exception { String id = "id"; String resultSerialized = "testModel"; setupCacheReturnMap(id, resultSerialized); setupDeserialize(resultSerialized, new TestModel(id)); List<TestModel> result = testee.getAll(); Assert.assertEquals(id, result.get(0).getId()); }
@Test(expected = RedirectorDataSourceException.class) public void testGetAllExceptionHappens() throws Exception { setupExceptionOnGetAll(new RedirectorDataSourceException(new Exception())); testee.getAll(); }
@Test(expected = RedirectorNoConnectionToDataSourceException.class) public void testGetAllNoConnection() throws Exception { setupExceptionOnGetAll(new RedirectorNoConnectionToDataSourceException(new KeeperException.ConnectionLossException())); testee.getAll(); }
@Test public void testGetAllCantSerialize() throws Exception { String id = "id"; String resultSerialized = "testModel"; setupCacheReturnMap(id, resultSerialized); setupDeserializeThrowsException(); List<TestModel> result = testee.getAll(); Assert.assertEquals(0, result.size()); }
|
### Question:
ListDAO extends BaseListDAO<T> implements IListDAO<T> { @Override public void deleteById(String id) { try { super.deleteByPath(pathHelper.getPath(id), getCache()); } catch (DataSourceConnectorException e) { throw new RedirectorDataSourceException(e); } } ListDAO(Class<T> clazz,
Serializer marshalling,
IDataSourceConnector connector,
IPathHelper pathHelper,
boolean isCompressed,
boolean useCache); @Override List<T> getAll(); @Override List<String> getAllIDs(); @Override T getById(String id); @Override void saveById(T data, String id); @Override void deleteById(String id); @Override void addCacheListener(ICacheListener listener); }### Answer:
@Test public void testDeleteById() throws Exception { String path = "/path"; setupPathHelperReturn(path); testee.deleteById(ANY_ID); verify(connector, times(1)).delete(path); verify(getWrapper()).rebuild(); }
@Test(expected = RedirectorDataSourceException.class) public void testDeleteByIdExceptionHappens() throws Exception { String path = "/path"; setupPathHelperReturn(path); setupExceptionOnDelete(new RedirectorDataSourceException(new Exception())); testee.deleteById(ANY_ID); }
@Test(expected = RedirectorNoConnectionToDataSourceException.class) public void testDeleteByIdNoConnection() throws Exception { String path = "/path"; setupPathHelperReturn(path); setupExceptionOnDelete(new RedirectorNoConnectionToDataSourceException(new Exception())); testee.deleteById(ANY_ID); }
|
### Question:
ZkPathChildrenCacheWrapper extends BaseCacheWrapper implements IPathChildrenCacheWrapper { public boolean isUseCache() { return useCache; } ZkPathChildrenCacheWrapper(IDataSourceConnector connector,
String path,
boolean dataIsCompressed,
PathChildrenCache cache); @Override void start(final PathChildrenCache.StartMode startMode); @Override void addListener(PathChildrenCacheListener listener); @Override void rebuild(); @Override void close(); @Override void rebuildNode(final String path); @Override Map<String, byte[]> getNodeIdToDataMap(); @Override byte[] getCurrentData(String fullPath); boolean isUseCache(); }### Answer:
@Test public void testConstructWithCache() throws Exception { testee = new ZkPathChildrenCacheWrapper(client, "/test", false, cache); Assert.assertTrue(testee.isUseCache()); }
@Test public void testConstructWithoutCache() throws Exception { testee = new ZkPathChildrenCacheWrapper(client, "/test", false, null); Assert.assertFalse(testee.isUseCache()); }
|
### Question:
Utils { public static LocalDateTime saneNowPlusDurationForAlarms(Duration duration) { LocalDateTime proposedLDT = Utils.getNow().plus(duration) .withSecondOfMinute(0) .withMillisOfSecond(0); while (DateTimeZone.getDefault().isLocalDateTimeGap(proposedLDT)) { proposedLDT = proposedLDT.plusMinutes(30); } return proposedLDT; } static LocalDateTime getNow(); static int getAppSmallIcon(); static DatePickerDialog getDatePickerDialog(Context context, DatePickerDialog.OnDateSetListener onDateSetListener, int year, int month, int day); static TimePickerDialog getTimePickerDialog(Context context,
TimePickerDialog.OnTimeSetListener onTimeSetListener,
int hour, int minute, boolean is24HourFormat); static void toastTo(final String toastMessage); static PendingIntent getPIInNewStack(Intent intent, int requestCode); static PendingIntent getPIInNewStack(Intent intent, int requestCode, int flags); static int calculateDaysUntil(LocalDateTime until); static String getFormattedMessageForDate(LocalDateTime localDateTime,
@StringRes int stringRed); static int getSharedUniqueId(); static LocalDateTime saneNowPlusDurationForAlarms(Duration duration); static DateTime convertLocalToDTSafely(LocalDateTime localDateTime); }### Answer:
@Test public void saneNowPlusDurationForAlarms() { DateTimeZone.setDefault(DateTimeZone.forID("America/Los_Angeles")); DateTimeUtils.setCurrentMillisFixed(LocalDateTime.parse("2018-03-11T01:34:00") .toDateTime(DateTimeZone.getDefault()).getMillis()); Assert.assertEquals(LocalDateTime.parse("2018-03-11T03:04:00"), Utils.saneNowPlusDurationForAlarms(Duration.standardMinutes(30))); DateTimeUtils.setCurrentMillisOffset(0L); }
|
### Question:
ValueMapper { public Object map(final Value message) throws ObjectToIdMappingException { final UUID valueId = message.getObservableObjectId(); if (valueId != null) { return objectRegistry.getByIdOrFail(valueId); } else { return message.getSimpleObjectValue(); } } ValueMapper(final WeakObjectRegistry objectRegistry); Object map(final Value message); Value map(final Object value, final boolean isObservable); }### Answer:
@Test public void shouldReturnSimpleObjectObservedValueForSimpleObjectMessages() { final Value message = new Value("some value"); final Object maped = cut.map(message); assertThat(maped).isSameAs(message.getSimpleObjectValue()); }
@Test public void shouldReturnObservableObjectValueForObservableObjectMessage() { final Object sampleObservableObject = "sample object"; when(objectRegistry.getByIdOrFail(SAMPLE_ID)).thenReturn(sampleObservableObject); final Value message = new Value(SAMPLE_ID); final Object maped = cut.map(message); assertThat(maped).isSameAs(sampleObservableObject); }
@Test public void shouldReturnSimpleObjectMessageForSimpleObjectValue() { final Value message = cut.map("sample object", false); assertThat(message.getObservableObjectId()).isNull(); assertThat(message.getSimpleObjectValue()).isSameAs("sample object"); }
@Test public void shouldReturnObservableObjectMessageForObservableObjectValue() { Object sampleObservableObject = "sample object"; when(objectRegistry.getIdOrFail(sampleObservableObject)).thenReturn(SAMPLE_ID); Value message = cut.map(sampleObservableObject, true); assertThat(message.getObservableObjectId()).isEqualTo(SAMPLE_ID); assertThat(message.getSimpleObjectValue()).isNull(); }
|
### Question:
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); }### Answer:
@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); }
|
### Question:
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); }### Answer:
@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); }
|
### Question:
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); }### Answer:
@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); }
|
### Question:
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); }### Answer:
@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()); }
|
### Question:
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); }### Answer:
@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(); }
|
### Question:
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); }### Answer:
@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); }
|
### Question:
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); }### Answer:
@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); }
|
### Question:
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); }### Answer:
@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); }
|
### Question:
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); }### Answer:
@Test(expected = ObjectToIdMappingException.class) public void failsWhenMetaDataShouldBeStoredForAPropertyThatAlreadyHasMetaData() { cut.storeMetaDataOrFail(list1, exampleMetaData1); cut.storeMetaDataOrFail(list1, exampleMetaData2); }
|
### Question:
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); }### Answer:
@Test(expected = ObjectToIdMappingException.class) public void failsWhenMetaDataShouldBeRetrivedForAPropertyThatHasNoKnownMetaData() { cut.getMetaDataOrFail(list1); }
|
### Question:
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); }### Answer:
@Test public void shouldReturnEmptyOptionalForUnknownObject() { Object unknownObject = "example unknown object"; Optional<UUID> id = cut.getId(unknownObject); assertThat(id.isPresent()).isFalse(); }
|
### Question:
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); }### Answer:
@Test public void shouldReturnEmptyOptionalForUnknownId() { UUID unknownId = UUID.randomUUID(); Optional<Object> object = cut.getById(unknownId); assertThat(object.isPresent()).isFalse(); }
|
### Question:
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); }### Answer:
@Test(expected = ObjectToIdMappingException.class) public void shouldFailWhenIdForAnUnregisteredObjectIsRequested() { Object unknownObject = "example unknown object"; cut.getIdOrFail(unknownObject); }
|
### Question:
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); }### Answer:
@Test(expected = ObjectToIdMappingException.class) public void shouldFailWhenObjectForAnUnknownIdIsRequested() { UUID unknownId = UUID.randomUUID(); cut.getByIdOrFail(unknownId); }
|
### Question:
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; }### Answer:
@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); }
|
### Question:
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(); }### Answer:
@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); } }
|
### Question:
MetricRegistriesLoader { public static MetricRegistries load() { List<MetricRegistries> availableImplementations = getDefinedImplemantations(); return load(availableImplementations); } private MetricRegistriesLoader(); static MetricRegistries load(); }### Answer:
@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); }
|
### Question:
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; }### Answer:
@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()); }
|
### Question:
RefCountingMap { int size() { return map.size(); } }### Answer:
@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()); }
|
### Question:
RefCountingMap { void clear() { map.clear(); } }### Answer:
@Test public void testClear() { map.put("foo", () -> "foovalue"); map.put("bar", () -> "foovalue2"); map.put("baz", () -> "foovalue3"); map.clear(); assertEquals(0, map.size()); }
|
### Question:
RefCountingMap { Set<K> keySet() { return map.keySet(); } }### Answer:
@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))); }
|
### Question:
RefCountingMap { Collection<V> values() { return map.values().stream().map(v -> v.v).collect(Collectors.toList()); } }### Answer:
@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))); }
|
### Question:
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; }### Answer:
@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); }
|
### Question:
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(); }### Answer:
@Test public void test() { final String actual = new String(cut.serialize(null, event), StandardCharsets.UTF_8); assertEquals(expected, actual); }
|
### Question:
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(); }### Answer:
@Test public void test() { final CoffeeEvent actual = cut.deserialize(null, data.getBytes(StandardCharsets.UTF_8)); assertEventEquals(actual, expected); }
|
### Question:
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; }### Answer:
@Test public void testAttributes() { assertEquals(attributes, emptyDataPacket.getAttributes()); }
|
### Question:
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; }### Answer:
@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); }
|
### Question:
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; }### Answer:
@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)); }
|
### Question:
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; }### Answer:
@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)); }
|
### Question:
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; }### Answer:
@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)); }
|
### Question:
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; }### Answer:
@Test public void testGetData() throws IOException { InputStream data = emptyDataPacket.getData(); try { assertEquals(-1, data.read()); } finally { data.close(); } }
|
### Question:
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; }### Answer:
@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); }
|
### Question:
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; }### Answer:
@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()); }
|
### Question:
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; }### Answer:
@Test public void testGetSize() { assertEquals(0, emptyDataPacket.getSize()); }
|
### Question:
DataPacketGetDataException extends RuntimeException { @Override public synchronized IOException getCause() { return (IOException) super.getCause(); } DataPacketGetDataException(IOException cause); @Override synchronized IOException getCause(); }### Answer:
@Test public void testGetCause() { IOException cause = new IOException(); assertEquals(cause, new DataPacketGetDataException(cause).getCause()); }
|
### Question:
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; }### Answer:
@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")); }
|
### Question:
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; }### Answer:
@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())); }
|
### Question:
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; }### Answer:
@Test public void testGetSize() { assertEquals(tempFile.length(), fileDataPacket.getSize()); }
|
### Question:
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); }### Answer:
@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); }
|
### Question:
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(); }### Answer:
@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); }
|
### Question:
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(); }### Answer:
@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); }
|
### Question:
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(); }### Answer:
@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"); }
|
### Question:
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(); }### Answer:
@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"); }
|
### Question:
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(); }### Answer:
@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); }
|
### Question:
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(); }### Answer:
@Test(groups = "fast") public void testConvertToByte() throws Exception { Assert.assertEquals(trueDataItem.getByte().byteValue(), (byte) 1); Assert.assertEquals(falseDataItem.getByte().byteValue(), (byte) 0); }
|
### Question:
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(); }### Answer:
@Test(groups = "fast") public void testConvertToShort() throws Exception { Assert.assertEquals(trueDataItem.getShort().shortValue(), (short) 1); Assert.assertEquals(falseDataItem.getShort().shortValue(), (short) 0); }
|
### Question:
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(); }### Answer:
@Test(groups = "fast") public void testConvertToInteger() throws Exception { Assert.assertEquals(trueDataItem.getInteger().intValue(), 1); Assert.assertEquals(falseDataItem.getInteger().intValue(), 0); }
|
### Question:
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(); }### Answer:
@Test(groups = "fast") public void testConvertToLong() throws Exception { Assert.assertEquals(trueDataItem.getLong().longValue(), 1L); Assert.assertEquals(falseDataItem.getLong().longValue(), 0L); }
|
### Question:
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(); }### Answer:
@Test(groups = "fast") public void testConvertToDouble() throws Exception { Assert.assertEquals(trueDataItem.getDouble(), 1.0); Assert.assertEquals(falseDataItem.getDouble(), 0.0); }
|
### Question:
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(); }### Answer:
@Test(groups = "fast") public void testConvertToStringOk() throws Exception { Assert.assertEquals(trueDataItem.getString(), "1"); Assert.assertEquals(falseDataItem.getString(), "0"); }
|
### Question:
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(); }### Answer:
@Test(groups = "fast") public void testToString() throws Exception { Assert.assertEquals(trueDataItem.toString(), trueDataItem.getString()); Assert.assertEquals(falseDataItem.toString(), falseDataItem.getString()); }
|
### Question:
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(); }### Answer:
@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); }
|
### Question:
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(); }### Answer:
@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); }
|
### Question:
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(); }### Answer:
@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)); }
|
### Question:
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(); }### Answer:
@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)); }
|
### Question:
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(); }### Answer:
@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)); }
|
### Question:
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(); }### Answer:
@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)); }
|
### Question:
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); }### Answer:
@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)); }
|
### Question:
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(); }### Answer:
@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"); }
|
### Question:
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(); }### Answer:
@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"); }
|
### Question:
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(); }### Answer:
@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)); }
|
### Question:
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(); }### Answer:
@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); }
|
### Question:
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(); }### Answer:
@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)); }
|
### Question:
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(); }### Answer:
@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)); }
|
### Question:
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(); }### Answer:
@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)); }
|
### Question:
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(); }### Answer:
@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)); }
|
### Question:
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(); }### Answer:
@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); }
|
### Question:
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(); }### Answer:
@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"); }
|
### Question:
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(); }### Answer:
@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()); }
|
### Question:
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(); }### Answer:
@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)); }
|
### Question:
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(); }### Answer:
@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); }
|
### Question:
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(); }### Answer:
@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)); }
|
### Question:
LongDataItem implements DataItem { @Override public Short getShort() { return value.shortValue(); } 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(); }### Answer:
@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(valueBigPositive.getShort(), Short.valueOf((short) -7168)); Assert.assertEquals(valueBigNegative.getShort(), Short.valueOf((short) 7168)); }
|
### Question:
LongDataItem implements DataItem { @Override public Integer getInteger() { return value.intValue(); } 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(); }### Answer:
@Test(groups = "fast") public void testConvertToInteger() throws Exception { Assert.assertEquals(value0.getInteger(), Integer.valueOf(0)); Assert.assertEquals(value1.getInteger(), Integer.valueOf(1)); Assert.assertEquals(valueBigPositive.getInteger(), Integer.valueOf(1410065408)); Assert.assertEquals(valueBigNegative.getInteger(), Integer.valueOf(-1410065408)); }
|
### Question:
LongDataItem implements DataItem { @Override public Double getDouble() { return value.doubleValue(); } 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(); }### Answer:
@Test(groups = "fast") public void testConvertToDouble() throws Exception { Assert.assertEquals(value0.getDouble(), 0.0); Assert.assertEquals(value1.getDouble(), 1.0); Assert.assertEquals(valueBigPositive.getDouble(), 10000000000.0); Assert.assertEquals(valueBigNegative.getDouble(), -10000000000.0); }
|
### Question:
LongDataItem implements DataItem { @Override public String getString() { return String.valueOf(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(); }### Answer:
@Test(groups = "fast") public void testConvertToStringOk() throws Exception { Assert.assertEquals(value0.getString(), "0"); Assert.assertEquals(value1.getString(), "1"); Assert.assertEquals(valueBigPositive.getString(), "10000000000"); Assert.assertEquals(valueBigNegative.getString(), "-10000000000"); }
|
### Question:
LongDataItem implements DataItem { @Override public String toString() { return getString(); } 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(); }### Answer:
@Test(groups = "fast") public void testToString() throws Exception { Assert.assertEquals(value0.toString(), "0"); Assert.assertEquals(value1.toString(), "1"); Assert.assertEquals(valueBigPositive.toString(), "10000000000"); Assert.assertEquals(valueBigNegative.toString(), "-10000000000"); }
|
### Question:
ShortDataItem implements DataItem { @Override public Short getShort() { return value; } ShortDataItem(); ShortDataItem(final short 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(); }### Answer:
@Test(groups = "fast") public void testNoArgConstructor() throws Exception { final DataItem item = new ShortDataItem(); Assert.assertEquals(item.getShort(), Short.valueOf((short) 0)); }
@Test(groups = "fast") public void testConstructor() throws Exception { final DataItem item1 = new ShortDataItem((short) 100); Assert.assertEquals(item1.getShort(), Short.valueOf((short) 100)); }
@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(value1000.getShort(), Short.valueOf((short) 1000)); Assert.assertEquals(valueMinus1000.getShort(), Short.valueOf((short) -1000)); }
|
### Question:
ShortDataItem implements DataItem { @Override public Boolean getBoolean() { return !value.equals((short) 0); } ShortDataItem(); ShortDataItem(final short 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(); }### Answer:
@Test(groups = "fast") public void testConvertToBoolean() throws Exception { Assert.assertEquals(value0.getBoolean().booleanValue(), false); Assert.assertEquals(value1.getBoolean().booleanValue(), true); Assert.assertEquals(value1000.getBoolean().booleanValue(), true); Assert.assertEquals(valueMinus1000.getBoolean().booleanValue(), true); }
|
### Question:
ShortDataItem implements DataItem { @Override public Byte getByte() { return value.byteValue(); } ShortDataItem(); ShortDataItem(final short 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(); }### Answer:
@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(value1000.getByte(), Byte.valueOf((byte) -24)); Assert.assertEquals(valueMinus1000.getByte(), Byte.valueOf((byte) 24)); }
|
### Question:
ShortDataItem implements DataItem { @Override public Integer getInteger() { return value.intValue(); } ShortDataItem(); ShortDataItem(final short 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(); }### Answer:
@Test(groups = "fast") public void testConvertToInteger() throws Exception { Assert.assertEquals(value0.getInteger(), Integer.valueOf(0)); Assert.assertEquals(value1.getInteger(), Integer.valueOf(1)); Assert.assertEquals(value1000.getInteger(), Integer.valueOf(1000)); Assert.assertEquals(valueMinus1000.getInteger(), Integer.valueOf(-1000)); }
|
### Question:
ShortDataItem implements DataItem { @Override public Long getLong() { return value.longValue(); } ShortDataItem(); ShortDataItem(final short 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(); }### Answer:
@Test(groups = "fast") public void testConvertToLong() throws Exception { Assert.assertEquals(value0.getLong(), Long.valueOf(0)); Assert.assertEquals(value1.getLong(), Long.valueOf(1)); Assert.assertEquals(value1000.getLong(), Long.valueOf(1000)); Assert.assertEquals(valueMinus1000.getLong(), Long.valueOf(-1000)); }
|
### Question:
IntegerDataItem implements DataItem { @Override public Boolean getBoolean() { return !value.equals(0); } 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(); }### Answer:
@Test(groups = "fast") public void testConvertToBoolean() throws Exception { Assert.assertEquals(value0.getBoolean().booleanValue(), false); Assert.assertEquals(value1.getBoolean().booleanValue(), true); Assert.assertEquals(value1000000.getBoolean().booleanValue(), true); Assert.assertEquals(valueMinus1000000.getBoolean().booleanValue(), true); }
|
### Question:
ShortDataItem implements DataItem { @Override public Double getDouble() { return value.doubleValue(); } ShortDataItem(); ShortDataItem(final short 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(); }### Answer:
@Test(groups = "fast") public void testConvertToDouble() throws Exception { Assert.assertEquals(value0.getDouble(), 0.0); Assert.assertEquals(value1.getDouble(), 1.0); Assert.assertEquals(value1000.getDouble(), 1000.0); Assert.assertEquals(valueMinus1000.getDouble(), -1000.0); }
|
### Question:
ShortDataItem implements DataItem { @Override public String getString() { return String.valueOf(value); } ShortDataItem(); ShortDataItem(final short 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(); }### Answer:
@Test(groups = "fast") public void testConvertToStringOk() throws Exception { Assert.assertEquals(value0.getString(), "0"); Assert.assertEquals(value1.getString(), "1"); Assert.assertEquals(value1000.getString(), "1000"); Assert.assertEquals(valueMinus1000.getString(), "-1000"); }
|
### Question:
ShortDataItem implements DataItem { @Override public String toString() { return getString(); } ShortDataItem(); ShortDataItem(final short 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(); }### Answer:
@Test(groups = "fast") public void testToString() throws Exception { Assert.assertEquals(value0.toString(), "0"); Assert.assertEquals(value1.toString(), "1"); Assert.assertEquals(value1000.toString(), "1000"); Assert.assertEquals(valueMinus1000.toString(), "-1000"); }
|
### Question:
StringDataItem implements DataItem { @Override public String getString() { return value; } StringDataItem(); StringDataItem(final String 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 int hashCode(); @Override boolean equals(final Object o); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }### Answer:
@Test(groups = "fast") public void testNoArgConstructor() throws Exception { final DataItem item = new StringDataItem(); Assert.assertEquals(item.getString(), ""); }
@Test(groups = "fast") public void testConstructor() throws Exception { final String testString = "test-string"; final DataItem item1 = new StringDataItem(testString); Assert.assertEquals(item1.getString(), testString); }
|
### Question:
StringDataItem implements DataItem { @Override public Double getDouble() { if (value.isEmpty()) { return (double) 0; } return Double.valueOf(value); } StringDataItem(); StringDataItem(final String 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 int hashCode(); @Override boolean equals(final Object o); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }### Answer:
@Test(groups = "fast") public void testConvertToDoubleOk() throws Exception { final long value1 = 1341345143; final DataItem item1 = new StringDataItem(String.valueOf(value1)); Assert.assertEquals(item1.getDouble(), (double) value1); final double value2 = 1341345143.13242142; final DataItem item2 = new StringDataItem(String.valueOf(value2)); Assert.assertEquals(item2.getDouble(), value2); }
@Test(groups = "fast") public void testConvertToDoubleFail() throws Exception { try { final DataItem item = new StringDataItem("a string"); item.getDouble(); Assert.fail("expected NumberFormatException NOT thrown"); } catch (Exception e) { Assert.assertEquals(e.getClass(), NumberFormatException.class); } }
|
### Question:
StringDataItem implements DataItem { @Override public Long getLong() { if (value.isEmpty()) { return (long) 0; } return Long.valueOf(value); } StringDataItem(); StringDataItem(final String 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 int hashCode(); @Override boolean equals(final Object o); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }### Answer:
@Test(groups = "fast") public void testConvertToLongOk() throws Exception { final long value = 7890; final DataItem item = new StringDataItem(String.valueOf(value)); Assert.assertEquals(item.getLong(), Long.valueOf(value)); }
@Test(groups = "fast") public void testConvertToLongFail() throws Exception { try { final DataItem item = new StringDataItem("a string"); item.getLong(); Assert.fail("expected NumberFormatException NOT thrown"); } catch (Exception e) { Assert.assertEquals(e.getClass(), NumberFormatException.class); } }
|
### Question:
StringDataItem implements DataItem { @Override public String toString() { return getString(); } StringDataItem(); StringDataItem(final String 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 int hashCode(); @Override boolean equals(final Object o); @Override void write(final DataOutput out); @Override void readFields(final DataInput in); @Override String toString(); @Override byte getThriftType(); }### Answer:
@Test(groups = "fast") public void testToString() throws Exception { final DataItem item = new StringDataItem("...a.a.sd.f...sf"); Assert.assertEquals(item.toString(), item.getString()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.