src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
ListenerCollection { public synchronized void remove(Listener listener) { listeners.remove(listener); } synchronized void add(Listener listener); synchronized void remove(Listener listener); synchronized void safeForEach(HandlerMethod<Listener> method); } | @Test public void testRemove() throws Exception { ListenerCollection<Runnable> collection = new ListenerCollection<>(); IMocksControl control = EasyMock.createControl(); Runnable l1 = control.createMock("l1", Runnable.class); Runnable l2 = control.createMock("l2", Runnable.class); control.checkOrder(true); l2.run(); EasyMock.expectLastCall().once(); control.replay(); collection.add(l1); collection.add(l2); collection.remove(l1); collection.safeForEach(Runnable::run); control.verify(); } |
XMLConfiguration implements TileLayerConfiguration,
InitializingBean,
DefaultingConfiguration,
ServerConfiguration,
BlobStoreConfiguration,
GridSetConfiguration { public synchronized void addLayer(TileLayer tl) throws IllegalArgumentException { if (tl == null) { throw new NullPointerException(); } if (!canSaveIfNotTransient(tl)) { throw new IllegalArgumentException( "Can't add layers of type " + tl.getClass().getName()); } if (getLayer(tl.getName()).isPresent()) { throw new IllegalArgumentException("Layer '" + tl.getName() + "' already exists"); } initialize(tl); getGwcConfig().getLayers().add(tl); updateLayers(); try { save(); } catch (IOException e) { if (getGwcConfig().getLayers().remove(tl)) { updateLayers(); } throw new ConfigurationPersistenceException("Unable to add layer " + tl.getName(), e); } } XMLConfiguration(
final ApplicationContextProvider appCtx, final ConfigurationResourceProvider inFac); XMLConfiguration(
final ApplicationContextProvider appCtx,
final String configFileDirectory,
final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final String configFileDirectory); void setTemplate(String template); String getConfigLocation(); Boolean isRuntimeStatsEnabled(); void setRuntimeStatsEnabled(Boolean isEnabled); synchronized ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInfo); @Override void setDefaultValues(TileLayer layer); XStream getConfiguredXStream(XStream xs); static XStream getConfiguredXStream(XStream xs, WebApplicationContext context); XStream getConfiguredXStreamWithContext(
XStream xs, ContextualConfigurationProvider.Context providerContext); static XStream getConfiguredXStreamWithContext(
XStream xs,
WebApplicationContext context,
ContextualConfigurationProvider.Context providerContext); boolean canSave(TileLayer tl); synchronized void addLayer(TileLayer tl); synchronized void modifyLayer(TileLayer tl); void renameLayer(String oldName, String newName); synchronized void removeLayer(final String layerName); void afterPropertiesSet(); String getIdentifier(); void setRelativePath(String relPath); void setAbsolutePath(String absPath); Collection<TileLayer> getLayers(); Optional<TileLayer> getLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayerById(String layerId); boolean containsLayer(String layerId); int getLayerCount(); Set<String> getLayerNames(); String getVersion(); @Override Boolean isFullWMS(); @Override void setFullWMS(Boolean isFullWMS); @Override List<BlobStoreInfo> getBlobStores(); @Override synchronized void addBlobStore(BlobStoreInfo info); @Override synchronized void removeBlobStore(String name); @Override synchronized void modifyBlobStore(BlobStoreInfo info); @Override int getBlobStoreCount(); @Override Set<String> getBlobStoreNames(); @Override Optional<BlobStoreInfo> getBlobStore(String name); @Override boolean canSave(BlobStoreInfo info); @Override void renameBlobStore(String oldName, String newName); @Override boolean containsBlobStore(String name); @Override void addBlobStoreListener(BlobStoreConfigurationListener listener); @Override void removeBlobStoreListener(BlobStoreConfigurationListener listener); @Override LockProvider getLockProvider(); @Override void setLockProvider(LockProvider lockProvider); @Override Boolean isWmtsCiteCompliant(); void setWmtsCiteCompliant(Boolean wmtsCiteStrictCompliant); @Override Integer getBackendTimeout(); @Override void setBackendTimeout(Integer backendTimeout); @Override Boolean isCacheBypassAllowed(); @Override void setCacheBypassAllowed(Boolean cacheBypassAllowed); @Override String getLocation(); @Override synchronized void addGridSet(GridSet gridSet); @Override synchronized void removeGridSet(String gridSetName); @Override Optional<GridSet> getGridSet(String name); @Override Collection<GridSet> getGridSets(); @Override synchronized void modifyGridSet(GridSet gridSet); @Override void renameGridSet(String oldName, String newName); @Override boolean canSave(GridSet gridset); @Autowired @Override void setGridSetBroker(@Qualifier("gwcGridSetBroker") GridSetBroker broker); @Override void deinitialize(); static final String DEFAULT_CONFIGURATION_FILE_NAME; } | @Test public void testAddLayer() throws Exception { int count = config.getLayerCount(); TileLayer tl = createTestLayer("testLayer"); config.addLayer(tl); assertEquals(count + 1, config.getLayerCount()); assertSame(tl, config.getLayer("testLayer").get()); try { config.addLayer(tl); fail("Expected IllegalArgumentException on duplicate layer name"); } catch (IllegalArgumentException e) { assertEquals("Layer 'testLayer' already exists", e.getMessage()); } } |
XMLConfiguration implements TileLayerConfiguration,
InitializingBean,
DefaultingConfiguration,
ServerConfiguration,
BlobStoreConfiguration,
GridSetConfiguration { public boolean canSave(TileLayer tl) { if (tl.isTransientLayer()) { return false; } return canSaveIfNotTransient(tl); } XMLConfiguration(
final ApplicationContextProvider appCtx, final ConfigurationResourceProvider inFac); XMLConfiguration(
final ApplicationContextProvider appCtx,
final String configFileDirectory,
final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final String configFileDirectory); void setTemplate(String template); String getConfigLocation(); Boolean isRuntimeStatsEnabled(); void setRuntimeStatsEnabled(Boolean isEnabled); synchronized ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInfo); @Override void setDefaultValues(TileLayer layer); XStream getConfiguredXStream(XStream xs); static XStream getConfiguredXStream(XStream xs, WebApplicationContext context); XStream getConfiguredXStreamWithContext(
XStream xs, ContextualConfigurationProvider.Context providerContext); static XStream getConfiguredXStreamWithContext(
XStream xs,
WebApplicationContext context,
ContextualConfigurationProvider.Context providerContext); boolean canSave(TileLayer tl); synchronized void addLayer(TileLayer tl); synchronized void modifyLayer(TileLayer tl); void renameLayer(String oldName, String newName); synchronized void removeLayer(final String layerName); void afterPropertiesSet(); String getIdentifier(); void setRelativePath(String relPath); void setAbsolutePath(String absPath); Collection<TileLayer> getLayers(); Optional<TileLayer> getLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayerById(String layerId); boolean containsLayer(String layerId); int getLayerCount(); Set<String> getLayerNames(); String getVersion(); @Override Boolean isFullWMS(); @Override void setFullWMS(Boolean isFullWMS); @Override List<BlobStoreInfo> getBlobStores(); @Override synchronized void addBlobStore(BlobStoreInfo info); @Override synchronized void removeBlobStore(String name); @Override synchronized void modifyBlobStore(BlobStoreInfo info); @Override int getBlobStoreCount(); @Override Set<String> getBlobStoreNames(); @Override Optional<BlobStoreInfo> getBlobStore(String name); @Override boolean canSave(BlobStoreInfo info); @Override void renameBlobStore(String oldName, String newName); @Override boolean containsBlobStore(String name); @Override void addBlobStoreListener(BlobStoreConfigurationListener listener); @Override void removeBlobStoreListener(BlobStoreConfigurationListener listener); @Override LockProvider getLockProvider(); @Override void setLockProvider(LockProvider lockProvider); @Override Boolean isWmtsCiteCompliant(); void setWmtsCiteCompliant(Boolean wmtsCiteStrictCompliant); @Override Integer getBackendTimeout(); @Override void setBackendTimeout(Integer backendTimeout); @Override Boolean isCacheBypassAllowed(); @Override void setCacheBypassAllowed(Boolean cacheBypassAllowed); @Override String getLocation(); @Override synchronized void addGridSet(GridSet gridSet); @Override synchronized void removeGridSet(String gridSetName); @Override Optional<GridSet> getGridSet(String name); @Override Collection<GridSet> getGridSets(); @Override synchronized void modifyGridSet(GridSet gridSet); @Override void renameGridSet(String oldName, String newName); @Override boolean canSave(GridSet gridset); @Autowired @Override void setGridSetBroker(@Qualifier("gwcGridSetBroker") GridSetBroker broker); @Override void deinitialize(); static final String DEFAULT_CONFIGURATION_FILE_NAME; } | @Test public void testNotAddLayer() throws Exception { TileLayer tl = mock(WMSLayer.class); when(tl.getName()).thenReturn("testLayer"); when(tl.isTransientLayer()).thenReturn(true); assertFalse(config.canSave(tl)); } |
XMLConfiguration implements TileLayerConfiguration,
InitializingBean,
DefaultingConfiguration,
ServerConfiguration,
BlobStoreConfiguration,
GridSetConfiguration { public synchronized void modifyLayer(TileLayer tl) throws NoSuchElementException { TileLayer previous = findLayer(tl.getName()); if (!canSaveIfNotTransient(tl)) { throw new IllegalArgumentException( "Can't add layers of type " + tl.getClass().getName()); } getGwcConfig().getLayers().remove(previous); initialize(tl); getGwcConfig().getLayers().add(tl); updateLayers(); try { save(); } catch (IOException e) { getGwcConfig().getLayers().remove(tl); initialize(previous); getGwcConfig().getLayers().add(previous); updateLayers(); throw new IllegalArgumentException("Unable to modify layer " + tl.getName(), e); } } XMLConfiguration(
final ApplicationContextProvider appCtx, final ConfigurationResourceProvider inFac); XMLConfiguration(
final ApplicationContextProvider appCtx,
final String configFileDirectory,
final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final String configFileDirectory); void setTemplate(String template); String getConfigLocation(); Boolean isRuntimeStatsEnabled(); void setRuntimeStatsEnabled(Boolean isEnabled); synchronized ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInfo); @Override void setDefaultValues(TileLayer layer); XStream getConfiguredXStream(XStream xs); static XStream getConfiguredXStream(XStream xs, WebApplicationContext context); XStream getConfiguredXStreamWithContext(
XStream xs, ContextualConfigurationProvider.Context providerContext); static XStream getConfiguredXStreamWithContext(
XStream xs,
WebApplicationContext context,
ContextualConfigurationProvider.Context providerContext); boolean canSave(TileLayer tl); synchronized void addLayer(TileLayer tl); synchronized void modifyLayer(TileLayer tl); void renameLayer(String oldName, String newName); synchronized void removeLayer(final String layerName); void afterPropertiesSet(); String getIdentifier(); void setRelativePath(String relPath); void setAbsolutePath(String absPath); Collection<TileLayer> getLayers(); Optional<TileLayer> getLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayerById(String layerId); boolean containsLayer(String layerId); int getLayerCount(); Set<String> getLayerNames(); String getVersion(); @Override Boolean isFullWMS(); @Override void setFullWMS(Boolean isFullWMS); @Override List<BlobStoreInfo> getBlobStores(); @Override synchronized void addBlobStore(BlobStoreInfo info); @Override synchronized void removeBlobStore(String name); @Override synchronized void modifyBlobStore(BlobStoreInfo info); @Override int getBlobStoreCount(); @Override Set<String> getBlobStoreNames(); @Override Optional<BlobStoreInfo> getBlobStore(String name); @Override boolean canSave(BlobStoreInfo info); @Override void renameBlobStore(String oldName, String newName); @Override boolean containsBlobStore(String name); @Override void addBlobStoreListener(BlobStoreConfigurationListener listener); @Override void removeBlobStoreListener(BlobStoreConfigurationListener listener); @Override LockProvider getLockProvider(); @Override void setLockProvider(LockProvider lockProvider); @Override Boolean isWmtsCiteCompliant(); void setWmtsCiteCompliant(Boolean wmtsCiteStrictCompliant); @Override Integer getBackendTimeout(); @Override void setBackendTimeout(Integer backendTimeout); @Override Boolean isCacheBypassAllowed(); @Override void setCacheBypassAllowed(Boolean cacheBypassAllowed); @Override String getLocation(); @Override synchronized void addGridSet(GridSet gridSet); @Override synchronized void removeGridSet(String gridSetName); @Override Optional<GridSet> getGridSet(String name); @Override Collection<GridSet> getGridSets(); @Override synchronized void modifyGridSet(GridSet gridSet); @Override void renameGridSet(String oldName, String newName); @Override boolean canSave(GridSet gridset); @Autowired @Override void setGridSetBroker(@Qualifier("gwcGridSetBroker") GridSetBroker broker); @Override void deinitialize(); static final String DEFAULT_CONFIGURATION_FILE_NAME; } | @Test public void testModifyLayer() throws Exception { WMSLayer layer1 = createTestLayer("testLayer"); config.addLayer(layer1); int count = config.getLayerCount(); WMSLayer layer2 = createTestLayer("testLayer"); config.modifyLayer(layer2); assertEquals(count, config.getLayerCount()); assertSame(layer2, config.getLayer("testLayer").get()); layer1 = createTestLayer("another"); try { config.modifyLayer(layer1); fail("Expected NoSuchElementException"); } catch (NoSuchElementException e) { assertTrue(true); } } |
XMLConfiguration implements TileLayerConfiguration,
InitializingBean,
DefaultingConfiguration,
ServerConfiguration,
BlobStoreConfiguration,
GridSetConfiguration { public synchronized void removeLayer(final String layerName) throws NoSuchElementException, IllegalArgumentException { final TileLayer tileLayer = findLayer(layerName); if (tileLayer == null) { throw new NoSuchElementException("Layer " + layerName + " does not exist"); } boolean removed = getGwcConfig().getLayers().remove(tileLayer); if (removed) { updateLayers(); } else { throw new NoSuchElementException("Layer " + tileLayer.getName() + " does not exist"); } try { save(); } catch (IOException e) { if (getGwcConfig().getLayers().add(tileLayer)) { updateLayers(); } throw new IllegalArgumentException("Unable to remove layer " + tileLayer, e); } } XMLConfiguration(
final ApplicationContextProvider appCtx, final ConfigurationResourceProvider inFac); XMLConfiguration(
final ApplicationContextProvider appCtx,
final String configFileDirectory,
final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final String configFileDirectory); void setTemplate(String template); String getConfigLocation(); Boolean isRuntimeStatsEnabled(); void setRuntimeStatsEnabled(Boolean isEnabled); synchronized ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInfo); @Override void setDefaultValues(TileLayer layer); XStream getConfiguredXStream(XStream xs); static XStream getConfiguredXStream(XStream xs, WebApplicationContext context); XStream getConfiguredXStreamWithContext(
XStream xs, ContextualConfigurationProvider.Context providerContext); static XStream getConfiguredXStreamWithContext(
XStream xs,
WebApplicationContext context,
ContextualConfigurationProvider.Context providerContext); boolean canSave(TileLayer tl); synchronized void addLayer(TileLayer tl); synchronized void modifyLayer(TileLayer tl); void renameLayer(String oldName, String newName); synchronized void removeLayer(final String layerName); void afterPropertiesSet(); String getIdentifier(); void setRelativePath(String relPath); void setAbsolutePath(String absPath); Collection<TileLayer> getLayers(); Optional<TileLayer> getLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayerById(String layerId); boolean containsLayer(String layerId); int getLayerCount(); Set<String> getLayerNames(); String getVersion(); @Override Boolean isFullWMS(); @Override void setFullWMS(Boolean isFullWMS); @Override List<BlobStoreInfo> getBlobStores(); @Override synchronized void addBlobStore(BlobStoreInfo info); @Override synchronized void removeBlobStore(String name); @Override synchronized void modifyBlobStore(BlobStoreInfo info); @Override int getBlobStoreCount(); @Override Set<String> getBlobStoreNames(); @Override Optional<BlobStoreInfo> getBlobStore(String name); @Override boolean canSave(BlobStoreInfo info); @Override void renameBlobStore(String oldName, String newName); @Override boolean containsBlobStore(String name); @Override void addBlobStoreListener(BlobStoreConfigurationListener listener); @Override void removeBlobStoreListener(BlobStoreConfigurationListener listener); @Override LockProvider getLockProvider(); @Override void setLockProvider(LockProvider lockProvider); @Override Boolean isWmtsCiteCompliant(); void setWmtsCiteCompliant(Boolean wmtsCiteStrictCompliant); @Override Integer getBackendTimeout(); @Override void setBackendTimeout(Integer backendTimeout); @Override Boolean isCacheBypassAllowed(); @Override void setCacheBypassAllowed(Boolean cacheBypassAllowed); @Override String getLocation(); @Override synchronized void addGridSet(GridSet gridSet); @Override synchronized void removeGridSet(String gridSetName); @Override Optional<GridSet> getGridSet(String name); @Override Collection<GridSet> getGridSets(); @Override synchronized void modifyGridSet(GridSet gridSet); @Override void renameGridSet(String oldName, String newName); @Override boolean canSave(GridSet gridset); @Autowired @Override void setGridSetBroker(@Qualifier("gwcGridSetBroker") GridSetBroker broker); @Override void deinitialize(); static final String DEFAULT_CONFIGURATION_FILE_NAME; } | @Test public void testRemoveLayer() { try { config.removeLayer("nonExistent"); fail("Expected exception removing nonExistant layer"); } catch (Exception e) { } Set<String> tileLayerNames = config.getLayerNames(); for (String name : tileLayerNames) { int count = config.getLayerCount(); config.removeLayer(name); assertEquals(count - 1, config.getLayerCount()); } } |
XMLConfiguration implements TileLayerConfiguration,
InitializingBean,
DefaultingConfiguration,
ServerConfiguration,
BlobStoreConfiguration,
GridSetConfiguration { private synchronized void save() throws IOException { if (!resourceProvider.hasOutput()) { return; } try { resourceProvider.backup(); } catch (Exception e) { log.warn("Error creating back up of configuration file " + resourceProvider.getId(), e); } persistToFile(); } XMLConfiguration(
final ApplicationContextProvider appCtx, final ConfigurationResourceProvider inFac); XMLConfiguration(
final ApplicationContextProvider appCtx,
final String configFileDirectory,
final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final String configFileDirectory); void setTemplate(String template); String getConfigLocation(); Boolean isRuntimeStatsEnabled(); void setRuntimeStatsEnabled(Boolean isEnabled); synchronized ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInfo); @Override void setDefaultValues(TileLayer layer); XStream getConfiguredXStream(XStream xs); static XStream getConfiguredXStream(XStream xs, WebApplicationContext context); XStream getConfiguredXStreamWithContext(
XStream xs, ContextualConfigurationProvider.Context providerContext); static XStream getConfiguredXStreamWithContext(
XStream xs,
WebApplicationContext context,
ContextualConfigurationProvider.Context providerContext); boolean canSave(TileLayer tl); synchronized void addLayer(TileLayer tl); synchronized void modifyLayer(TileLayer tl); void renameLayer(String oldName, String newName); synchronized void removeLayer(final String layerName); void afterPropertiesSet(); String getIdentifier(); void setRelativePath(String relPath); void setAbsolutePath(String absPath); Collection<TileLayer> getLayers(); Optional<TileLayer> getLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayerById(String layerId); boolean containsLayer(String layerId); int getLayerCount(); Set<String> getLayerNames(); String getVersion(); @Override Boolean isFullWMS(); @Override void setFullWMS(Boolean isFullWMS); @Override List<BlobStoreInfo> getBlobStores(); @Override synchronized void addBlobStore(BlobStoreInfo info); @Override synchronized void removeBlobStore(String name); @Override synchronized void modifyBlobStore(BlobStoreInfo info); @Override int getBlobStoreCount(); @Override Set<String> getBlobStoreNames(); @Override Optional<BlobStoreInfo> getBlobStore(String name); @Override boolean canSave(BlobStoreInfo info); @Override void renameBlobStore(String oldName, String newName); @Override boolean containsBlobStore(String name); @Override void addBlobStoreListener(BlobStoreConfigurationListener listener); @Override void removeBlobStoreListener(BlobStoreConfigurationListener listener); @Override LockProvider getLockProvider(); @Override void setLockProvider(LockProvider lockProvider); @Override Boolean isWmtsCiteCompliant(); void setWmtsCiteCompliant(Boolean wmtsCiteStrictCompliant); @Override Integer getBackendTimeout(); @Override void setBackendTimeout(Integer backendTimeout); @Override Boolean isCacheBypassAllowed(); @Override void setCacheBypassAllowed(Boolean cacheBypassAllowed); @Override String getLocation(); @Override synchronized void addGridSet(GridSet gridSet); @Override synchronized void removeGridSet(String gridSetName); @Override Optional<GridSet> getGridSet(String name); @Override Collection<GridSet> getGridSets(); @Override synchronized void modifyGridSet(GridSet gridSet); @Override void renameGridSet(String oldName, String newName); @Override boolean canSave(GridSet gridset); @Autowired @Override void setGridSetBroker(@Qualifier("gwcGridSetBroker") GridSetBroker broker); @Override void deinitialize(); static final String DEFAULT_CONFIGURATION_FILE_NAME; } | @Test public void testSave() throws Exception { for (String name : config.getLayerNames()) { int count = config.getLayerCount(); config.removeLayer(name); assertEquals(count - 1, config.getLayerCount()); } String layerName = "testLayer"; String[] wmsURL = {"http: String wmsStyles = "default,line"; String wmsLayers = "states,border"; List<String> mimeFormats = Arrays.asList("image/png", "image/jpeg"); Map<String, GridSubset> subSets = new HashMap<String, GridSubset>(); GridSubset gridSubSet = GridSubsetFactory.createGridSubSet(gridSetBroker.get("EPSG:4326")); subSets.put(gridSubSet.getName(), gridSubSet); StringParameterFilter filter = new StringParameterFilter(); filter.setKey("STYLES"); filter.setValues(Arrays.asList("polygon", "point")); filter.setDefaultValue("polygon"); List<ParameterFilter> parameterFilters = new ArrayList<ParameterFilter>( new ArrayList<ParameterFilter>(Arrays.asList((ParameterFilter) filter))); int[] metaWidthHeight = {9, 9}; String vendorParams = "vendor=1"; boolean queryable = false; String wmsQueryLayers = null; WMSLayer layer = new WMSLayer( layerName, wmsURL, wmsStyles, wmsLayers, mimeFormats, subSets, parameterFilters, metaWidthHeight, vendorParams, queryable, wmsQueryLayers); LegendsRawInfo legendsRawInfo = new LegendsRawInfo(); legendsRawInfo.setDefaultWidth(50); legendsRawInfo.setDefaultHeight(100); legendsRawInfo.setDefaultFormat("image/png"); LegendRawInfo legendRawInfoA = new LegendRawInfo(); legendRawInfoA.setStyle("polygon"); legendRawInfoA.setWidth(75); legendRawInfoA.setHeight(125); legendRawInfoA.setFormat("image/jpeg"); legendRawInfoA.setUrl("http: legendRawInfoA.setMinScale(5000D); legendRawInfoA.setMaxScale(10000D); LegendRawInfo legendRawInfoB = new LegendRawInfo(); legendRawInfoB.setStyle("point"); legendRawInfoB.setCompleteUrl("http: LegendRawInfo legendRawInfoC = new LegendRawInfo(); legendRawInfoC.setStyle(""); legendsRawInfo.addLegendRawInfo(legendRawInfoA); legendsRawInfo.addLegendRawInfo(legendRawInfoB); legendsRawInfo.addLegendRawInfo(legendRawInfoC); layer.setLegends(legendsRawInfo); config.addLayer(layer); try { XMLConfiguration.validate( XMLConfiguration.loadDocument(new FileInputStream(configFile))); } catch (SAXParseException e) { log.error(e.getMessage()); fail(e.getMessage()); } XMLConfiguration config2 = new XMLConfiguration(null, configDir.getAbsolutePath()); config2.setGridSetBroker(gridSetBroker); config2.afterPropertiesSet(); config2.getLayerCount(); assertEquals(1, config2.getLayerCount()); assertThat(config2.getLayer("testLayer"), TestUtils.isPresent()); WMSLayer l = (WMSLayer) config2.getLayer("testLayer").get(); assertTrue(Arrays.equals(wmsURL, l.getWMSurl())); assertEquals(wmsStyles, l.getStyles()); assertEquals(wmsLayers, l.getWmsLayers()); assertEquals(mimeFormats, l.getMimeFormats()); assertEquals(parameterFilters, l.getParameterFilters()); for (GridSubset expected : subSets.values()) { GridSubset actual = l.getGridSubset(expected.getName()); assertNotNull(actual); assertEquals(new XMLGridSubset(expected), new XMLGridSubset(actual)); } assertThat(l.getLegends(), notNullValue()); assertThat(l.getLegends().getDefaultWidth(), is(50)); assertThat(l.getLegends().getDefaultHeight(), is(100)); assertThat(l.getLegends().getDefaultFormat(), is("image/png")); assertThat(l.getLegends().getLegendsRawInfo().size(), is(3)); assertThat( l.getLegends().getLegendsRawInfo(), containsInAnyOrder(legendRawInfoA, legendRawInfoB, legendRawInfoC)); } |
XMLConfiguration implements TileLayerConfiguration,
InitializingBean,
DefaultingConfiguration,
ServerConfiguration,
BlobStoreConfiguration,
GridSetConfiguration { private void saveGridSet(GridSet gridSet) throws IOException { addOrReplaceGridSet(new XMLGridSet(gridSet)); save(); } XMLConfiguration(
final ApplicationContextProvider appCtx, final ConfigurationResourceProvider inFac); XMLConfiguration(
final ApplicationContextProvider appCtx,
final String configFileDirectory,
final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final String configFileDirectory); void setTemplate(String template); String getConfigLocation(); Boolean isRuntimeStatsEnabled(); void setRuntimeStatsEnabled(Boolean isEnabled); synchronized ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInfo); @Override void setDefaultValues(TileLayer layer); XStream getConfiguredXStream(XStream xs); static XStream getConfiguredXStream(XStream xs, WebApplicationContext context); XStream getConfiguredXStreamWithContext(
XStream xs, ContextualConfigurationProvider.Context providerContext); static XStream getConfiguredXStreamWithContext(
XStream xs,
WebApplicationContext context,
ContextualConfigurationProvider.Context providerContext); boolean canSave(TileLayer tl); synchronized void addLayer(TileLayer tl); synchronized void modifyLayer(TileLayer tl); void renameLayer(String oldName, String newName); synchronized void removeLayer(final String layerName); void afterPropertiesSet(); String getIdentifier(); void setRelativePath(String relPath); void setAbsolutePath(String absPath); Collection<TileLayer> getLayers(); Optional<TileLayer> getLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayerById(String layerId); boolean containsLayer(String layerId); int getLayerCount(); Set<String> getLayerNames(); String getVersion(); @Override Boolean isFullWMS(); @Override void setFullWMS(Boolean isFullWMS); @Override List<BlobStoreInfo> getBlobStores(); @Override synchronized void addBlobStore(BlobStoreInfo info); @Override synchronized void removeBlobStore(String name); @Override synchronized void modifyBlobStore(BlobStoreInfo info); @Override int getBlobStoreCount(); @Override Set<String> getBlobStoreNames(); @Override Optional<BlobStoreInfo> getBlobStore(String name); @Override boolean canSave(BlobStoreInfo info); @Override void renameBlobStore(String oldName, String newName); @Override boolean containsBlobStore(String name); @Override void addBlobStoreListener(BlobStoreConfigurationListener listener); @Override void removeBlobStoreListener(BlobStoreConfigurationListener listener); @Override LockProvider getLockProvider(); @Override void setLockProvider(LockProvider lockProvider); @Override Boolean isWmtsCiteCompliant(); void setWmtsCiteCompliant(Boolean wmtsCiteStrictCompliant); @Override Integer getBackendTimeout(); @Override void setBackendTimeout(Integer backendTimeout); @Override Boolean isCacheBypassAllowed(); @Override void setCacheBypassAllowed(Boolean cacheBypassAllowed); @Override String getLocation(); @Override synchronized void addGridSet(GridSet gridSet); @Override synchronized void removeGridSet(String gridSetName); @Override Optional<GridSet> getGridSet(String name); @Override Collection<GridSet> getGridSets(); @Override synchronized void modifyGridSet(GridSet gridSet); @Override void renameGridSet(String oldName, String newName); @Override boolean canSave(GridSet gridset); @Autowired @Override void setGridSetBroker(@Qualifier("gwcGridSetBroker") GridSetBroker broker); @Override void deinitialize(); static final String DEFAULT_CONFIGURATION_FILE_NAME; } | @Test public void testSaveGridSet() throws Exception { String name = "testGrid"; SRS srs = SRS.getEPSG4326(); BoundingBox extent = new BoundingBox(-1, -1, 1, 1); boolean alignTopLeft = true; double[] resolutions = {3, 2, 1}; double[] scaleDenoms = null; Double metersPerUnit = 1.5; double pixelSize = 2 * GridSetFactory.DEFAULT_PIXEL_SIZE_METER; String[] scaleNames = {"uno", "dos", "tres"}; int tileWidth = 128; int tileHeight = 512; boolean yCoordinateFirst = true; GridSet gridSet = GridSetFactory.createGridSet( name, srs, extent, alignTopLeft, resolutions, scaleDenoms, metersPerUnit, pixelSize, scaleNames, tileWidth, tileHeight, yCoordinateFirst); gridSet.setDescription("test description"); config.addGridSet(gridSet); try { XMLConfiguration.validate( XMLConfiguration.loadDocument(new FileInputStream(configFile))); } catch (SAXParseException e) { log.error(e.getMessage()); fail(e.getMessage()); } XMLConfiguration config2 = new XMLConfiguration(null, configDir.getAbsolutePath()); GridSetBroker gridSetBroker2 = new GridSetBroker( Arrays.asList( new DefaultGridsets(true, true), (GridSetConfiguration) config2)); config2.setGridSetBroker(gridSetBroker2); config2.afterPropertiesSet(); config2.getLayerCount(); GridSet gridSet2 = gridSetBroker2.get(name); assertNotNull(gridSet2); assertEquals(gridSet, gridSet2); } |
XMLConfiguration implements TileLayerConfiguration,
InitializingBean,
DefaultingConfiguration,
ServerConfiguration,
BlobStoreConfiguration,
GridSetConfiguration { @Autowired @Override public void setGridSetBroker(@Qualifier("gwcGridSetBroker") GridSetBroker broker) { this.gridSetBroker = broker; } XMLConfiguration(
final ApplicationContextProvider appCtx, final ConfigurationResourceProvider inFac); XMLConfiguration(
final ApplicationContextProvider appCtx,
final String configFileDirectory,
final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final String configFileDirectory); void setTemplate(String template); String getConfigLocation(); Boolean isRuntimeStatsEnabled(); void setRuntimeStatsEnabled(Boolean isEnabled); synchronized ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInfo); @Override void setDefaultValues(TileLayer layer); XStream getConfiguredXStream(XStream xs); static XStream getConfiguredXStream(XStream xs, WebApplicationContext context); XStream getConfiguredXStreamWithContext(
XStream xs, ContextualConfigurationProvider.Context providerContext); static XStream getConfiguredXStreamWithContext(
XStream xs,
WebApplicationContext context,
ContextualConfigurationProvider.Context providerContext); boolean canSave(TileLayer tl); synchronized void addLayer(TileLayer tl); synchronized void modifyLayer(TileLayer tl); void renameLayer(String oldName, String newName); synchronized void removeLayer(final String layerName); void afterPropertiesSet(); String getIdentifier(); void setRelativePath(String relPath); void setAbsolutePath(String absPath); Collection<TileLayer> getLayers(); Optional<TileLayer> getLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayerById(String layerId); boolean containsLayer(String layerId); int getLayerCount(); Set<String> getLayerNames(); String getVersion(); @Override Boolean isFullWMS(); @Override void setFullWMS(Boolean isFullWMS); @Override List<BlobStoreInfo> getBlobStores(); @Override synchronized void addBlobStore(BlobStoreInfo info); @Override synchronized void removeBlobStore(String name); @Override synchronized void modifyBlobStore(BlobStoreInfo info); @Override int getBlobStoreCount(); @Override Set<String> getBlobStoreNames(); @Override Optional<BlobStoreInfo> getBlobStore(String name); @Override boolean canSave(BlobStoreInfo info); @Override void renameBlobStore(String oldName, String newName); @Override boolean containsBlobStore(String name); @Override void addBlobStoreListener(BlobStoreConfigurationListener listener); @Override void removeBlobStoreListener(BlobStoreConfigurationListener listener); @Override LockProvider getLockProvider(); @Override void setLockProvider(LockProvider lockProvider); @Override Boolean isWmtsCiteCompliant(); void setWmtsCiteCompliant(Boolean wmtsCiteStrictCompliant); @Override Integer getBackendTimeout(); @Override void setBackendTimeout(Integer backendTimeout); @Override Boolean isCacheBypassAllowed(); @Override void setCacheBypassAllowed(Boolean cacheBypassAllowed); @Override String getLocation(); @Override synchronized void addGridSet(GridSet gridSet); @Override synchronized void removeGridSet(String gridSetName); @Override Optional<GridSet> getGridSet(String name); @Override Collection<GridSet> getGridSets(); @Override synchronized void modifyGridSet(GridSet gridSet); @Override void renameGridSet(String oldName, String newName); @Override boolean canSave(GridSet gridset); @Autowired @Override void setGridSetBroker(@Qualifier("gwcGridSetBroker") GridSetBroker broker); @Override void deinitialize(); static final String DEFAULT_CONFIGURATION_FILE_NAME; } | @Test public void testOverrideGridSetDefaults() throws Exception { URL source = XMLConfiguration.class.getResource("geowebcache_4326_override.xml"); FileUtils.copyURLToFile(source, configFile); XMLConfiguration config2 = new XMLConfiguration(null, configDir.getAbsolutePath()); final DefaultGridsets defaultGridSets = new DefaultGridsets(true, true); gridSetBroker = new GridSetBroker(Arrays.asList(defaultGridSets)); config2.setGridSetBroker(gridSetBroker); ApplicationContext appContext = createMock(ApplicationContext.class); final HashMap<String, GridSetConfiguration> beans = new HashMap<>(2); beans.put("defaultGridSets", defaultGridSets); beans.put("xmlConfig", config2); expect(appContext.getBeansOfType(GridSetConfiguration.class)).andReturn(beans); expect(appContext.getBean("defaultGridSets")).andReturn(defaultGridSets); expect(appContext.getBean("xmlConfig")).andReturn(config2); replay(appContext); GeoWebCacheExtensions gwcExtensions = new GeoWebCacheExtensions(); gwcExtensions.setApplicationContext(appContext); GridSet override4326 = gridSetBroker.get("EPSG:4326"); assertNotNull(override4326); GridSet worldEpsg4326 = gridSetBroker.getWorldEpsg4326(); assertNotNull(worldEpsg4326); assertEquals(override4326, worldEpsg4326); GridSet internal4326 = defaultGridSets.worldEpsg4326(); assertEquals( "Unexpected number of Default EPSG:4326 resolution levels", 22, internal4326.getNumLevels()); assertEquals( "Unexpected number of Overriden EPSG:4326 resolution levels", 14, override4326.getNumLevels()); final Grid overrideLevel = override4326.getGrid(0); final Grid defaultLevel = internal4326.getGrid(0); assertEquals( "Unexpected default resolution level 0", 0.703125, defaultLevel.getResolution(), 0d); assertEquals( "Unexpected override resolution level 0", 1.40625, overrideLevel.getResolution(), 0d); final String overrideDescription = override4326.getDescription(); final String defaultDescription = internal4326.getDescription(); assertFalse( "Default EPSG:4326 GridSet description should not contain 'OVERRIDE'", defaultDescription.contains("OVERRIDE")); assertTrue( "Overriden EPSG:4326 GridSet description should contain 'OVERRIDE'", overrideDescription.contains("OVERRIDE")); } |
XMLConfiguration implements TileLayerConfiguration,
InitializingBean,
DefaultingConfiguration,
ServerConfiguration,
BlobStoreConfiguration,
GridSetConfiguration { @Override public List<BlobStoreInfo> getBlobStores() { return Collections.unmodifiableList( getGwcConfig() .getBlobStores() .stream() .map( (info) -> { return (BlobStoreInfo) info.clone(); }) .collect(Collectors.toList())); } XMLConfiguration(
final ApplicationContextProvider appCtx, final ConfigurationResourceProvider inFac); XMLConfiguration(
final ApplicationContextProvider appCtx,
final String configFileDirectory,
final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final DefaultStorageFinder storageDirFinder); XMLConfiguration(
final ApplicationContextProvider appCtx, final String configFileDirectory); void setTemplate(String template); String getConfigLocation(); Boolean isRuntimeStatsEnabled(); void setRuntimeStatsEnabled(Boolean isEnabled); synchronized ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInfo); @Override void setDefaultValues(TileLayer layer); XStream getConfiguredXStream(XStream xs); static XStream getConfiguredXStream(XStream xs, WebApplicationContext context); XStream getConfiguredXStreamWithContext(
XStream xs, ContextualConfigurationProvider.Context providerContext); static XStream getConfiguredXStreamWithContext(
XStream xs,
WebApplicationContext context,
ContextualConfigurationProvider.Context providerContext); boolean canSave(TileLayer tl); synchronized void addLayer(TileLayer tl); synchronized void modifyLayer(TileLayer tl); void renameLayer(String oldName, String newName); synchronized void removeLayer(final String layerName); void afterPropertiesSet(); String getIdentifier(); void setRelativePath(String relPath); void setAbsolutePath(String absPath); Collection<TileLayer> getLayers(); Optional<TileLayer> getLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayer(String layerName); @Deprecated @Nullable TileLayer getTileLayerById(String layerId); boolean containsLayer(String layerId); int getLayerCount(); Set<String> getLayerNames(); String getVersion(); @Override Boolean isFullWMS(); @Override void setFullWMS(Boolean isFullWMS); @Override List<BlobStoreInfo> getBlobStores(); @Override synchronized void addBlobStore(BlobStoreInfo info); @Override synchronized void removeBlobStore(String name); @Override synchronized void modifyBlobStore(BlobStoreInfo info); @Override int getBlobStoreCount(); @Override Set<String> getBlobStoreNames(); @Override Optional<BlobStoreInfo> getBlobStore(String name); @Override boolean canSave(BlobStoreInfo info); @Override void renameBlobStore(String oldName, String newName); @Override boolean containsBlobStore(String name); @Override void addBlobStoreListener(BlobStoreConfigurationListener listener); @Override void removeBlobStoreListener(BlobStoreConfigurationListener listener); @Override LockProvider getLockProvider(); @Override void setLockProvider(LockProvider lockProvider); @Override Boolean isWmtsCiteCompliant(); void setWmtsCiteCompliant(Boolean wmtsCiteStrictCompliant); @Override Integer getBackendTimeout(); @Override void setBackendTimeout(Integer backendTimeout); @Override Boolean isCacheBypassAllowed(); @Override void setCacheBypassAllowed(Boolean cacheBypassAllowed); @Override String getLocation(); @Override synchronized void addGridSet(GridSet gridSet); @Override synchronized void removeGridSet(String gridSetName); @Override Optional<GridSet> getGridSet(String name); @Override Collection<GridSet> getGridSets(); @Override synchronized void modifyGridSet(GridSet gridSet); @Override void renameGridSet(String oldName, String newName); @Override boolean canSave(GridSet gridset); @Autowired @Override void setGridSetBroker(@Qualifier("gwcGridSetBroker") GridSetBroker broker); @Override void deinitialize(); static final String DEFAULT_CONFIGURATION_FILE_NAME; } | @Test public void testNoBlobStores() throws Exception { assertNotNull(config.getBlobStores()); assertTrue(config.getBlobStores().isEmpty()); } |
CompositeBlobStore implements BlobStore, BlobStoreConfigurationListener { @Override public boolean get(TileObject obj) throws StorageException { return readFunctionUnsafe(() -> store(obj.getLayerName()).get(obj)); } CompositeBlobStore(
TileLayerDispatcher layers,
DefaultStorageFinder defaultStorageFinder,
ServerConfiguration serverConfiguration,
BlobStoreAggregator blobStoreAggregator); static StoreSuitabilityCheck getStoreSuitabilityCheck(); @Override boolean delete(String layerName); @Override boolean deleteByGridsetId(String layerName, String gridSetId); @Override boolean delete(TileObject obj); @Override boolean delete(TileRange obj); @Override boolean get(TileObject obj); @Override void put(TileObject obj); @Deprecated @Override void clear(); @Override synchronized void destroy(); @Override void addListener(BlobStoreListener listener); @Override boolean removeListener(BlobStoreListener listener); @Override boolean rename(String oldLayerName, String newLayerName); @Override String getLayerMetadata(String layerName, String key); @Override void putLayerMetadata(String layerName, String key, String value); @Override boolean layerExists(String layerName); void setBlobStores(Iterable<? extends BlobStoreInfo> configs); @Override boolean deleteByParametersId(String layerName, String parametersId); @Override Set<Map<String, String>> getParameters(String layerName); @Override Set<String> getParameterIds(String layerName); Map<String, Optional<Map<String, String>>> getParametersMapping(String layerName); @Override void handleAddBlobStore(BlobStoreInfo newBlobStore); @Override void handleRemoveBlobStore(BlobStoreInfo removedBlobStore); @Override void handleModifyBlobStore(BlobStoreInfo modifiedBlobStore); @Override void handleRenameBlobStore(String oldName, BlobStoreInfo modifiedBlobStore); static void checkSuitability(String location, final boolean exists, boolean empty); static final String DEFAULT_STORE_DEFAULT_ID; } | @Test public void noStoresDefinedCreatesLegacyDefaultStore() throws Exception { store = create(); assertEquals(1, store.blobStores.size()); LiveStore liveStore = store.blobStores.get(CompositeBlobStore.DEFAULT_STORE_DEFAULT_ID); assertNotNull(liveStore); assertTrue(liveStore.config instanceof FileBlobStoreInfo); FileBlobStoreInfo config = (FileBlobStoreInfo) liveStore.config; assertTrue(config.isEnabled()); assertTrue(config.isDefault()); assertEquals(tmpFolder.getRoot().getAbsolutePath(), config.getBaseDirectory()); }
@Test public void noExplicitDefaultCreatesLegacyDefaultStore() throws Exception { final boolean isDefault = false; configs.add( config("store1", isDefault, true, tmpFolder.newFolder().getAbsolutePath(), 1024)); configs.add( config("store2", isDefault, true, tmpFolder.newFolder().getAbsolutePath(), 2048)); store = create(); Map<String, LiveStore> stores = store.blobStores; assertEquals(3, stores.size()); LiveStore defaultStore = stores.get(CompositeBlobStore.DEFAULT_STORE_DEFAULT_ID); assertNotNull(defaultStore); assertNotEquals(configs.get(0), defaultStore.config); assertNotEquals(configs.get(1), defaultStore.config); }
@Test public void disabledStoreHasNoLiveInstance() throws Exception { boolean enabled = false; configs.add( config("storeId", false, enabled, tmpFolder.newFolder().getAbsolutePath(), 1024)); store = create(); assertNotNull(store.blobStores.get("storeId")); assertNull(store.blobStores.get("storeId").liveInstance); }
@Test public void configuredDefaultRespectedAndNoLegacyDefaultCreated() throws Exception { configs.add( config( "some-other", false , true, tmpFolder.newFolder().getAbsolutePath(), 1024)); FileBlobStoreInfo defaultStore = config("default-store", true, true, tmpFolder.newFolder().getAbsolutePath(), 1024); configs.add(defaultStore); store = create(); assertSame( defaultStore, store.blobStores.get(CompositeBlobStore.DEFAULT_STORE_DEFAULT_ID).config); assertSame(defaultStore, store.blobStores.get("default-store").config); assertEquals(3, store.blobStores.size()); }
@Test public void getTileInvalidBlobStore() throws Exception { configs.add(config("default", true, true, tmpFolder.newFolder().getAbsolutePath(), 1024)); store = create(); when(defaultLayer.getBlobStoreId()).thenReturn("nonExistentStore"); ex.expect(StorageException.class); ex.expectMessage("No BlobStore with id 'nonExistentStore' found"); store.get(queryTile(0, 0, 0)); }
@Test public void getTileDefaultsToDefaultBlobStore() throws Exception { store = create(); LiveStore liveStore = store.blobStores.get(CompositeBlobStore.DEFAULT_STORE_DEFAULT_ID); liveStore.liveInstance = spy(liveStore.liveInstance); when(defaultLayer.getBlobStoreId()).thenReturn(null); TileObject tile = queryTile(0, 0, 0); store.get(tile); verify(liveStore.liveInstance).get(tile); }
@Test public void getTileInvalidLayer() throws Exception { store = create(); LiveStore liveStore = store.blobStores.get(CompositeBlobStore.DEFAULT_STORE_DEFAULT_ID); liveStore.liveInstance = spy(liveStore.liveInstance); when(defaultLayer.getBlobStoreId()).thenReturn(null); TileObject tile = queryTile("someLayer", DEFAULT_GRIDSET, DEFAULT_FORMAT, 0, 0, 0); ex.expect(StorageException.class); ex.expectMessage("layer not found"); store.get(tile); }
@Test public void getTileDisabledStore() throws Exception { boolean isEnabled = false; configs.add( config("store1", false, isEnabled, tmpFolder.newFolder().getAbsolutePath(), 1024)); store = create(); when(defaultLayer.getBlobStoreId()).thenReturn("store1"); TileObject tile = queryTile(0, 0, 0); ex.expect(StorageException.class); ex.expectMessage("Attempted to use a blob store that's disabled"); store.get(tile); } |
CompositeBlobStore implements BlobStore, BlobStoreConfigurationListener { public static StoreSuitabilityCheck getStoreSuitabilityCheck() { return storeSuitability.get(); } CompositeBlobStore(
TileLayerDispatcher layers,
DefaultStorageFinder defaultStorageFinder,
ServerConfiguration serverConfiguration,
BlobStoreAggregator blobStoreAggregator); static StoreSuitabilityCheck getStoreSuitabilityCheck(); @Override boolean delete(String layerName); @Override boolean deleteByGridsetId(String layerName, String gridSetId); @Override boolean delete(TileObject obj); @Override boolean delete(TileRange obj); @Override boolean get(TileObject obj); @Override void put(TileObject obj); @Deprecated @Override void clear(); @Override synchronized void destroy(); @Override void addListener(BlobStoreListener listener); @Override boolean removeListener(BlobStoreListener listener); @Override boolean rename(String oldLayerName, String newLayerName); @Override String getLayerMetadata(String layerName, String key); @Override void putLayerMetadata(String layerName, String key, String value); @Override boolean layerExists(String layerName); void setBlobStores(Iterable<? extends BlobStoreInfo> configs); @Override boolean deleteByParametersId(String layerName, String parametersId); @Override Set<Map<String, String>> getParameters(String layerName); @Override Set<String> getParameterIds(String layerName); Map<String, Optional<Map<String, String>>> getParametersMapping(String layerName); @Override void handleAddBlobStore(BlobStoreInfo newBlobStore); @Override void handleRemoveBlobStore(BlobStoreInfo removedBlobStore); @Override void handleModifyBlobStore(BlobStoreInfo modifiedBlobStore); @Override void handleRenameBlobStore(String oldName, BlobStoreInfo modifiedBlobStore); static void checkSuitability(String location, final boolean exists, boolean empty); static final String DEFAULT_STORE_DEFAULT_ID; } | @Test public void testSuitabilityOnStartup() throws Exception { assertThat( CompositeBlobStore.getStoreSuitabilityCheck(), equalTo(CompositeBlobStore.StoreSuitabilityCheck.EXISTING)); final BlobStoreInfo info = mock(BlobStoreInfo.class); when(info.getName()).thenReturn("testStore"); when(info.isEnabled()).thenReturn(true); BlobStore subStore = mock(BlobStore.class); when(info.createInstance(Mockito.any(), Mockito.any())) .thenAnswer( invocation -> { assertThat( CompositeBlobStore.getStoreSuitabilityCheck(), equalTo(CompositeBlobStore.StoreSuitabilityCheck.NONE)); return subStore; }); configs.add(info); store = create(); verify(info).createInstance(Mockito.any(), Mockito.any()); assertThat( CompositeBlobStore.getStoreSuitabilityCheck(), equalTo(CompositeBlobStore.StoreSuitabilityCheck.EXISTING)); }
@Test public void testNonDefaultSuitabilityOnStartup() throws Exception { suitability.setValue(CompositeBlobStore.StoreSuitabilityCheck.EMPTY); assertThat( CompositeBlobStore.getStoreSuitabilityCheck(), equalTo(CompositeBlobStore.StoreSuitabilityCheck.EMPTY)); final BlobStoreInfo info = mock(BlobStoreInfo.class); when(info.getName()).thenReturn("testStore"); when(info.isEnabled()).thenReturn(true); BlobStore subStore = mock(BlobStore.class); when(info.createInstance(Mockito.any(), Mockito.any())) .thenAnswer( invocation -> { assertThat( CompositeBlobStore.getStoreSuitabilityCheck(), equalTo(CompositeBlobStore.StoreSuitabilityCheck.NONE)); return subStore; }); configs.add(info); store = create(); verify(info).createInstance(Mockito.any(), Mockito.any()); assertThat( CompositeBlobStore.getStoreSuitabilityCheck(), equalTo(CompositeBlobStore.StoreSuitabilityCheck.EMPTY)); } |
GeoWebCacheExtensions implements ApplicationContextAware, ApplicationListener { @SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD") public void setApplicationContext(ApplicationContext context) throws BeansException { GeoWebCacheExtensions.context = context; extensionsCache.clear(); } @SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD") void setApplicationContext(ApplicationContext context); @SuppressWarnings("unchecked") static final List<T> extensions(
Class<T> extensionPoint, ApplicationContext context); static String[] getBeansNamesOrderedByPriority(Class<T> extensionType); static final List<T> extensions(Class<T> extensionPoint); static List<T> configurations(
Class<T> extensionPoint, ApplicationContext context); static List<T> configurations(Class<T> extensionPoint); static void reinitialize(ApplicationContext context); static final Object bean(String name); static final Object bean(String name, ApplicationContext context); static final T bean(Class<T> type); static final T bean(Class<T> type, ApplicationContext context); void onApplicationEvent(ApplicationEvent event); static String getProperty(String propertyName); static String getProperty(String propertyName, ApplicationContext context); static String getProperty(String propertyName, ServletContext context); } | @Test public void testSetApplicationContext() { ApplicationContext appContext1 = createMock(ApplicationContext.class); ApplicationContext appContext2 = createMock(ApplicationContext.class); GeoWebCacheExtensions gse = new GeoWebCacheExtensions(); gse.setApplicationContext(appContext1); GeoWebCacheExtensions.extensionsCache.put( GeoWebCacheExtensionsTest.class, new String[] {"fake"}); assertSame(appContext1, GeoWebCacheExtensions.context); gse.setApplicationContext(appContext2); assertSame(appContext2, GeoWebCacheExtensions.context); assertEquals(0, GeoWebCacheExtensions.extensionsCache.size()); } |
GeoWebCacheExtensions implements ApplicationContextAware, ApplicationListener { @SuppressWarnings("unchecked") public static final <T> List<T> extensions( Class<T> extensionPoint, ApplicationContext context) { String[] names; if (GeoWebCacheExtensions.context == context) { names = extensionsCache.get(extensionPoint); } else { names = null; } if (names == null) { checkContext(context); if (context != null) { try { names = getBeansNamesOrderedByPriority(extensionPoint, context); if (GeoWebCacheExtensions.context == context) { extensionsCache.put(extensionPoint, names); } } catch (Exception e) { LOGGER.error("bean lookup error", e); return Collections.emptyList(); } } else { return Collections.emptyList(); } } List<T> result = new ArrayList<T>(names.length); for (String name : names) { T bean = (T) context.getBean(name); result.add(bean); } return result; } @SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD") void setApplicationContext(ApplicationContext context); @SuppressWarnings("unchecked") static final List<T> extensions(
Class<T> extensionPoint, ApplicationContext context); static String[] getBeansNamesOrderedByPriority(Class<T> extensionType); static final List<T> extensions(Class<T> extensionPoint); static List<T> configurations(
Class<T> extensionPoint, ApplicationContext context); static List<T> configurations(Class<T> extensionPoint); static void reinitialize(ApplicationContext context); static final Object bean(String name); static final Object bean(String name, ApplicationContext context); static final T bean(Class<T> type); static final T bean(Class<T> type, ApplicationContext context); void onApplicationEvent(ApplicationEvent event); static String getProperty(String propertyName); static String getProperty(String propertyName, ApplicationContext context); static String getProperty(String propertyName, ServletContext context); } | @Test public void testExtensions() { ApplicationContext appContext = createMock(ApplicationContext.class); GeoWebCacheExtensions gse = new GeoWebCacheExtensions(); gse.setApplicationContext(appContext); Map<String, GeoWebCacheExtensionsTest> beans = new HashMap<>(); beans.put("testKey", this); beans.put("fakeKey", null); assertEquals(0, GeoWebCacheExtensions.extensionsCache.size()); expect(appContext.getBeansOfType(GeoWebCacheExtensionsTest.class)).andReturn(beans); expect(appContext.getBean("testKey")).andReturn(this); expect(appContext.getBean("fakeKey")).andReturn(null); replay(appContext); List<GeoWebCacheExtensionsTest> extensions = GeoWebCacheExtensions.extensions(GeoWebCacheExtensionsTest.class); assertNotNull(extensions); assertEquals(2, extensions.size()); assertTrue(extensions.contains(this)); assertTrue(extensions.contains(null)); assertEquals(1, GeoWebCacheExtensions.extensionsCache.size()); assertTrue( GeoWebCacheExtensions.extensionsCache.containsKey(GeoWebCacheExtensionsTest.class)); assertNotNull(GeoWebCacheExtensions.extensionsCache.get(GeoWebCacheExtensionsTest.class)); assertEquals( 2, GeoWebCacheExtensions.extensionsCache.get(GeoWebCacheExtensionsTest.class).length); verify(appContext); } |
GeoWebCacheExtensions implements ApplicationContextAware, ApplicationListener { public static String getProperty(String propertyName) { return getProperty(propertyName, context); } @SuppressFBWarnings("ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD") void setApplicationContext(ApplicationContext context); @SuppressWarnings("unchecked") static final List<T> extensions(
Class<T> extensionPoint, ApplicationContext context); static String[] getBeansNamesOrderedByPriority(Class<T> extensionType); static final List<T> extensions(Class<T> extensionPoint); static List<T> configurations(
Class<T> extensionPoint, ApplicationContext context); static List<T> configurations(Class<T> extensionPoint); static void reinitialize(ApplicationContext context); static final Object bean(String name); static final Object bean(String name, ApplicationContext context); static final T bean(Class<T> type); static final T bean(Class<T> type, ApplicationContext context); void onApplicationEvent(ApplicationEvent event); static String getProperty(String propertyName); static String getProperty(String propertyName, ApplicationContext context); static String getProperty(String propertyName, ServletContext context); } | @Test public void testSystemProperty() { testProperty.setValue("ABC"); assertEquals( "ABC", GeoWebCacheExtensions.getProperty("TEST_PROPERTY", (ApplicationContext) null)); assertEquals( "ABC", GeoWebCacheExtensions.getProperty("TEST_PROPERTY", (ServletContext) null)); }
@Test public void testWebProperty() { testProperty.setValue("ABC"); ServletContext servletContext = createMock(ServletContext.class); expect(servletContext.getInitParameter("TEST_PROPERTY")).andReturn("DEF").anyTimes(); expect(servletContext.getInitParameter("WEB_PROPERTY")).andReturn("WWW").anyTimes(); replay(servletContext); assertEquals("ABC", GeoWebCacheExtensions.getProperty("TEST_PROPERTY", servletContext)); assertEquals("WWW", GeoWebCacheExtensions.getProperty("WEB_PROPERTY", servletContext)); } |
GridSetBroker implements ConfigurationAggregator<GridSetConfiguration>,
ApplicationContextAware,
InitializingBean { public @Nullable GridSet get(String gridSetId) { return getGridSet(gridSetId).orElse(null); } GridSetBroker(); GridSetBroker(List<GridSetConfiguration> configurations); void afterPropertiesSet(); @Nullable GridSet get(String gridSetId); Set<String> getEmbeddedNames(); Set<String> getNames(); Set<String> getGridSetNames(); Collection<GridSet> getGridSets(); synchronized void put(GridSet gridSet); void addGridSet(GridSet gridSet); synchronized GridSet remove(final String gridSetName); synchronized void removeGridSet(final String gridSetName); DefaultGridsets getDefaults(); GridSet getWorldEpsg4326(); GridSet getWorldEpsg3857(); @SuppressWarnings("unchecked") List<? extends GSC> getConfigurations(
Class<GSC> type); @Override void setApplicationContext(ApplicationContext applicationContext); } | @Test public void testGetDefaultGridsetOld() throws IOException { GridSet existingGridSet = gridSetBroker.get(GWCConfigIntegrationTestData.GRIDSET_EPSG4326); assertThat( existingGridSet, hasProperty("name", equalTo(GWCConfigIntegrationTestData.GRIDSET_EPSG4326))); }
@Test public void testGetGridsetOld() throws IOException { GridSet existingGridSet = gridSetBroker.get(GWCConfigIntegrationTestData.GRIDSET_EPSG2163); assertThat( existingGridSet, hasProperty("name", equalTo(GWCConfigIntegrationTestData.GRIDSET_EPSG2163))); }
@Test public void testGetNotPresentGridsetOld() throws IOException { GridSet existingGridSet = gridSetBroker.get("DOESNOTEXIST"); assertThat(existingGridSet, nullValue()); } |
GridSetBroker implements ConfigurationAggregator<GridSetConfiguration>,
ApplicationContextAware,
InitializingBean { protected Optional<GridSet> getGridSet(String name) { for (GridSetConfiguration c : getConfigurations()) { Optional<GridSet> gridSet = c.getGridSet(name); if (gridSet.isPresent()) { GridSet set = gridSet.get(); return Optional.of(set); } } return Optional.empty(); } GridSetBroker(); GridSetBroker(List<GridSetConfiguration> configurations); void afterPropertiesSet(); @Nullable GridSet get(String gridSetId); Set<String> getEmbeddedNames(); Set<String> getNames(); Set<String> getGridSetNames(); Collection<GridSet> getGridSets(); synchronized void put(GridSet gridSet); void addGridSet(GridSet gridSet); synchronized GridSet remove(final String gridSetName); synchronized void removeGridSet(final String gridSetName); DefaultGridsets getDefaults(); GridSet getWorldEpsg4326(); GridSet getWorldEpsg3857(); @SuppressWarnings("unchecked") List<? extends GSC> getConfigurations(
Class<GSC> type); @Override void setApplicationContext(ApplicationContext applicationContext); } | @Test public void testGetDefaultGridSet() throws IOException { Optional<GridSet> existingGridSet = gridSetBroker.getGridSet(GWCConfigIntegrationTestData.GRIDSET_EPSG4326); assertThat( existingGridSet, isPresent( hasProperty( "name", equalTo(GWCConfigIntegrationTestData.GRIDSET_EPSG4326)))); }
@Test public void testGetGridSet() throws IOException { Optional<GridSet> existingGridSet = gridSetBroker.getGridSet(GWCConfigIntegrationTestData.GRIDSET_EPSG2163); assertThat( existingGridSet, isPresent( hasProperty( "name", equalTo(GWCConfigIntegrationTestData.GRIDSET_EPSG2163)))); }
@Test public void testGetNotPresentGridSet() throws IOException { Optional<GridSet> existingGridSet = gridSetBroker.getGridSet("DOESNOTEXIST"); assertThat(existingGridSet, notPresent()); } |
GridSetBroker implements ConfigurationAggregator<GridSetConfiguration>,
ApplicationContextAware,
InitializingBean { public void addGridSet(GridSet gridSet) { log.debug("Adding " + gridSet.getName()); getConfigurations() .stream() .filter(c -> c.canSave(gridSet)) .findFirst() .orElseThrow( () -> new UnsupportedOperationException( "No Configuration is able to save gridset " + gridSet.getName())) .addGridSet(gridSet); } GridSetBroker(); GridSetBroker(List<GridSetConfiguration> configurations); void afterPropertiesSet(); @Nullable GridSet get(String gridSetId); Set<String> getEmbeddedNames(); Set<String> getNames(); Set<String> getGridSetNames(); Collection<GridSet> getGridSets(); synchronized void put(GridSet gridSet); void addGridSet(GridSet gridSet); synchronized GridSet remove(final String gridSetName); synchronized void removeGridSet(final String gridSetName); DefaultGridsets getDefaults(); GridSet getWorldEpsg4326(); GridSet getWorldEpsg3857(); @SuppressWarnings("unchecked") List<? extends GSC> getConfigurations(
Class<GSC> type); @Override void setApplicationContext(ApplicationContext applicationContext); } | @Test public void testAddGridset() throws GeoWebCacheException, IOException { String gridsetName = "EPSG:3005"; GridSet epsg3005 = GridSetFactory.createGridSet( gridsetName, SRS.getSRS(gridsetName), new BoundingBox(35043.6538, 440006.8768, 1885895.3117, 1735643.8497), false, null, new double[] {25000000, 1250000, 500000, 250000}, null, GridSetFactory.DEFAULT_PIXEL_SIZE_METER, null, 256, 256, false); gridSetBroker.addGridSet(epsg3005); assertTrue(gridSetBroker.getNames().contains(gridsetName)); assertEquals(gridSetBroker.get(gridsetName), epsg3005); } |
GridSetBroker implements ConfigurationAggregator<GridSetConfiguration>,
ApplicationContextAware,
InitializingBean { public synchronized void removeGridSet(final String gridSetName) { getConfigurations() .stream() .filter(c -> c.getGridSet(gridSetName).isPresent()) .forEach( c -> { c.removeGridSet(gridSetName); }); } GridSetBroker(); GridSetBroker(List<GridSetConfiguration> configurations); void afterPropertiesSet(); @Nullable GridSet get(String gridSetId); Set<String> getEmbeddedNames(); Set<String> getNames(); Set<String> getGridSetNames(); Collection<GridSet> getGridSets(); synchronized void put(GridSet gridSet); void addGridSet(GridSet gridSet); synchronized GridSet remove(final String gridSetName); synchronized void removeGridSet(final String gridSetName); DefaultGridsets getDefaults(); GridSet getWorldEpsg4326(); GridSet getWorldEpsg3857(); @SuppressWarnings("unchecked") List<? extends GSC> getConfigurations(
Class<GSC> type); @Override void setApplicationContext(ApplicationContext applicationContext); } | @Test public void testRemoveGridset() throws IOException { String gridsetToRemove = GWCConfigIntegrationTestData.GRIDSET_EPSG2163; gridSetBroker.removeGridSet(gridsetToRemove); assertThat(gridSetBroker.getGridSetNames(), not(hasItem(gridsetToRemove))); assertThat(gridSetBroker.getGridSet(gridsetToRemove), notPresent()); } |
GridSubset { public long[][] getCoverageIntersections(BoundingBox reqBounds) { final int zoomStart = getZoomStart(); final int zoomStop = getZoomStop(); long[][] ret = new long[1 + zoomStop - zoomStart][5]; for (int level = zoomStart; level <= zoomStop; level++) { ret[level - zoomStart] = getCoverageIntersection(level, reqBounds); } return ret; } protected GridSubset(
GridSet gridSet,
Map<Integer, GridCoverage> coverages,
BoundingBox originalExtent,
boolean fullCoverage); GridSubset(
GridSet gridSet,
Map<Integer, GridCoverage> coverages,
BoundingBox originalExtent,
boolean fullCoverage,
Integer minCachedZoom,
Integer maxCachedZoom); GridSubset(GridSubset subSet); BoundingBox boundsFromIndex(long[] tileIndex); BoundingBox boundsFromRectangle(long[] rectangleExtent); long[] closestIndex(BoundingBox tileBounds); long[] closestRectangle(BoundingBox rectangleBounds); boolean covers(long[] index); void checkCoverage(long[] index); void checkTileDimensions(int width, int height); long[][] expandToMetaFactors(final long[][] coverages, final int[] metaFactors); long[] getCoverage(int level); long[][] getCoverages(); double getDotsPerInch(); BoundingBox getCoverageBounds(int level); long[] getCoverageBestFit(); BoundingBox getCoverageBestFitBounds(); long[] getCoverageIntersection(long[] reqRectangle); long[][] getCoverageIntersections(BoundingBox reqBounds); long[] getCoverageIntersection(int level, BoundingBox reqBounds); long getGridIndex(String gridId); String[] getGridNames(); GridSet getGridSet(); BoundingBox getGridSetBounds(); long getNumTilesWide(int zoomLevel); long getNumTilesHigh(int zoomLevel); String getName(); BoundingBox getOriginalExtent(); double[] getResolutions(); long[][] getSubGrid(long[] gridLoc); boolean getScaleWarning(); SRS getSRS(); int getTileHeight(); int getTileWidth(); long[][] getWMTSCoverages(); int getZoomStart(); int getZoomStop(); Integer getMinCachedZoom(); Integer getMaxCachedZoom(); boolean fullGridSetCoverage(); boolean shouldCacheAtZoom(long zoom); @Override String toString(); } | @Test public void testCreateTileRange() throws IOException, GeoWebCacheException { WMSLayer tl = createWMSLayer(); String gridSet = tl.getGridSubsets().iterator().next(); GridSubset gridSubSet = tl.getGridSubset(gridSet); BoundingBox bounds = new BoundingBox(0d, 0d, 1d, 1d); long[][] result = gridSubSet.getCoverageIntersections(bounds); assertNotNull(result); } |
GridSet implements Info { public BoundingBox boundsFromIndex(long[] tileIndex) { final int tileZ = (int) tileIndex[2]; Grid grid = getGrid(tileZ); final long tileX = tileIndex[0]; final long tileY; if (yBaseToggle) { tileY = tileIndex[1] - grid.getNumTilesHigh(); } else { tileY = tileIndex[1]; } double width = grid.getResolution() * getTileWidth(); double height = grid.getResolution() * getTileHeight(); final double[] tileOrigin = tileOrigin(); BoundingBox tileBounds = new BoundingBox( tileOrigin[0] + width * tileX, tileOrigin[1] + height * (tileY), tileOrigin[0] + width * (tileX + 1), tileOrigin[1] + height * (tileY + 1)); return tileBounds; } protected GridSet(); GridSet(GridSet g); BoundingBox getOriginalExtent(); boolean isResolutionsPreserved(); BoundingBox boundsFromIndex(long[] tileIndex); long[] closestRectangle(BoundingBox rectangleBounds); @Override boolean equals(Object obj); @Override int hashCode(); BoundingBox getBounds(); double[] getOrderedTopLeftCorner(int gridIndex); String guessMapUnits(); boolean isTopLeftAligned(); int getNumLevels(); Grid getGrid(final int zLevel); void setGrid(final int zLevel, final Grid grid); double[] tileOrigin(); boolean isyCoordinateFirst(); boolean isScaleWarning(); double getMetersPerUnit(); double getPixelSize(); String getName(); String getDescription(); void setDescription(String description); SRS getSrs(); int getTileWidth(); int getTileHeight(); boolean shouldTruncateIfChanged(final GridSet another); @Override String toString(); } | @Test public void testBoundsFromIndex() throws Exception { long[] index = {0, 0, 1}; BoundingBox bboxTL = gridSetTL.boundsFromIndex(index); BoundingBox bboxBL = gridSetBL.boundsFromIndex(index); BoundingBox bboxTLswap = gridSetTLswap.boundsFromIndex(index); BoundingBox bboxBLswap = gridSetBLswap.boundsFromIndex(index); BoundingBox solution = new BoundingBox(-180.0, -90.0, -90.0, 0); assertThat(bboxTL, closeTo(solution, 0.00000001)); assertThat(bboxBL, closeTo(solution, 0.00000001)); assertThat(bboxTLswap, closeTo(solution, 0.00000001)); assertThat(bboxBLswap, closeTo(solution, 0.00000001)); } |
GridSet implements Info { public BoundingBox getBounds() { int i; long tilesWide, tilesHigh; for (i = (getNumLevels() - 1); i > 0; i--) { tilesWide = getGrid(i).getNumTilesWide(); tilesHigh = getGrid(i).getNumTilesHigh(); if (tilesWide == 1 && tilesHigh == 0) { break; } } tilesWide = getGrid(i).getNumTilesWide(); tilesHigh = getGrid(i).getNumTilesHigh(); long[] ret = {0, 0, tilesWide - 1, tilesHigh - 1, i}; return boundsFromRectangle(ret); } protected GridSet(); GridSet(GridSet g); BoundingBox getOriginalExtent(); boolean isResolutionsPreserved(); BoundingBox boundsFromIndex(long[] tileIndex); long[] closestRectangle(BoundingBox rectangleBounds); @Override boolean equals(Object obj); @Override int hashCode(); BoundingBox getBounds(); double[] getOrderedTopLeftCorner(int gridIndex); String guessMapUnits(); boolean isTopLeftAligned(); int getNumLevels(); Grid getGrid(final int zLevel); void setGrid(final int zLevel, final Grid grid); double[] tileOrigin(); boolean isyCoordinateFirst(); boolean isScaleWarning(); double getMetersPerUnit(); double getPixelSize(); String getName(); String getDescription(); void setDescription(String description); SRS getSrs(); int getTileWidth(); int getTileHeight(); boolean shouldTruncateIfChanged(final GridSet another); @Override String toString(); } | @Test public void testBounds() throws Exception { BoundingBox bboxTL = gridSetTL.getBounds(); BoundingBox bboxBL = gridSetBL.getBounds(); BoundingBox bboxTLswap = gridSetTLswap.getBounds(); BoundingBox bboxBLswap = gridSetBLswap.getBounds(); BoundingBox solution = new BoundingBox(-180.0, -90.0, 180, 90); assertThat(bboxTL, closeTo(solution, 0.00000001)); assertThat(bboxBL, closeTo(solution, 0.00000001)); assertThat(bboxTLswap, closeTo(solution, 0.00000001)); assertThat(bboxBLswap, closeTo(solution, 0.00000001)); } |
GridSet implements Info { protected BoundingBox boundsFromRectangle(long[] rectangleExtent) { Grid grid = getGrid((int) rectangleExtent[4]); double width = grid.getResolution() * getTileWidth(); double height = grid.getResolution() * getTileHeight(); long bottomY = rectangleExtent[1]; long topY = rectangleExtent[3]; if (yBaseToggle) { bottomY = bottomY - grid.getNumTilesHigh(); topY = topY - grid.getNumTilesHigh(); } double[] tileOrigin = tileOrigin(); double minx = tileOrigin[0] + width * rectangleExtent[0]; double miny = tileOrigin[1] + height * (bottomY); double maxx = tileOrigin[0] + width * (rectangleExtent[2] + 1); double maxy = tileOrigin[1] + height * (topY + 1); BoundingBox rectangleBounds = new BoundingBox(minx, miny, maxx, maxy); return rectangleBounds; } protected GridSet(); GridSet(GridSet g); BoundingBox getOriginalExtent(); boolean isResolutionsPreserved(); BoundingBox boundsFromIndex(long[] tileIndex); long[] closestRectangle(BoundingBox rectangleBounds); @Override boolean equals(Object obj); @Override int hashCode(); BoundingBox getBounds(); double[] getOrderedTopLeftCorner(int gridIndex); String guessMapUnits(); boolean isTopLeftAligned(); int getNumLevels(); Grid getGrid(final int zLevel); void setGrid(final int zLevel, final Grid grid); double[] tileOrigin(); boolean isyCoordinateFirst(); boolean isScaleWarning(); double getMetersPerUnit(); double getPixelSize(); String getName(); String getDescription(); void setDescription(String description); SRS getSrs(); int getTileWidth(); int getTileHeight(); boolean shouldTruncateIfChanged(final GridSet another); @Override String toString(); } | @Test public void testBoundsFromRectangle() throws Exception { long[] rect = {0, 0, 0, 0, 0}; BoundingBox bboxTL = gridSetTL.boundsFromRectangle(rect); BoundingBox bboxBL = gridSetBL.boundsFromRectangle(rect); BoundingBox bboxTLswap = gridSetTLswap.boundsFromRectangle(rect); BoundingBox bboxBLswap = gridSetBLswap.boundsFromRectangle(rect); BoundingBox solution = new BoundingBox(-180.0, -90.0, 0.0, 90.0); assertThat(bboxTL, equalTo(solution)); assertThat(bboxBL, equalTo(solution)); assertThat(bboxTLswap, equalTo(solution)); assertThat(bboxBLswap, equalTo(solution)); long[] rect2 = {2, 1, 2, 1, 1}; BoundingBox bboxTL2 = gridSetTL.boundsFromRectangle(rect2); BoundingBox bboxBL2 = gridSetBL.boundsFromRectangle(rect2); BoundingBox bboxTLswap2 = gridSetTLswap.boundsFromRectangle(rect2); BoundingBox bboxBLswap2 = gridSetBLswap.boundsFromRectangle(rect2); BoundingBox solution2 = new BoundingBox(0.0, 0.0, 90.0, 90.0); assertThat(bboxTL2, equalTo(solution2)); assertThat(bboxBL2, equalTo(solution2)); assertThat(bboxTLswap2, equalTo(solution2)); assertThat(bboxBLswap2, equalTo(solution2)); } |
GridSet implements Info { protected long[] closestIndex(BoundingBox tileBounds) throws GridMismatchException { double wRes = tileBounds.getWidth() / getTileWidth(); double bestError = Double.MAX_VALUE; int bestLevel = -1; double bestResolution = -1.0; for (int i = 0; i < getNumLevels(); i++) { Grid grid = getGrid(i); double error = Math.abs(wRes - grid.getResolution()); if (error < bestError) { bestError = error; bestResolution = grid.getResolution(); bestLevel = i; } else { break; } } if (Math.abs(wRes - bestResolution) > (0.1 * wRes)) { throw new ResolutionMismatchException(wRes, bestResolution); } return closestIndex(bestLevel, tileBounds); } protected GridSet(); GridSet(GridSet g); BoundingBox getOriginalExtent(); boolean isResolutionsPreserved(); BoundingBox boundsFromIndex(long[] tileIndex); long[] closestRectangle(BoundingBox rectangleBounds); @Override boolean equals(Object obj); @Override int hashCode(); BoundingBox getBounds(); double[] getOrderedTopLeftCorner(int gridIndex); String guessMapUnits(); boolean isTopLeftAligned(); int getNumLevels(); Grid getGrid(final int zLevel); void setGrid(final int zLevel, final Grid grid); double[] tileOrigin(); boolean isyCoordinateFirst(); boolean isScaleWarning(); double getMetersPerUnit(); double getPixelSize(); String getName(); String getDescription(); void setDescription(String description); SRS getSrs(); int getTileWidth(); int getTileHeight(); boolean shouldTruncateIfChanged(final GridSet another); @Override String toString(); } | @Test public void testClosestIndex() throws Exception { BoundingBox box = new BoundingBox(-180.0, -90.0, -90.0, 0); long[] idxTL = gridSetTL.closestIndex(box); long[] idxBL = gridSetBL.closestIndex(box); long[] solution = {0, 0, 1}; assertTrue(Arrays.equals(idxTL, solution)); assertTrue(Arrays.equals(idxBL, solution)); }
@Test public void testClosestIndexInvalidBounds1() throws Exception { BoundingBox box = new BoundingBox(0, -180, 180.0, 0); exception.expect(GridAlignmentMismatchException.class); gridSetTL.closestIndex(box); }
@Test public void testClosestIndexInvalidBounds2() throws Exception { BoundingBox box = new BoundingBox(0, 0, 180.0, 180); exception.expect(GridAlignmentMismatchException.class); gridSetTL.closestIndex(box); } |
GridSet implements Info { public long[] closestRectangle(BoundingBox rectangleBounds) { double rectWidth = rectangleBounds.getWidth(); double rectHeight = rectangleBounds.getHeight(); double bestError = Double.MAX_VALUE; int bestLevel = -1; for (int i = 0; i < getNumLevels(); i++) { Grid grid = getGrid(i); double countX = rectWidth / (grid.getResolution() * getTileWidth()); double countY = rectHeight / (grid.getResolution() * getTileHeight()); double error = Math.abs(countX - Math.round(countX)) + Math.abs(countY - Math.round(countY)); if (error < bestError) { bestError = error; bestLevel = i; } else if (error >= bestError) { break; } } return closestRectangle(bestLevel, rectangleBounds); } protected GridSet(); GridSet(GridSet g); BoundingBox getOriginalExtent(); boolean isResolutionsPreserved(); BoundingBox boundsFromIndex(long[] tileIndex); long[] closestRectangle(BoundingBox rectangleBounds); @Override boolean equals(Object obj); @Override int hashCode(); BoundingBox getBounds(); double[] getOrderedTopLeftCorner(int gridIndex); String guessMapUnits(); boolean isTopLeftAligned(); int getNumLevels(); Grid getGrid(final int zLevel); void setGrid(final int zLevel, final Grid grid); double[] tileOrigin(); boolean isyCoordinateFirst(); boolean isScaleWarning(); double getMetersPerUnit(); double getPixelSize(); String getName(); String getDescription(); void setDescription(String description); SRS getSrs(); int getTileWidth(); int getTileHeight(); boolean shouldTruncateIfChanged(final GridSet another); @Override String toString(); } | @Test public void testClosestRectangle() throws Exception { BoundingBox box = new BoundingBox(-180.0, -90.0, 0.0, 0.0); long[] rectTL = gridSetTL.closestRectangle(box); long[] rectBL = gridSetBL.closestRectangle(box); long[] solution = {0, 0, 1, 0, 1}; assertTrue(Arrays.equals(rectTL, solution)); assertTrue(Arrays.equals(rectBL, solution)); } |
GridSet implements Info { public double[] getOrderedTopLeftCorner(int gridIndex) { double[] leftTop = new double[2]; if (yBaseToggle) { leftTop[0] = tileOrigin()[0]; leftTop[1] = tileOrigin()[1]; } else { Grid grid = getGrid(gridIndex); double dTileHeight = getTileHeight(); double dGridExtent = grid.getNumTilesHigh(); double top = tileOrigin()[1] + dTileHeight * grid.getResolution() * dGridExtent; if (Math.abs(top - Math.round(top)) < (top / 200)) { top = Math.round(top); } leftTop[0] = tileOrigin()[0]; leftTop[1] = top; } if (isyCoordinateFirst()) { double[] ret = {leftTop[1], leftTop[0]}; return ret; } return leftTop; } protected GridSet(); GridSet(GridSet g); BoundingBox getOriginalExtent(); boolean isResolutionsPreserved(); BoundingBox boundsFromIndex(long[] tileIndex); long[] closestRectangle(BoundingBox rectangleBounds); @Override boolean equals(Object obj); @Override int hashCode(); BoundingBox getBounds(); double[] getOrderedTopLeftCorner(int gridIndex); String guessMapUnits(); boolean isTopLeftAligned(); int getNumLevels(); Grid getGrid(final int zLevel); void setGrid(final int zLevel, final Grid grid); double[] tileOrigin(); boolean isyCoordinateFirst(); boolean isScaleWarning(); double getMetersPerUnit(); double getPixelSize(); String getName(); String getDescription(); void setDescription(String description); SRS getSrs(); int getTileWidth(); int getTileHeight(); boolean shouldTruncateIfChanged(final GridSet another); @Override String toString(); } | @Test public void testGetLeftTopCorner() throws Exception { double[] tlTL = gridSetTL.getOrderedTopLeftCorner(1); double[] tlBL = gridSetBL.getOrderedTopLeftCorner(1); assertThat(tlBL[1], Matchers.closeTo(90.0, 0.01)); assertThat(tlTL[1], Matchers.closeTo(90.0, 0.01)); } |
TileLayerDispatcher implements DisposableBean,
InitializingBean,
ApplicationContextAware,
ConfigurationAggregator<TileLayerConfiguration> { public synchronized void addLayer(final TileLayer tl) throws IllegalArgumentException { for (TileLayerConfiguration c : configs) { if (c.canSave(tl)) { c.addLayer(tl); return; } } throw new IllegalArgumentException("No configuration found capable of saving " + tl); } TileLayerDispatcher(GridSetBroker gridSetBroker, List<TileLayerConfiguration> configs); TileLayerDispatcher(GridSetBroker gridSetBroker); boolean layerExists(final String layerName); TileLayer getTileLayer(final String layerName); int getLayerCount(); Set<String> getLayerNames(); @SuppressWarnings("unchecked") Iterable<TileLayer> getLayerList(); ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInformation); void destroy(); synchronized void removeLayer(final String layerName); synchronized void addLayer(final TileLayer tl); synchronized void rename(final String oldName, final String newName); synchronized void modify(final TileLayer tl); TileLayerConfiguration getConfiguration(TileLayer tl); TileLayerConfiguration getConfiguration(final String tileLayerName); synchronized void addGridSet(final GridSet gridSet); synchronized void removeGridSet(String gridsetToRemove); synchronized void removeGridSetRecursive(String gridsetToRemove); @SuppressWarnings("unchecked") @Override List<? extends T> getConfigurations(Class<T> clazz); @Override void afterPropertiesSet(); @Override void setApplicationContext(ApplicationContext applicationContext); void reInit(); } | @Test public void testAddLayer() throws GeoWebCacheException { String layerName = "newLayer"; WMSLayer layer = new WMSLayer( layerName, new String[] {"http: null, null, null, null, null, null, null, false, null); tileLayerDispatcher.addLayer(layer); assertTrue(tileLayerDispatcher.getLayerNames().contains(layerName)); assertEquals(layer, tileLayerDispatcher.getTileLayer(layerName)); } |
TileLayerDispatcher implements DisposableBean,
InitializingBean,
ApplicationContextAware,
ConfigurationAggregator<TileLayerConfiguration> { public synchronized void removeLayer(final String layerName) throws IllegalArgumentException { for (TileLayerConfiguration config : configs) { if (config.containsLayer(layerName)) { config.removeLayer(layerName); return; } } throw new NoSuchElementException("No configuration found containing layer " + layerName); } TileLayerDispatcher(GridSetBroker gridSetBroker, List<TileLayerConfiguration> configs); TileLayerDispatcher(GridSetBroker gridSetBroker); boolean layerExists(final String layerName); TileLayer getTileLayer(final String layerName); int getLayerCount(); Set<String> getLayerNames(); @SuppressWarnings("unchecked") Iterable<TileLayer> getLayerList(); ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInformation); void destroy(); synchronized void removeLayer(final String layerName); synchronized void addLayer(final TileLayer tl); synchronized void rename(final String oldName, final String newName); synchronized void modify(final TileLayer tl); TileLayerConfiguration getConfiguration(TileLayer tl); TileLayerConfiguration getConfiguration(final String tileLayerName); synchronized void addGridSet(final GridSet gridSet); synchronized void removeGridSet(String gridsetToRemove); synchronized void removeGridSetRecursive(String gridsetToRemove); @SuppressWarnings("unchecked") @Override List<? extends T> getConfigurations(Class<T> clazz); @Override void afterPropertiesSet(); @Override void setApplicationContext(ApplicationContext applicationContext); void reInit(); } | @Test public void testRemoveLayer() { String layerToRemove = GWCConfigIntegrationTestData.LAYER_TOPP_STATES; tileLayerDispatcher.removeLayer(layerToRemove); assertFalse(tileLayerDispatcher.getLayerNames().contains(layerToRemove)); try { tileLayerDispatcher.getTileLayer(layerToRemove); fail("Expected exception when trying to get removed layer"); } catch (GeoWebCacheException e) { } }
@Test public void testRemoveLayerException() { try { tileLayerDispatcher.removeLayer(null); fail("Expected failure when trying to remove null layer"); } catch (Exception e) { } try { tileLayerDispatcher.removeLayer("nonexistantLayer"); fail("Expected failure when trying to remove nonexistant layer"); } catch (Exception e) { } } |
TileLayerDispatcher implements DisposableBean,
InitializingBean,
ApplicationContextAware,
ConfigurationAggregator<TileLayerConfiguration> { public synchronized void modify(final TileLayer tl) throws IllegalArgumentException { TileLayerConfiguration config = getConfiguration(tl); config.modifyLayer(tl); } TileLayerDispatcher(GridSetBroker gridSetBroker, List<TileLayerConfiguration> configs); TileLayerDispatcher(GridSetBroker gridSetBroker); boolean layerExists(final String layerName); TileLayer getTileLayer(final String layerName); int getLayerCount(); Set<String> getLayerNames(); @SuppressWarnings("unchecked") Iterable<TileLayer> getLayerList(); ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInformation); void destroy(); synchronized void removeLayer(final String layerName); synchronized void addLayer(final TileLayer tl); synchronized void rename(final String oldName, final String newName); synchronized void modify(final TileLayer tl); TileLayerConfiguration getConfiguration(TileLayer tl); TileLayerConfiguration getConfiguration(final String tileLayerName); synchronized void addGridSet(final GridSet gridSet); synchronized void removeGridSet(String gridsetToRemove); synchronized void removeGridSetRecursive(String gridsetToRemove); @SuppressWarnings("unchecked") @Override List<? extends T> getConfigurations(Class<T> clazz); @Override void afterPropertiesSet(); @Override void setApplicationContext(ApplicationContext applicationContext); void reInit(); } | @Test public void testModifyBadLayer() { String layerName = "newLayer"; WMSLayer layer = new WMSLayer( layerName, new String[] {"http: null, null, null, null, null, null, null, false, null); try { tileLayerDispatcher.modify(layer); fail("Expected exception when modifiying nonexistant layer"); } catch (IllegalArgumentException e) { } try { tileLayerDispatcher.modify(null); fail("Expected exception when modifiying null layer"); } catch (IllegalArgumentException e) { } } |
TileLayerDispatcher implements DisposableBean,
InitializingBean,
ApplicationContextAware,
ConfigurationAggregator<TileLayerConfiguration> { public synchronized void addGridSet(final GridSet gridSet) throws IllegalArgumentException, IOException { if (null != gridSetBroker.get(gridSet.getName())) { throw new IllegalArgumentException("GridSet " + gridSet.getName() + " already exists"); } saveGridSet(gridSet); } TileLayerDispatcher(GridSetBroker gridSetBroker, List<TileLayerConfiguration> configs); TileLayerDispatcher(GridSetBroker gridSetBroker); boolean layerExists(final String layerName); TileLayer getTileLayer(final String layerName); int getLayerCount(); Set<String> getLayerNames(); @SuppressWarnings("unchecked") Iterable<TileLayer> getLayerList(); ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInformation); void destroy(); synchronized void removeLayer(final String layerName); synchronized void addLayer(final TileLayer tl); synchronized void rename(final String oldName, final String newName); synchronized void modify(final TileLayer tl); TileLayerConfiguration getConfiguration(TileLayer tl); TileLayerConfiguration getConfiguration(final String tileLayerName); synchronized void addGridSet(final GridSet gridSet); synchronized void removeGridSet(String gridsetToRemove); synchronized void removeGridSetRecursive(String gridsetToRemove); @SuppressWarnings("unchecked") @Override List<? extends T> getConfigurations(Class<T> clazz); @Override void afterPropertiesSet(); @Override void setApplicationContext(ApplicationContext applicationContext); void reInit(); } | @Test public void testAddGridset() throws GeoWebCacheException, IOException { String gridsetName = "EPSG:3005"; GridSet epsg3005 = GridSetFactory.createGridSet( gridsetName, SRS.getSRS(gridsetName), new BoundingBox(35043.6538, 440006.8768, 1885895.3117, 1735643.8497), false, null, new double[] {25000000, 1250000, 500000, 250000}, null, GridSetFactory.DEFAULT_PIXEL_SIZE_METER, null, 256, 256, false); tileLayerDispatcher.addGridSet(epsg3005); assertTrue(gridSetBroker.getNames().contains(gridsetName)); assertEquals(gridSetBroker.get(gridsetName), epsg3005); }
@Test public void testAddBadGridset() throws IOException { GridSet existingGridSet = gridSetBroker.get(GWCConfigIntegrationTestData.GRIDSET_EPSG2163); try { tileLayerDispatcher.addGridSet(existingGridSet); fail("Expected exception adding existing gridset"); } catch (IllegalArgumentException e) { } try { tileLayerDispatcher.addGridSet(null); fail("Expected exception adding null gridset"); } catch (NullPointerException e) { } } |
TileLayerDispatcher implements DisposableBean,
InitializingBean,
ApplicationContextAware,
ConfigurationAggregator<TileLayerConfiguration> { public synchronized void removeGridSet(String gridsetToRemove) { if (StreamSupport.stream(getLayerList().spliterator(), true) .anyMatch(g -> Objects.nonNull(g.getGridSubset(gridsetToRemove)))) { throw new IllegalStateException( "Can not remove gridset " + gridsetToRemove + " as it is used by layers"); } gridSetBroker.removeGridSet(gridsetToRemove); } TileLayerDispatcher(GridSetBroker gridSetBroker, List<TileLayerConfiguration> configs); TileLayerDispatcher(GridSetBroker gridSetBroker); boolean layerExists(final String layerName); TileLayer getTileLayer(final String layerName); int getLayerCount(); Set<String> getLayerNames(); @SuppressWarnings("unchecked") Iterable<TileLayer> getLayerList(); ServiceInformation getServiceInformation(); void setServiceInformation(ServiceInformation serviceInformation); void destroy(); synchronized void removeLayer(final String layerName); synchronized void addLayer(final TileLayer tl); synchronized void rename(final String oldName, final String newName); synchronized void modify(final TileLayer tl); TileLayerConfiguration getConfiguration(TileLayer tl); TileLayerConfiguration getConfiguration(final String tileLayerName); synchronized void addGridSet(final GridSet gridSet); synchronized void removeGridSet(String gridsetToRemove); synchronized void removeGridSetRecursive(String gridsetToRemove); @SuppressWarnings("unchecked") @Override List<? extends T> getConfigurations(Class<T> clazz); @Override void afterPropertiesSet(); @Override void setApplicationContext(ApplicationContext applicationContext); void reInit(); } | @Test public void testRemoveGridset() throws IOException { String gridsetToRemove = GWCConfigIntegrationTestData.GRIDSET_EPSG2163; tileLayerDispatcher.removeLayer(GWCConfigIntegrationTestData.LAYER_TOPP_STATES); tileLayerDispatcher.removeGridSet(gridsetToRemove); assertFalse(gridSetBroker.getNames().contains(gridsetToRemove)); assertNull(gridSetBroker.get(gridsetToRemove)); }
@Test public void testRemoveGridsetException() throws IOException { String gridsetToRemove = GWCConfigIntegrationTestData.GRIDSET_EPSG2163; try { tileLayerDispatcher.removeGridSet(gridsetToRemove); fail("Expected exception removing a gridset referenced by a layer"); } catch (IllegalStateException e) { } } |
RuntimeStats { public String getHTMLStats() { long runningTime = (clock.millis() - startTime) / 1000; StringBuilder str = new StringBuilder(); str.append("<table border=\"0\" cellspacing=\"5\" class=\"stats\">"); synchronized (bytes) { if (runningTime > 0) { str.append("<tbody>"); str.append("<tr><th colspan=\"2\" scope=\"row\">Started:</th><td colspan=\"3\">"); str.append( ServletUtils.formatTimestamp(this.startTime) + " (" + formatTimeDiff(runningTime) + ") "); str.append("</td></tr>\n"); str.append( "<tr><th colspan=\"2\" scope=\"row\">Total number of requests:</th><td colspan=\"3\">" + totalRequests); str.append(" (" + totalRequests / (runningTime) + "/s ) "); str.append("</td></tr>\n"); str.append( "<tr><th colspan=\"2\" scope=\"row\">Total number of untiled WMS requests:</th><td colspan=\"3\">" + totalWMS); str.append(" (" + totalWMS / (runningTime) + "/s ) "); str.append("</td></tr>\n"); str.append( "<tr><th colspan=\"2\" scope=\"row\">Total number of bytes:</th><td colspan=\"3\">" + totalBytes); str.append(" (" + formatBits((totalBytes * 8.0) / (runningTime)) + ") "); str.append("</td></tr>\n"); str.append("</tbody>"); str.append("<tbody>"); } else { str.append("<tbody>"); str.append( "<tr><th colspan=\"5\">Runtime stats not yet available, try again in a few seconds.</th></tr>"); str.append("<tbody>"); } str.append( "<tr><th colspan=\"2\" scope=\"row\">Cache hit ratio:</th><td colspan=\"3\">"); if (totalHits + totalMisses > 0) { double hitPercentage = (totalHits * 100.0) / (totalHits + totalMisses); int rounded = (int) Math.round(hitPercentage * 100.0); int percents = rounded / 100; int decimals = rounded - percents * 100; str.append(percents + "." + decimals + "% of requests"); } else { str.append("No data"); } str.append("</td></tr>\n"); str.append( "<tr><th colspan=\"2\" scope=\"row\">Blank/KML/HTML:</th><td colspan=\"3\">"); if (totalRequests > 0) { if (totalHits + totalMisses == 0) { str.append("100.0% of requests"); } else { int rounded = (int) Math.round( ((totalRequests - totalHits - totalMisses - totalWMS) * 100.0) / totalRequests); int percents = rounded / 100; int decimals = rounded - percents * 100; str.append(percents + "." + decimals + "% of requests"); } } else { str.append("No data"); } str.append("</td></tr>\n"); str.append("</tbody>"); str.append("<tbody>"); str.append( "<tr><th colspan=\"2\" scope=\"row\">Peak request rate:</th><td colspan=\"3\">"); if (totalRequests > 0) { str.append(formatRequests((peakRequests * 1.0) / pollInterval)); str.append(" (" + ServletUtils.formatTimestamp(peakRequestsTime) + ") "); } else { str.append("No data"); } str.append("</td></tr>\n"); str.append( "<tr><th colspan=\"2\" scope=\"row\">Peak bandwidth:</th><td colspan=\"3\">"); if (totalRequests > 0) { str.append(formatBits((peakBytes * 8.0) / pollInterval)); str.append(" (" + ServletUtils.formatTimestamp(peakRequestsTime) + ") "); } else { str.append("No data"); } str.append("</td></tr>\n"); str.append("</tbody>"); str.append("<tbody>"); str.append( "<tr><th scope=\"col\">Interval</th><th scope=\"col\">Requests</th><th scope=\"col\">Rate</th><th scope=\"col\">Bytes</th><th scope=\"col\">Bandwidth</th></tr>\n"); for (int i = 0; i < intervals.length; i++) { if (runningTime < intervals[i]) { continue; } String[] requests = calculateRequests(intervals[i]); String[] bits = calculateBits(intervals[i]); str.append( "<tr><td>" + intervalDescs[i] + "</td><td>" + requests[0] + "</td><td>" + requests[1] + "</td><td>" + bits[0] + "</td><td>" + bits[1] + "</td><td>" + "</tr>\n"); } str.append("</tbody>"); str.append("<tbody>"); str.append( "<tr><td colspan=\"5\">All figures are " + pollInterval + " second(s) delayed and do not include HTTP overhead</td></tr>"); str.append( "<tr><td colspan=\"5\">The cache hit ratio does not account for metatiling</td></tr>"); str.append("</tbody>"); } return str.toString(); } RuntimeStats(int pollInterval, List<Integer> intervals, List<String> intervalDescs); RuntimeStats(
int pollInterval, List<Integer> intervals, List<String> intervalDescs, Clock clock); void start(); void destroy(); void log(int size, CacheResult cacheResult); String getHTMLStats(); } | @Test public void test() { Clock clock = EasyMock.createMock("Clock", Clock.class); EasyMock.expect(clock.millis()).andStubAnswer(() -> time); EasyMock.replay(clock); time = 0; RuntimeStats stats = new RuntimeStats(1, Arrays.asList(60), Arrays.asList("Minutes"), clock); time += 500; stats.getHTMLStats(); EasyMock.verify(clock); } |
HelloControllerWithRepository { @GetMapping("/hello/data/{name}") public Hello sayHi(@PathVariable String name) { Optional<Person> foundPerson = personRepository.findByFirstName(name); String result = foundPerson .map(person -> String.format("Hello %s", person.getFirstName())) .orElse("Data not found"); return new Hello(result); } @Autowired HelloControllerWithRepository(PersonRepository personRepository); @GetMapping("/hello/data/{name}") Hello sayHi(@PathVariable String name); } | @Test public void shouldReturnHelloSomkiat() { Person somkiat = new Person("somkiat", "pui"); given(personRepository.findByFirstName("somkiat")) .willReturn(Optional.of(somkiat)); Hello hello = controllerWithRepository.sayHi("somkiat"); assertEquals("Hello somkiat", hello.getMessage()); } |
Hello { public String getMessage() { return message; } Hello(String message); String getMessage(); void setMessage(String message); } | @Test public void success_to_create_model_with_constructor() { Hello hello = new Hello("Somkiat"); assertEquals("Somkiat", hello.getMessage()); } |
HelloWithRepositoryController { @GetMapping("/hello/data/{name}") public Hello sayHi(@PathVariable String name) { Optional<Person> person = personRepository.findByFirstName(name); String message = person.map(person1 -> String.format("Hello %s", person1.getFirstName())) .orElse("Data not found"); return new Hello(message); } @Autowired HelloWithRepositoryController(PersonRepository personRepository); @GetMapping("/hello/data/{name}") Hello sayHi(@PathVariable String name); } | @Test public void shouldReturnHelloSomkiat() { Person somkiat = new Person("somkiat", "pui"); given(personRepository.findByFirstName("somkiat")) .willReturn(Optional.of(somkiat)); Hello hello = controller.sayHi("somkiat"); assertEquals("Hello somkiat", hello.getMessage()); } |
Hello { public String getMessage() { return message; } Hello(String message); String getMessage(); } | @Test public void shouldReturnSomkiat() { Hello hello = new Hello("somkiat"); assertEquals("somkiat", hello.getMessage()); } |
Recommendations extends SimpleBenchmark { public Map<Integer, List<Integer>> calculateRecommendations(int reps) { Map<Integer, List<Integer>> results = null; for (int i = 0; i < reps; i++) { results = lambdaRecommendations.calculateRecommendations(); } return results; } void setPurchases(Purchases purchases); Map<Integer, List<Integer>> calculateRecommendations(int reps); MutableMap<Integer, MutableList<Integer>> timeGSRecommendations(int reps); } | @Test public void lambdaVariant() { LambdaRecommendations recommendations = new LambdaRecommendations(makePurchases()); Map<Integer, List<Integer>> results = recommendations.calculateRecommendations(); assertTrue("product 5 is similar to 4", recommendations.alsoBought(4, 1, results).contains(5)); assertTrue("product 4 is similar to 5", recommendations.alsoBought(5, 1, results).contains(4)); }
@Test public void imperativeVariant() { ImperativeRecommendations recommendations = new ImperativeRecommendations(makePurchases()); Map<Integer, List<Integer>> results = recommendations.calculateRecommendations(); List<Integer> similarTo4 = recommendations.alsoBought(4, 1, results); assertTrue("product 5 is similar to 4: " + similarTo4, similarTo4.contains(5)); assertTrue("product 4 is similar to 5", recommendations.alsoBought(5, 1, results).contains(4)); }
@Ignore @Test public void gsVariant() { GSLambdaRecommendations recommendations = new GSLambdaRecommendations(makePurchases()); MutableMap<Integer, MutableList<Integer>> results = recommendations.calculateRecommendations(); Assert.assertEquals(4, results.get(5).get(0).intValue()); Assert.assertEquals(5, results.get(4).get(0).intValue()); } |
BaseController extends Controller { @NonNull @Override protected final View onCreateView(@NonNull LayoutInflater inflater, @NonNull ViewGroup container) { U view = createView(inflater, container); view.setController(getThis()); return view; } BaseController(); BaseController(@Nullable Bundle args); } | @Test public void setView() { DummyView dummyView = (DummyView) dummyController.onCreateView(null, null); Assert.assertEquals(dummyController, dummyView.getController()); } |
LoginPresenter extends BasePresenter<V, I> implements LoginMvpPresenter<V, I> { @Override public void onServerLoginClick(String email, String password) { if (email == null || email.isEmpty()) { getMvpView().onError(R.string.empty_email); return; } if (!CommonUtils.isEmailValid(email)) { getMvpView().onError(R.string.invalid_email); return; } if (password == null || password.isEmpty()) { getMvpView().onError(R.string.empty_password); return; } getMvpView().showLoading(); getCompositeDisposable().add(getInteractor() .doServerLoginApiCall(new LoginRequest.ServerLoginRequest(email, password)) .subscribeOn(getSchedulerProvider().io()) .observeOn(getSchedulerProvider().ui()) .subscribe(new Consumer<LoginResponse>() { @Override public void accept(LoginResponse response) throws Exception { getInteractor().updateUserInfo( response.getAccessToken(), response.getUserId(), AppConstants.LoggedInMode.LOGGED_IN_MODE_SERVER, response.getUserName(), response.getUserEmail(), response.getGoogleProfilePicUrl()); if (!isViewAttached()) { return; } getMvpView().hideLoading(); getMvpView().openMainActivity(); } }, new Consumer<Throwable>() { @Override public void accept(Throwable throwable) throws Exception { if (!isViewAttached()) { return; } getMvpView().hideLoading(); if (throwable instanceof ANError) { ANError anError = (ANError) throwable; handleApiError(anError); } } })); } @Inject LoginPresenter(I mvpInteractor,
SchedulerProvider schedulerProvider,
CompositeDisposable compositeDisposable); @Override void onServerLoginClick(String email, String password); @Override void onGoogleLoginClick(); @Override void onFacebookLoginClick(); } | @Test public void testServerLoginSuccess() { String email = "[email protected]"; String password = "password"; LoginResponse loginResponse = new LoginResponse(); doReturn(Observable.just(loginResponse)) .when(mMockLoginMvpInteractor) .doServerLoginApiCall(new LoginRequest .ServerLoginRequest(email, password)); mLoginPresenter.onServerLoginClick(email, password); mTestScheduler.triggerActions(); verify(mMockLoginMvpView).showLoading(); verify(mMockLoginMvpView).hideLoading(); verify(mMockLoginMvpView).openMainActivity(); } |
TasksRepository implements TasksDataSource { @Override public void getTask(@NonNull final String taskId, @NonNull final GetTaskCallback callback) { checkNotNull(taskId); checkNotNull(callback); Task cachedTask = getTaskWithId(taskId); if (cachedTask != null) { callback.onTaskLoaded(cachedTask); return; } mTasksLocalDataSource.getTask(taskId, new GetTaskCallback() { @Override public void onTaskLoaded(Task task) { if (mCachedTasks == null) { mCachedTasks = new LinkedHashMap<>(); } mCachedTasks.put(task.getId(), task); callback.onTaskLoaded(task); } @Override public void onDataNotAvailable() { mTasksRemoteDataSource.getTask(taskId, new GetTaskCallback() { @Override public void onTaskLoaded(Task task) { if (mCachedTasks == null) { mCachedTasks = new LinkedHashMap<>(); } mCachedTasks.put(task.getId(), task); callback.onTaskLoaded(task); } @Override public void onDataNotAvailable() { callback.onDataNotAvailable(); } }); } }); } @Inject TasksRepository(@Remote TasksDataSource tasksRemoteDataSource,
@Local TasksDataSource tasksLocalDataSource); @Override void getTasks(@NonNull final LoadTasksCallback callback); @Override void saveTask(@NonNull Task task); @Override void completeTask(@NonNull Task task); @Override void completeTask(@NonNull String taskId); @Override void activateTask(@NonNull Task task); @Override void activateTask(@NonNull String taskId); @Override void clearCompletedTasks(); @Override void getTask(@NonNull final String taskId, @NonNull final GetTaskCallback callback); @Override void refreshTasks(); @Override void deleteAllTasks(); @Override void deleteTask(@NonNull String taskId); } | @Test public void getTask_requestsSingleTaskFromLocalDataSource() { mTasksRepository.getTask(TASK_TITLE, mGetTaskCallback); verify(mTasksLocalDataSource).getTask(eq(TASK_TITLE), any( TasksDataSource.GetTaskCallback.class)); }
@Test public void getTaskWithBothDataSourcesUnavailable_firesOnDataUnavailable() { final String taskId = "123"; mTasksRepository.getTask(taskId, mGetTaskCallback); setTaskNotAvailable(mTasksLocalDataSource, taskId); setTaskNotAvailable(mTasksRemoteDataSource, taskId); verify(mGetTaskCallback).onDataNotAvailable(); } |
TasksPresenter implements TasksContract.Presenter { @Override public void addNewTask() { if (mTasksView != null) { mTasksView.showAddTask(); } } @Inject TasksPresenter(TasksRepository tasksRepository); @Override void result(int requestCode, int resultCode); @Override void loadTasks(boolean forceUpdate); @Override void addNewTask(); @Override void openTaskDetails(@NonNull Task requestedTask); @Override void completeTask(@NonNull Task completedTask); @Override void activateTask(@NonNull Task activeTask); @Override void clearCompletedTasks(); @Override TasksFilterType getFiltering(); @Override void setFiltering(TasksFilterType requestType); @Override void takeView(TasksContract.View view); @Override void dropView(); } | @Test public void clickOnFab_ShowsAddTaskUi() { mTasksPresenter.addNewTask(); verify(mTasksView).showAddTask(); } |
TasksPresenter implements TasksContract.Presenter { @Override public void openTaskDetails(@NonNull Task requestedTask) { checkNotNull(requestedTask, "requestedTask cannot be null!"); if (mTasksView != null) { mTasksView.showTaskDetailsUi(requestedTask.getId()); } } @Inject TasksPresenter(TasksRepository tasksRepository); @Override void result(int requestCode, int resultCode); @Override void loadTasks(boolean forceUpdate); @Override void addNewTask(); @Override void openTaskDetails(@NonNull Task requestedTask); @Override void completeTask(@NonNull Task completedTask); @Override void activateTask(@NonNull Task activeTask); @Override void clearCompletedTasks(); @Override TasksFilterType getFiltering(); @Override void setFiltering(TasksFilterType requestType); @Override void takeView(TasksContract.View view); @Override void dropView(); } | @Test public void clickOnTask_ShowsDetailUi() { Task requestedTask = new Task("Details Requested", "For this task"); mTasksPresenter.openTaskDetails(requestedTask); verify(mTasksView).showTaskDetailsUi(any(String.class)); } |
TasksPresenter implements TasksContract.Presenter { @Override public void completeTask(@NonNull Task completedTask) { checkNotNull(completedTask, "completedTask cannot be null!"); mTasksRepository.completeTask(completedTask); if (mTasksView != null) { mTasksView.showTaskMarkedComplete(); } loadTasks(false, false); } @Inject TasksPresenter(TasksRepository tasksRepository); @Override void result(int requestCode, int resultCode); @Override void loadTasks(boolean forceUpdate); @Override void addNewTask(); @Override void openTaskDetails(@NonNull Task requestedTask); @Override void completeTask(@NonNull Task completedTask); @Override void activateTask(@NonNull Task activeTask); @Override void clearCompletedTasks(); @Override TasksFilterType getFiltering(); @Override void setFiltering(TasksFilterType requestType); @Override void takeView(TasksContract.View view); @Override void dropView(); } | @Test public void completeTask_ShowsTaskMarkedComplete() { Task task = new Task("Details Requested", "For this task"); mTasksPresenter.completeTask(task); verify(mTasksRepository).completeTask(task); verify(mTasksView).showTaskMarkedComplete(); } |
TaskDetailPresenter implements TaskDetailContract.Presenter { @Override public void takeView(TaskDetailContract.View taskDetailView) { mTaskDetailView = taskDetailView; openTask(); } @Inject TaskDetailPresenter(@Nullable String taskId,
TasksRepository tasksRepository); @Override void editTask(); @Override void deleteTask(); @Override void completeTask(); @Override void activateTask(); @Override void takeView(TaskDetailContract.View taskDetailView); @Override void dropView(); } | @Test public void getActiveTaskFromRepositoryAndLoadIntoView() { mTaskDetailPresenter = new TaskDetailPresenter( ACTIVE_TASK.getId(), mTasksRepository); mTaskDetailPresenter.takeView(mTaskDetailView); verify(mTasksRepository).getTask(eq(ACTIVE_TASK.getId()), mGetTaskCallbackCaptor.capture()); InOrder inOrder = inOrder(mTaskDetailView); inOrder.verify(mTaskDetailView).setLoadingIndicator(true); mGetTaskCallbackCaptor.getValue().onTaskLoaded(ACTIVE_TASK); inOrder.verify(mTaskDetailView).setLoadingIndicator(false); verify(mTaskDetailView).showTitle(TITLE_TEST); verify(mTaskDetailView).showDescription(DESCRIPTION_TEST); verify(mTaskDetailView).showCompletionStatus(false); }
@Test public void getCompletedTaskFromRepositoryAndLoadIntoView() { mTaskDetailPresenter = new TaskDetailPresenter( COMPLETED_TASK.getId(), mTasksRepository); mTaskDetailPresenter.takeView(mTaskDetailView); verify(mTasksRepository).getTask( eq(COMPLETED_TASK.getId()), mGetTaskCallbackCaptor.capture()); InOrder inOrder = inOrder(mTaskDetailView); inOrder.verify(mTaskDetailView).setLoadingIndicator(true); mGetTaskCallbackCaptor.getValue().onTaskLoaded(COMPLETED_TASK); inOrder.verify(mTaskDetailView).setLoadingIndicator(false); verify(mTaskDetailView).showTitle(TITLE_TEST); verify(mTaskDetailView).showDescription(DESCRIPTION_TEST); verify(mTaskDetailView).showCompletionStatus(true); }
@Test public void getUnknownTaskFromRepositoryAndLoadIntoView() { mTaskDetailPresenter = new TaskDetailPresenter( INVALID_TASK_ID, mTasksRepository); mTaskDetailPresenter.takeView(mTaskDetailView); verify(mTaskDetailView).showMissingTask(); } |
TaskDetailPresenter implements TaskDetailContract.Presenter { @Override public void deleteTask() { if (Strings.isNullOrEmpty(mTaskId)) { if (mTaskDetailView != null) { mTaskDetailView.showMissingTask(); } return; } mTasksRepository.deleteTask(mTaskId); if (mTaskDetailView != null) { mTaskDetailView.showTaskDeleted(); } } @Inject TaskDetailPresenter(@Nullable String taskId,
TasksRepository tasksRepository); @Override void editTask(); @Override void deleteTask(); @Override void completeTask(); @Override void activateTask(); @Override void takeView(TaskDetailContract.View taskDetailView); @Override void dropView(); } | @Test public void deleteTask() { Task task = new Task(TITLE_TEST, DESCRIPTION_TEST); mTaskDetailPresenter = new TaskDetailPresenter( task.getId(), mTasksRepository); mTaskDetailPresenter.takeView(mTaskDetailView); mTaskDetailPresenter.deleteTask(); verify(mTasksRepository).deleteTask(task.getId()); verify(mTaskDetailView).showTaskDeleted(); } |
TaskDetailPresenter implements TaskDetailContract.Presenter { @Override public void completeTask() { if (Strings.isNullOrEmpty(mTaskId)) { if (mTaskDetailView != null) { mTaskDetailView.showMissingTask(); } return; } mTasksRepository.completeTask(mTaskId); if (mTaskDetailView != null) { mTaskDetailView.showTaskMarkedComplete(); } } @Inject TaskDetailPresenter(@Nullable String taskId,
TasksRepository tasksRepository); @Override void editTask(); @Override void deleteTask(); @Override void completeTask(); @Override void activateTask(); @Override void takeView(TaskDetailContract.View taskDetailView); @Override void dropView(); } | @Test public void completeTask() { Task task = new Task(TITLE_TEST, DESCRIPTION_TEST); mTaskDetailPresenter = new TaskDetailPresenter( task.getId(), mTasksRepository); mTaskDetailPresenter.takeView(mTaskDetailView); mTaskDetailPresenter.completeTask(); verify(mTasksRepository).completeTask(task.getId()); verify(mTaskDetailView).showTaskMarkedComplete(); } |
TaskDetailPresenter implements TaskDetailContract.Presenter { @Override public void activateTask() { if (Strings.isNullOrEmpty(mTaskId)) { if (mTaskDetailView != null) { mTaskDetailView.showMissingTask(); } return; } mTasksRepository.activateTask(mTaskId); if (mTaskDetailView != null) { mTaskDetailView.showTaskMarkedActive(); } } @Inject TaskDetailPresenter(@Nullable String taskId,
TasksRepository tasksRepository); @Override void editTask(); @Override void deleteTask(); @Override void completeTask(); @Override void activateTask(); @Override void takeView(TaskDetailContract.View taskDetailView); @Override void dropView(); } | @Test public void activateTask() { Task task = new Task(TITLE_TEST, DESCRIPTION_TEST, true); mTaskDetailPresenter = new TaskDetailPresenter( task.getId(), mTasksRepository); mTaskDetailPresenter.takeView(mTaskDetailView); mTaskDetailPresenter.activateTask(); verify(mTasksRepository).activateTask(task.getId()); verify(mTaskDetailView).showTaskMarkedActive(); } |
TasksRepository implements TasksDataSource { @Override public Flowable<List<Task>> getTasks() { if (mCachedTasks != null && !mCacheIsDirty) { return Flowable.fromIterable(mCachedTasks.values()).toList().toFlowable(); } else if (mCachedTasks == null) { mCachedTasks = new LinkedHashMap<>(); } Flowable<List<Task>> remoteTasks = getAndSaveRemoteTasks(); if (mCacheIsDirty) { return remoteTasks; } else { Flowable<List<Task>> localTasks = getAndCacheLocalTasks(); return Flowable.concat(localTasks, remoteTasks) .filter(tasks -> !tasks.isEmpty()) .firstOrError() .toFlowable(); } } private TasksRepository(@NonNull TasksDataSource tasksRemoteDataSource,
@NonNull TasksDataSource tasksLocalDataSource); static TasksRepository getInstance(@NonNull TasksDataSource tasksRemoteDataSource,
@NonNull TasksDataSource tasksLocalDataSource); static void destroyInstance(); @Override Flowable<List<Task>> getTasks(); @Override void saveTask(@NonNull Task task); @Override void completeTask(@NonNull Task task); @Override void completeTask(@NonNull String taskId); @Override void activateTask(@NonNull Task task); @Override void activateTask(@NonNull String taskId); @Override void clearCompletedTasks(); @Override Flowable<Optional<Task>> getTask(@NonNull final String taskId); @Override void refreshTasks(); @Override void deleteAllTasks(); @Override void deleteTask(@NonNull String taskId); } | @Test public void getTasks_repositoryCachesAfterFirstSubscription_whenTasksAvailableInLocalStorage() { setTasksAvailable(mTasksLocalDataSource, TASKS); setTasksNotAvailable(mTasksRemoteDataSource); TestSubscriber<List<Task>> testSubscriber1 = new TestSubscriber<>(); mTasksRepository.getTasks().subscribe(testSubscriber1); TestSubscriber<List<Task>> testSubscriber2 = new TestSubscriber<>(); mTasksRepository.getTasks().subscribe(testSubscriber2); verify(mTasksRemoteDataSource).getTasks(); verify(mTasksLocalDataSource).getTasks(); assertFalse(mTasksRepository.mCacheIsDirty); testSubscriber1.assertValue(TASKS); testSubscriber2.assertValue(TASKS); }
@Test public void getTasks_repositoryCachesAfterFirstSubscription_whenTasksAvailableInRemoteStorage() { setTasksAvailable(mTasksRemoteDataSource, TASKS); setTasksNotAvailable(mTasksLocalDataSource); TestSubscriber<List<Task>> testSubscriber1 = new TestSubscriber<>(); mTasksRepository.getTasks().subscribe(testSubscriber1); TestSubscriber<List<Task>> testSubscriber2 = new TestSubscriber<>(); mTasksRepository.getTasks().subscribe(testSubscriber2); verify(mTasksRemoteDataSource).getTasks(); verify(mTasksLocalDataSource).getTasks(); assertFalse(mTasksRepository.mCacheIsDirty); testSubscriber1.assertValue(TASKS); testSubscriber2.assertValue(TASKS); }
@Test public void getTasks_requestsAllTasksFromLocalDataSource() { setTasksAvailable(mTasksLocalDataSource, TASKS); setTasksNotAvailable(mTasksRemoteDataSource); mTasksRepository.getTasks().subscribe(mTasksTestSubscriber); verify(mTasksLocalDataSource).getTasks(); mTasksTestSubscriber.assertValue(TASKS); }
@Test public void getTasksWithLocalDataSourceUnavailable_tasksAreRetrievedFromRemote() { setTasksNotAvailable(mTasksLocalDataSource); setTasksAvailable(mTasksRemoteDataSource, TASKS); mTasksRepository.getTasks().subscribe(mTasksTestSubscriber); verify(mTasksRemoteDataSource).getTasks(); mTasksTestSubscriber.assertValue(TASKS); }
@Test public void getTasksWithBothDataSourcesUnavailable_firesOnDataUnavailable() { setTasksNotAvailable(mTasksLocalDataSource); setTasksNotAvailable(mTasksRemoteDataSource); mTasksRepository.getTasks().subscribe(mTasksTestSubscriber); mTasksTestSubscriber.assertNoValues(); mTasksTestSubscriber.assertError(NoSuchElementException.class); } |
TasksRepository implements TasksDataSource { @Override public void saveTask(@NonNull Task task) { checkNotNull(task); mTasksRemoteDataSource.saveTask(task); mTasksLocalDataSource.saveTask(task); if (mCachedTasks == null) { mCachedTasks = new LinkedHashMap<>(); } mCachedTasks.put(task.getId(), task); } private TasksRepository(@NonNull TasksDataSource tasksRemoteDataSource,
@NonNull TasksDataSource tasksLocalDataSource); static TasksRepository getInstance(@NonNull TasksDataSource tasksRemoteDataSource,
@NonNull TasksDataSource tasksLocalDataSource); static void destroyInstance(); @Override Flowable<List<Task>> getTasks(); @Override void saveTask(@NonNull Task task); @Override void completeTask(@NonNull Task task); @Override void completeTask(@NonNull String taskId); @Override void activateTask(@NonNull Task task); @Override void activateTask(@NonNull String taskId); @Override void clearCompletedTasks(); @Override Flowable<Optional<Task>> getTask(@NonNull final String taskId); @Override void refreshTasks(); @Override void deleteAllTasks(); @Override void deleteTask(@NonNull String taskId); } | @Test public void saveTask_savesTaskToServiceAPI() { Task newTask = new Task(TASK_TITLE, "Some Task Description"); mTasksRepository.saveTask(newTask); verify(mTasksRemoteDataSource).saveTask(newTask); verify(mTasksLocalDataSource).saveTask(newTask); assertThat(mTasksRepository.mCachedTasks.size(), is(1)); } |
TasksRepository implements TasksDataSource { @Override public Flowable<Optional<Task>> getTask(@NonNull final String taskId) { checkNotNull(taskId); final Task cachedTask = getTaskWithId(taskId); if (cachedTask != null) { return Flowable.just(Optional.of(cachedTask)); } if (mCachedTasks == null) { mCachedTasks = new LinkedHashMap<>(); } Flowable<Optional<Task>> localTask = getTaskWithIdFromLocalRepository(taskId); Flowable<Optional<Task>> remoteTask = mTasksRemoteDataSource .getTask(taskId) .doOnNext(taskOptional -> { if (taskOptional.isPresent()) { Task task = taskOptional.get(); mTasksLocalDataSource.saveTask(task); mCachedTasks.put(task.getId(), task); } }); return Flowable.concat(localTask, remoteTask) .firstElement() .toFlowable(); } private TasksRepository(@NonNull TasksDataSource tasksRemoteDataSource,
@NonNull TasksDataSource tasksLocalDataSource); static TasksRepository getInstance(@NonNull TasksDataSource tasksRemoteDataSource,
@NonNull TasksDataSource tasksLocalDataSource); static void destroyInstance(); @Override Flowable<List<Task>> getTasks(); @Override void saveTask(@NonNull Task task); @Override void completeTask(@NonNull Task task); @Override void completeTask(@NonNull String taskId); @Override void activateTask(@NonNull Task task); @Override void activateTask(@NonNull String taskId); @Override void clearCompletedTasks(); @Override Flowable<Optional<Task>> getTask(@NonNull final String taskId); @Override void refreshTasks(); @Override void deleteAllTasks(); @Override void deleteTask(@NonNull String taskId); } | @Test public void getTask_requestsSingleTaskFromLocalDataSource() { Task task = new Task(TASK_TITLE, "Some Task Description", true); Optional<Task> taskOptional = Optional.of(task); setTaskAvailable(mTasksLocalDataSource, taskOptional); setTaskNotAvailable(mTasksRemoteDataSource, taskOptional.get().getId()); TestSubscriber<Optional<Task>> testSubscriber = new TestSubscriber<>(); mTasksRepository.getTask(task.getId()).subscribe(testSubscriber); verify(mTasksLocalDataSource).getTask(eq(task.getId())); testSubscriber.assertValue(taskOptional); }
@Test public void getTask_whenDataNotLocal_fails() { Task task = new Task(TASK_TITLE, "Some Task Description", true); Optional<Task> taskOptional = Optional.of(task); setTaskAvailable(mTasksRemoteDataSource, taskOptional); setTaskNotAvailable(mTasksLocalDataSource, task.getId()); TestSubscriber<Optional<Task>> testSubscriber = new TestSubscriber<>(); mTasksRepository.getTask(task.getId()).subscribe(testSubscriber); testSubscriber.assertValue(Optional.absent()); }
@Test public void getTaskWithBothDataSourcesUnavailable_firesOnError() { final String taskId = "123"; setTaskNotAvailable(mTasksLocalDataSource, taskId); setTaskNotAvailable(mTasksRemoteDataSource, taskId); TestSubscriber<Optional<Task>> testSubscriber = new TestSubscriber<>(); mTasksRepository.getTask(taskId).subscribe(testSubscriber); testSubscriber.assertValue(Optional.absent()); } |
AddEditTaskPresenter implements AddEditTaskContract.Presenter { @Override public void populateTask() { if (isNewTask()) { throw new RuntimeException("populateTask() was called but task is new."); } mCompositeDisposable.add(mTasksRepository .getTask(mTaskId) .subscribeOn(mSchedulerProvider.computation()) .observeOn(mSchedulerProvider.ui()) .subscribe( taskOptional -> { if (taskOptional.isPresent()) { Task task = taskOptional.get(); if (mAddTaskView.isActive()) { mAddTaskView.setTitle(task.getTitle()); mAddTaskView.setDescription(task.getDescription()); mIsDataMissing = false; } } else { if (mAddTaskView.isActive()) { mAddTaskView.showEmptyTaskError(); } } }, throwable -> { if (mAddTaskView.isActive()) { mAddTaskView.showEmptyTaskError(); } })); } AddEditTaskPresenter(@Nullable String taskId, @NonNull TasksDataSource tasksRepository,
@NonNull AddEditTaskContract.View addTaskView, boolean shouldLoadDataFromRepo,
@NonNull BaseSchedulerProvider schedulerProvider); @Override void subscribe(); @Override void unsubscribe(); @Override void saveTask(String title, String description); @Override void populateTask(); @Override boolean isDataMissing(); } | @Test public void populateTask_callsRepoAndUpdatesViewOnAbsentTask() { Task testTask = new Task("TITLE", "DESCRIPTION"); when(mTasksRepository.getTask(testTask.getId())).thenReturn(Flowable.just(Optional.absent())); mAddEditTaskPresenter = new AddEditTaskPresenter(testTask.getId(), mTasksRepository, mAddEditTaskView, true, mSchedulerProvider); mAddEditTaskPresenter.populateTask(); verify(mTasksRepository).getTask(eq(testTask.getId())); verify(mAddEditTaskView).showEmptyTaskError(); verify(mAddEditTaskView, never()).setTitle(testTask.getTitle()); verify(mAddEditTaskView, never()).setDescription(testTask.getDescription()); }
@Test public void populateTask_callsRepoAndUpdatesViewOnError() { Task testTask = new Task("TITLE", "DESCRIPTION"); when(mTasksRepository.getTask(testTask.getId())).thenReturn(Flowable.error(new Throwable("Some error"))); mAddEditTaskPresenter = new AddEditTaskPresenter(testTask.getId(), mTasksRepository, mAddEditTaskView, true, mSchedulerProvider); mAddEditTaskPresenter.populateTask(); verify(mTasksRepository).getTask(eq(testTask.getId())); verify(mAddEditTaskView).showEmptyTaskError(); verify(mAddEditTaskView, never()).setTitle(testTask.getTitle()); verify(mAddEditTaskView, never()).setDescription(testTask.getDescription()); } |
ByteArrayDequeue { public void push(byte[] src) { push(src, 0, src.length); } ByteArrayDequeue(); ByteArrayDequeue(int initalCapacity); int getRemaining(); void push(byte[] src); void push(byte[] src, int srcOffset, int srcLengthToPush); void pushLast(byte[] src); void pushLast(byte[] src, int srcOffset, int srcLengthToPush); ByteBuffer popMaximum(int maximumLengthToPop); ByteBuffer popExactly(int lengthToPop); void popExactly(byte[] into); void clear(); } | @Test public void testCombineArrays() { for (int i = 0; i < 200; i++) { push("ABCDEFGH"); push("IJK"); assertEquals("ABCDE", pop(5)); assertEquals("FGHIJK", pop(6)); } } |
ClassUtils { public static String getMethodsList(Class<?> type) { final String SEPARATOR = ","; final List<Method> methods = Arrays.asList(type.getDeclaredMethods()); StringBuilder result = new StringBuilder(); Collections.sort(methods, (o1, o2) -> o1.getName().compareToIgnoreCase(o2.getName())); for (Method method : methods) { int modifiers = method.getModifiers(); if (Modifier.isAbstract(modifiers)) { result.append(method.getName()).append(SEPARATOR); } } return result.deleteCharAt(result.length() - 1).toString(); } static String getMethodsList(Class<?> type); } | @Test public void testGetFieldsReturnsCorrectString_forAutoValueClass() { String detectedAVFields = ClassUtils.getMethodsList(ComicVolumeInfoList.class); String actualFields = "count_of_issues,id,image,name,publisher,start_year"; assertEquals("getMethodsList method returned incorrect list!", actualFields, detectedAVFields); } |
IssueTextUtils { public static String getFormattedIssueName(String issue, String volume, int number) { String name; if (issue != null) { name = String.format(Locale.US, "%s #%d - %s", volume, number, issue); } else { name = String.format(Locale.US, "%s #%d", volume, number); } return name; } static String getFormattedIssueName(String issue, String volume, int number); static String getFormattedIssueTitle(String volume, int number); } | @Test public void testGetFormattedIssueName() { assertEquals("getFormattedIssueName method returned incorrect string!", FORMATTED_NAME_FULL, IssueTextUtils.getFormattedIssueName(ISSUE_NAME, VOLUME_NAME, ISSUE_NUMBER)); assertEquals("getFormattedIssueName method returned incorrect string!", FORMATTED_NAME_SHORT, IssueTextUtils.getFormattedIssueName(null, VOLUME_NAME, ISSUE_NUMBER)); } |
IssueTextUtils { public static String getFormattedIssueTitle(String volume, int number) { return String.format(Locale.US, "%s #%d", volume, number); } static String getFormattedIssueName(String issue, String volume, int number); static String getFormattedIssueTitle(String volume, int number); } | @Test public void testGetFormattedIssueDetailsTitle() { assertEquals("getFormattedIssueTitle method returned incorrect string!", FORMATTED_NAME_SHORT, IssueTextUtils.getFormattedIssueTitle(VOLUME_NAME, ISSUE_NUMBER)); } |
AvroHeadersFunction implements Function<AvroWrapper, List<String>> { List<String> getColumns(List<Schema.Field> fields) { List<String> columns = new ArrayList<>(fields.size()); for (Schema.Field field : fields) { switch (field.schema().getType()) { case RECORD: case MAP: case ARRAY: break; default: columns.add(field.name()); } } return columns; } @Override List<String> call(AvroWrapper avroWrapper); } | @Test public void test() { List<Schema.Field> fields = Arrays.asList( new Schema.Field(Schema.Type.ARRAY.getName(), Schema.createArray(Schema.create(Schema.Type.BOOLEAN)), null, null), new Schema.Field(Schema.Type.RECORD.getName(), Schema.createRecord(Collections.emptyList()), null, null), new Schema.Field(Schema.Type.MAP.getName(), Schema.createMap(Schema.create(Schema.Type.BOOLEAN)), null, null), new Schema.Field(Schema.Type.BOOLEAN.getName(), Schema.create(Schema.Type.BOOLEAN), null, null), new Schema.Field(Schema.Type.STRING.getName(), Schema.create(Schema.Type.STRING), null, null), new Schema.Field(Schema.Type.INT.getName(), Schema.create(Schema.Type.INT), null, null), new Schema.Field(Schema.Type.LONG.getName(), Schema.create(Schema.Type.LONG), null, null), new Schema.Field(Schema.Type.FLOAT.getName(), Schema.create(Schema.Type.FLOAT), null, null), new Schema.Field(Schema.Type.BYTES.getName(), Schema.create(Schema.Type.BYTES), null, null), new Schema.Field(Schema.Type.DOUBLE.getName(), Schema.create(Schema.Type.DOUBLE), null, null), new Schema.Field(Schema.Type.NULL.getName(), Schema.create(Schema.Type.NULL), null, null), new Schema.Field(Schema.Type.FIXED.getName(), Schema.createFixed("fixed", null, "fixed", 1), null, null), new Schema.Field(Schema.Type.ENUM.getName(), Schema.createEnum("enum", null, "namespace", Arrays.asList("Foo", "Bar")), null, null), new Schema.Field(Schema.Type.UNION.getName(), Schema.createUnion(Arrays.asList(Schema.create(Schema.Type.NULL), Schema.create(Schema.Type.STRING))), null, null)); assertEquals(Schema.Type.values().length, fields.size()); List<String> headers = new AvroHeadersFunction().getColumns(fields); assertEquals( Stream.of("boolean", "string", "int", "long", "float", "bytes", "double", "null", "fixed", "enum", "union").sorted().collect(Collectors.toList()), headers.stream().sorted().collect(Collectors.toList())); } |
SparkVerifier { static int getMaximumNumberOfGroups(BoundedDouble approxCountBoundedDouble, int maxGroupSize) { long countApprox = Math.round(approxCountBoundedDouble.mean()); LOGGER.info("Approximate count of expected results: " + countApprox); LOGGER.info("Maximum group size: " + maxGroupSize); long maximumNumberOfGroups = Math.max(1, countApprox / maxGroupSize); if (maximumNumberOfGroups > Integer.MAX_VALUE) { throw new IllegalStateException("Invalid max group size: " + maximumNumberOfGroups); } return (int) maximumNumberOfGroups; } SparkVerifier(List<String> groupKeyColumns); final SparkVerifier withMetadata(String name, String value); SparkVerifier withIgnoreSurplusColumns(boolean ignoreSurplusColumns); SparkVerifier withColumnsToIgnore(Set<String> columnsToIgnore); SparkVerifier withTolerance(double tolerance); SparkVerifier withTolerance(String columnName, double tolerance); SparkVerifier withMaxGroupSize(int maxGroupSize); SparkResult verify(String dataName, Supplier<DistributedTable> actualDataSupplier, Supplier<DistributedTable> expectedDataSupplier); } | @Test public void getMaximumNumberOfGroups() { Assert.assertEquals(1, SparkVerifier.getMaximumNumberOfGroups(new BoundedDouble(100.0, 50.0, 0.0, 200.0), 10_000)); Assert.assertEquals(5, SparkVerifier.getMaximumNumberOfGroups(new BoundedDouble(100.0, 50.0, 0.0, 200.0), 20)); Assert.assertEquals(100, SparkVerifier.getMaximumNumberOfGroups(new BoundedDouble(100.0, 50.0, 0.0, 200.0), 1)); } |
TableVerifier extends TestWatcher { public final TableVerifier withoutPartialMatchTimeout() { return this.withPartialMatchTimeoutMillis(0); } final TableVerifier withExpectedDir(String expectedDirPath); final TableVerifier withExpectedDir(File expectedDir); final TableVerifier withOutputDir(String outputDirPath); final TableVerifier withOutputDir(File outputDir); final TableVerifier withMavenDirectoryStrategy(); final TableVerifier withMavenDirectoryStrategy(String expectedSubDir, String outputSubDir); final TableVerifier withRebase(); final boolean isRebasing(); final TableVerifier withFilePerMethod(); @Deprecated final TableVerifier withFilePerClass(); final TableVerifier withFileStrategy(FilenameStrategy filenameStrategy); final TableVerifier withDirectoryStrategy(DirectoryStrategy directoryStrategy); final TableVerifier withVerifyRowOrder(boolean verifyRowOrder); final TableVerifier withMetadata(String name, String value); final TableVerifier withTolerance(double tolerance); final TableVerifier withTolerance(String columnName, double tolerance); final TableVerifier withVarianceThreshold(double varianceThreshold); final TableVerifier withVarianceThreshold(String columnName, double varianceThreshold); final TableVerifier withHideMatchedRows(boolean hideMatchedRows); final TableVerifier withAlwaysShowMatchedRowsFor(String... tableNames); TableVerifier withHideMatchedColumns(boolean hideMatchedColumns); final TableVerifier withTablesNotToAdapt(String... tableNames); final TableVerifier withHideMatchedTables(boolean hideMatchedTables); final TableVerifier withHtmlRowLimit(int htmlRowLimit); final TableVerifier withCreateActualResults(boolean createActualResults); final TableVerifier withCreateActualResultsOnFailure(boolean createActualResultsOnFailure); final TableVerifier withAssertionSummary(boolean assertionSummary); final TableVerifier withActualAdapter(Function<VerifiableTable, VerifiableTable> actualAdapter); Function<VerifiableTable, VerifiableTable> getActualAdapter(); final TableVerifier withExpectedAdapter(Function<VerifiableTable, VerifiableTable> expectedAdapter); Function<VerifiableTable, VerifiableTable> getExpectedAdapter(); final TableVerifier withIgnoreSurplusRows(); final TableVerifier withIgnoreMissingRows(); TableVerifier withIgnoreSurplusColumns(); TableVerifier withIgnoreMissingColumns(); TableVerifier withIgnoreColumns(String... columnsToIgnore); TableVerifier withColumnFilter(final Predicate<String> columnFilter); TableVerifier withIgnoreTables(String... tableNames); TableVerifier withTableFilter(Predicate<String> tableFilter); final TableVerifier withBaselineHeaders(String... headers); final TableVerifier withExpectedResultsLoader(ExpectedResultsLoader expectedResultsLoader); final TableVerifier withSummarisedResults(boolean summarisedResults); final TableVerifier withPartialMatchTimeoutMillis(long partialMatchTimeoutMillis); final TableVerifier withoutPartialMatchTimeout(); final TableVerifier withLifecycleEventHandler(LifecycleEventHandler lifecycleEventHandler); final TableVerifier withExceptionHandler(ExceptionHandler exceptionHandler); @Override final void starting(Description description); @Override final void succeeded(Description description); @Override final void failed(Throwable e, Description description); @Override final void skipped(AssumptionViolatedException e, Description description); @Override final void finished(Description description); final File getExpectedFile(); final File getOutputFile(); final File getActualFile(); final void verify(String tableName, VerifiableTable actualTable); final void verify(NamedTable... actualTables); final void verify(List<NamedTable> actualTables); @Deprecated final void verify(Map<String, VerifiableTable> actualTables); ExpectedResults getExpectedResults(); final void verify(String name, VerifiableTable expectedTable, VerifiableTable actualTable); final void verify(List<NamedTable> expectedTables, List<NamedTable> actualTables); @Deprecated final void verify(Map<String, VerifiableTable> expectedTables, Map<String, VerifiableTable> actualTables); HtmlFormatter newHtmlFormatter(); SingleTableVerifier newSingleTableVerifier(); void investigate(Investigation investigation); void investigate(Investigation investigation, File outputFile); } | @Test public void withoutPartialMatchTimeout() { this.verifier.starting(this.description.get()); this.verifier.withoutPartialMatchTimeout().verify("table1", TableTestUtils.ACTUAL, TableTestUtils.ACTUAL); this.verifier.succeeded(this.description.get()); } |
TableAdapters { public static VerifiableTable withRows(VerifiableTable delegate, IntPredicate rowFilter) { return new RowFilterAdapter(delegate, rowFilter); } private TableAdapters(); static VerifiableTable withRows(VerifiableTable delegate, IntPredicate rowFilter); static VerifiableTable withColumns(VerifiableTable delegate, Predicate<String> columnFilter); } | @Test public void testAllRows() { this.verify( TableTestUtils.createTable(1, "C", 1, 2, 3, 4, 5), TableAdapters.withRows(TableTestUtils.createTable(1, "C", 1, 2, 3, 4, 5), i -> true)); }
@Test public void testNoRows() { VerifiableTable table = TableTestUtils.createTable(1, "C", 1, 2, 3, 4, 5); this.verify( TableTestUtils.createTable(1, "C"), TableAdapters.withRows(table, i -> false)); }
@Test public void testSomeRows() { VerifiableTable table = TableTestUtils.createTable(1, "C", 1, 2, 3, 4, 5); this.verify( TableTestUtils.createTable(1, "C", 2, 4), TableAdapters.withRows(table, i -> (Integer) table.getValueAt(i, 0) % 2 == 0)); } |
TableAdapters { public static VerifiableTable withColumns(VerifiableTable delegate, Predicate<String> columnFilter) { return new ColumnFilterAdapter(delegate, columnFilter); } private TableAdapters(); static VerifiableTable withRows(VerifiableTable delegate, IntPredicate rowFilter); static VerifiableTable withColumns(VerifiableTable delegate, Predicate<String> columnFilter); } | @Test public void testAllColumns() { this.verify( TableTestUtils.createTable(5, "C1", "C2", "C3", "C4", "C5"), TableAdapters.withColumns(TableTestUtils.createTable(5, "C1", "C2", "C3", "C4", "C5"), name -> true)); }
@Test public void testSomeColumns() { this.verify( TableTestUtils.createTable(3, "C1", "C3", "C5"), TableAdapters.withColumns(TableTestUtils.createTable(5, "C1", "C2", "C3", "C4", "C5"), name -> name.matches("C[135]"))); } |
ExpectedResultsParser { public ExpectedResults parse() { this.results = new ExpectedResults(); try (InputStream inputStream = this.loader.load(this.file)) { BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8)); parse(reader); return this.results; } catch (IOException e) { throw new RuntimeException(e); } catch (ParseException e) { throw new RuntimeException("Parsing error reading '" + this.file + '\'', e); } } ExpectedResultsParser(ExpectedResultsLoader loader, File file); ExpectedResults parse(); } | @Test public void testParse() { File expected = new File(TableTestUtils.getExpectedDirectory(), ExpectedResultsParserTest.class.getSimpleName() + ".txt"); ExpectedResults results = new ExpectedResultsParser(new FileSystemExpectedResultsLoader(), expected).parse(); VerifiableTable summary = results.getTable("Summary"); Assert.assertEquals(6, summary.getColumnCount()); Assert.assertEquals(5, summary.getRowCount()); VerifiableTable drillDown = results.getTable("DrillDown"); Assert.assertEquals(6, drillDown.getColumnCount()); Assert.assertEquals(1, drillDown.getRowCount()); Assert.assertEquals(2, results.getMetadata().getData().size()); Assert.assertEquals(Collections.singletonMap("Recorded At", "2013-06-26 12:00:00").entrySet().iterator().next(), results.getMetadata().getData().get(0)); Assert.assertEquals(Collections.singletonMap("App Server URL", "http: }
@Test public void testMissingExpectedResultsFileResultsInClearErrorMessage() { String missingFileName = "missing-expected-results.txt"; try { new ExpectedResultsParser(new FileSystemExpectedResultsLoader(), new File(missingFileName)).parse(); Assert.fail("Should have failed looking for non-existent file"); } catch (IllegalStateException expected) { Assert.assertTrue(expected.getMessage().contains(missingFileName)); } } |
ExpectedResultsParser { ExpectedResults getExpectedResults() { return this.results; } ExpectedResultsParser(ExpectedResultsLoader loader, File file); ExpectedResults parse(); } | @Test public void testCache() { File expected = new File(TableTestUtils.getExpectedDirectory(), ExpectedResultsParserTest.class.getSimpleName() + ".txt"); Map<ExpectedResults, String> results = new IdentityHashMap<>(); for (int i = 0; i < 10; i++) { results.put(ExpectedResultsCache.getExpectedResults(new FileSystemExpectedResultsLoader(), expected), ""); } Assert.assertTrue("cache was hit at least once", results.size() < 10); } |
SparkVerifier { public SparkVerifier withMaxGroupSize(int maxGroupSize) { this.maxGroupSize = maxGroupSize; return this; } SparkVerifier(List<String> groupKeyColumns); final SparkVerifier withMetadata(String name, String value); SparkVerifier withIgnoreSurplusColumns(boolean ignoreSurplusColumns); SparkVerifier withColumnsToIgnore(Set<String> columnsToIgnore); SparkVerifier withTolerance(double tolerance); SparkVerifier withTolerance(String columnName, double tolerance); SparkVerifier withMaxGroupSize(int maxGroupSize); SparkResult verify(String dataName, Supplier<DistributedTable> actualDataSupplier, Supplier<DistributedTable> expectedDataSupplier); } | @Test public void runTestFail() throws IOException { runTest(AVRO, AVRO_X, false, newSparkVerifier(Arrays.asList("k2", "k1")) .withMaxGroupSize(2)); }
@Test public void runTestPass() throws IOException { runTest(AVRO, AVRO, true, newSparkVerifier(Collections.emptyList()) .withMaxGroupSize(2)); }
@Test public void runTestWithSingleShardColumn() throws IOException { runTest(AVRO, AVRO_X, false, newSparkVerifier(Collections.singletonList("k2")) .withMaxGroupSize(2)); }
@Test(expected = IllegalArgumentException.class) public void runTestWithInvalidShardColumn() throws IOException { runTest(AVRO, AVRO_X, false, newSparkVerifier(Collections.singletonList("foo")) .withMaxGroupSize(2)); }
@Test public void runManyRowTest() throws IOException { List<GenericRecord> data = new ArrayList<>(); for (Integer i = 1230001; i <= 1230100; i++) { data.add(row(AVSC, i, i.toString(), i, i * 1.0)); } runTest(data, data, true, newSparkVerifier(Collections.singletonList("k1")) .withMaxGroupSize(10_000)); }
@Test public void runManyRowTestWithMissingColumn() throws IOException { List<GenericRecord> actual = new ArrayList<>(); for (Integer i = 1230001; i <= 1230100; i++) { actual.add(row(AVSC_MISSING_COL, i, i.toString(), i)); } List<GenericRecord> expected = new ArrayList<>(); for (Integer i = 1230001; i <= 1230100; i++) { expected.add(row(AVSC, i, i.toString(), i, i * 1.0)); } runTest(actual, expected, false, newSparkVerifier(Collections.singletonList("k1")) .withMaxGroupSize(10_000)); }
@Test public void runManyRowTestWithManyBreaks() throws IOException { List<GenericRecord> actual = new ArrayList<>(); for (Integer i = 1230001; i <= 1230100; i++) { actual.add(row(AVSC, (i&8) == 0 ? i : i + 1, (i&4) == 0 ? String.valueOf(i) : String.valueOf(i + 1), (i&2) == 0 ? i : i + 1, (i&1) == 0 ? i * 1.0 : i * 1.0 + 1)); } List<GenericRecord> expected = new ArrayList<>(); for (Integer i = 1230001; i <= 1230100; i++) { expected.add(row(AVSC, i, i.toString(), i, i * 1.0)); } runTest(actual, expected, false, newSparkVerifier(Collections.emptyList()) .withMaxGroupSize(10_000)); }
@Test public void runManyRowTestWithManyBreaksAndRenamedColumn() throws IOException { List<GenericRecord> actual = new ArrayList<>(); Schema schema = new Schema.Parser().parse("{\"namespace\": \"verify.avro\",\n" + " \"type\": \"record\",\n" + " \"name\": \"Row\",\n" + " \"fields\": [\n" + " {\"name\": \"k1\", \"type\": \"int\"},\n" + " {\"name\": \"v1\", \"type\": \"string\"},\n" + " {\"name\": \"k2\", \"type\": \"int\"},\n" + " {\"name\": \"v3\", \"type\": \"double\"}\n" + " ]\n" + '}'); for (Integer i = 1230001; i <= 1230100; i++) { GenericRecord record = row( schema, (i & 4) == 0 ? i : i + 1, (i & 2) == 0 ? String.valueOf(i) : String.valueOf(i + 1), (i & 1) == 0 ? i : i + 1, i * 1.0); actual.add(record); } List<GenericRecord> expected = new ArrayList<>(); for (Integer i = 1230001; i <= 1230100; i++) { expected.add(row(AVSC, i, i.toString(), i, i * 1.0)); } runTest(actual, expected, false, newSparkVerifier(Collections.emptyList()) .withMaxGroupSize(10_000)); } |
CellComparator implements Serializable { protected abstract boolean compare(Object actual, Object expected); CellComparator(CellFormatter formatter); CellFormatter getFormatter(); static boolean isFloatingPoint(Object object); boolean equals(Object actual, Object expected); int computeHashCode(Object object); } | @Test public void testCompareToleranceStringInputsFail() { Assert.assertFalse(this.varianceCellComparator.compare("ActualAndExpected", "ActualAndExpected")); Assert.assertFalse(this.varianceCellComparator.compare("Actual", "Expected")); }
@Test public void testCompareNumbersWithinTolerance() { Assert.assertTrue("Results match expected. Actual(20.0) and Expected(20.09) within Tolerance range(0.1).",this.toleranceCellComparator.compare(new Double(20.0), new Double(20.09))); Assert.assertTrue("Results match expected. Actual(7894.87) and Expected(7894.79) within Tolerance range(0.1).",this.toleranceCellComparator.compare(new Float(7894.87), new Float(7894.79))); }
@Test public void testCompareNumbersOutsideTolerance() { Assert.assertFalse("Results mismatch expected. Actual(20.0) and Expected(20.11) outside Tolerance range(0.1). ", this.toleranceCellComparator.compare(new Double(20.0), new Double(20.11))); Assert.assertFalse("Results mismatch expected. Actual(7894.87) and Expected(7894.75) outside Tolerance range(0.1). ", this.toleranceCellComparator.compare(new Float(7894.87), new Float(7894.75))); }
@Test public void testCompareVarianceStringInputsFail() { Assert.assertFalse(this.varianceCellComparator.compare("ActualAndExpected", "ActualAndExpected")); Assert.assertFalse(this.varianceCellComparator.compare("Actual", "Expected")); }
@Test public void testCompareNumbersWithinVariance() { Assert.assertTrue("Results match expected. Actual(2000.0) and Expected(2100.0) within Variance range(5%).", this.varianceCellComparator.compare(new Double(2000.0), new Double(2100.0))); Assert.assertTrue("Results match expected. Actual(735.0) and Expected(772.0) within Variance range(5%).", this.varianceCellComparator.compare(new Float(735.0), new Float(772.0))); }
@Test public void testCompareNumbersOutsideVariance() { Assert.assertFalse("Results mismatch expected. Actual(2000.0) and Expected(2110.0) outside Variance range(5%).", this.varianceCellComparator.compare(new Double(2000.0), new Double(2110))); Assert.assertFalse("Results mismatch expected. Actual(735.0) and Expected(775.0) outside Variance range(5%).", this.varianceCellComparator.compare(new Float(735.0), new Float(775.0))); Assert.assertFalse("Results mismatch expected. Actual(5600.0) and Expected(NaN) outside Variance range(5%).", this.varianceCellComparator.compare(new Double(5600.0), Double.NaN)); Assert.assertFalse("Results mismatch expected. Actual(NaN) and Expected(88.0) outside Variance range(5%).", this.varianceCellComparator.compare(Double.NaN,new Double(88.0) )); }
@Test public void testActualExpectedMismatchedTypes() { Assert.assertFalse("Results mismatch expected. Actual(390.0) and Expected(expected) outside Variance range(5%).", this.varianceCellComparator.compare(new Double(390.0),"expected")); Assert.assertFalse("Results mismatch expected. Actual(actual) and Expected(1045.0) outside Variance range(5%).", this.varianceCellComparator.compare("actual", new Double(1045.0))); } |
ResultSetTable { public static VerifiableTable create(ResultSet resultSet) throws SQLException { ResultSetMetaData metaData = resultSet.getMetaData(); int columnCount = metaData.getColumnCount(); List<String> headers = new ArrayList<>(columnCount); for (int n = 1; n <= columnCount; n++) { headers.add(metaData.getColumnName(n)); } List<List> rows = new ArrayList<>(); while (resultSet.next()) { List<Object> row = new ArrayList<>(columnCount); for (int n = 1; n <= columnCount; n++) { row.add(resultSet.getObject(n)); } rows.add(row); } return ListVerifiableTable.create(headers, rows); } private ResultSetTable(); static VerifiableTable create(ResultSet resultSet); } | @Test public void create() throws SQLException { SimpleResultSet resultSet = new SimpleResultSet(); resultSet.addColumn("Name", Types.VARCHAR, 0, 0); resultSet.addColumn("Age", Types.INTEGER, 0, 0); resultSet.addColumn("Height", Types.DOUBLE, 0, 0); resultSet.addColumn("DoB", Types.DATE, 0, 0); resultSet.addRow("Joe", 70, 6.0, Date.valueOf("1940-02-16")); resultSet.addRow("Sue", 45, 5.8, Date.valueOf("1975-02-16")); VerifiableTable expected = new TestTable("Name", "Age", "Height", "DoB") .withRow("Joe", 70, 6.0, Date.valueOf("1940-02-16")) .withRow("Sue", 45, 5.8, Date.valueOf("1975-02-16")); VerifiableTable actual = ResultSetTable.create(resultSet); this.tableVerifier.verify( Collections.singletonList(new NamedTable("table", expected)), Collections.singletonList(new NamedTable("table", actual))); } |
ListVerifiableTable implements VerifiableTable { @Override public int getRowCount() { return this.data.size(); } ListVerifiableTable(List<List<Object>> headersAndData); ListVerifiableTable(List<?> headers, List<List<Object>> data); static VerifiableTable create(Iterable<List> headersAndRows); static VerifiableTable create(List<String> headers, Iterable<List> rows); @Override int getRowCount(); @Override int getColumnCount(); @Override String getColumnName(int columnIndex); @Override Object getValueAt(int rowIndex, int columnIndex); } | @Test public void testHeaderTypes() throws Exception { List<Object> headersAsObjects = Collections.singletonList("Col"); List<List<Object>> headersAndDataAsObjects = Arrays.asList(headersAsObjects, Collections.<Object>singletonList("Val")); Assert.assertEquals("Test constructor with headers and rows in one List<List<Object>>", 1, new ListVerifiableTable(headersAndDataAsObjects).getRowCount()); Assert.assertEquals("Test constructor with headers as List<Object>", 2, new ListVerifiableTable(headersAsObjects, headersAndDataAsObjects).getRowCount()); List<String> headersAsStrings = Collections.singletonList("Col"); Assert.assertEquals("Test cast that used to be necessary for headers as List<String>", 2, new ListVerifiableTable((List) headersAsStrings, headersAndDataAsObjects).getRowCount()); Assert.assertEquals("Test headers as List<String> can now be passed in as-is", 2, new ListVerifiableTable(headersAsStrings, headersAndDataAsObjects).getRowCount()); } |
ListVerifiableTable implements VerifiableTable { public static VerifiableTable create(Iterable<List> headersAndRows) { Iterator<List> iterator = headersAndRows.iterator(); List headers = iterator.next(); headers.forEach(ListVerifiableTable::verifyHeader); List rowList = new ArrayList(); iterator.forEachRemaining(verifyRowSize(headers).andThen(rowList::add)); return new ListVerifiableTable(headers, rowList); } ListVerifiableTable(List<List<Object>> headersAndData); ListVerifiableTable(List<?> headers, List<List<Object>> data); static VerifiableTable create(Iterable<List> headersAndRows); static VerifiableTable create(List<String> headers, Iterable<List> rows); @Override int getRowCount(); @Override int getColumnCount(); @Override String getColumnName(int columnIndex); @Override Object getValueAt(int rowIndex, int columnIndex); } | @Test(expected = IllegalArgumentException.class) public void createList_headersNotStrings() { ListVerifiableTable.create(Arrays.asList(Arrays.asList('A', 'B'), Arrays.asList(1, 2))); }
@Test(expected = IllegalArgumentException.class) public void createList_wrongRowSize() { ListVerifiableTable.create(Arrays.asList(Arrays.asList("A", "B"), Arrays.asList(1, 2), Collections.singletonList(3))); }
@Test(expected = IllegalArgumentException.class) public void createHeadersAndList_wrongRowSize() { ListVerifiableTable.create(Arrays.asList("A", "B"), Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4, 5))); }
@Test(expected = IllegalArgumentException.class) public void createHeadersAndIterable_wrongRowSize() { ListVerifiableTable.create(Arrays.asList("A", "B"), new LinkedHashSet<>(Arrays.asList(Arrays.asList(1, 2), Arrays.asList(3, 4, 5)))); } |
CellFormatter implements Function<Object, String>, Serializable { public String format(Object value) { if (isNumber(value)) { if (value.equals(Double.NaN) || value.equals(Float.NaN)) { return "NaN"; } String formatted = this.numberFormat.format(value); if (isNegativeZero(formatted)) { return formatted.substring(1); } return formatted; } if (value instanceof Date) { return this.dateFormat.format(value); } if (value == null) { return ""; } return this.formatString(String.valueOf(value)); } CellFormatter(double tolerance, boolean isGroupingUsed); @Override String apply(Object object); String format(Object value); } | @Test public void formatNumbers() { CellFormatter formatter = new CellFormatter(0.01, true); Assert.assertEquals("1", formatter.format(1.0d)); Assert.assertEquals("1.1", formatter.format(1.10d)); Assert.assertEquals("1.11", formatter.format(1.11d)); Assert.assertEquals("1.11", formatter.format(1.111d)); Assert.assertEquals("1.12", formatter.format(1.116d)); Assert.assertEquals("-1.12", formatter.format(-1.116d)); Assert.assertEquals("-1,000.12", formatter.format(-1000.116d)); Assert.assertEquals("-1,000.12", formatter.format(-1000.116f)); Assert.assertEquals("1,000", formatter.format(1000)); Assert.assertEquals("-1,000", formatter.format((long) -1000)); Assert.assertEquals("NaN", formatter.format(Double.NaN)); Assert.assertEquals("NaN", formatter.format(Float.NaN)); Assert.assertEquals("0", formatter.format(-0.0d)); Assert.assertEquals("0", formatter.format(-0)); Assert.assertEquals("0", formatter.format(-0.0001)); }
@Test public void formatDate() { CellFormatter formatter = new CellFormatter(0, false); Assert.assertEquals("2009-02-13 23:31:30", formatter.format(Timestamp.valueOf("2009-02-13 23:31:30.0001"))); } |
CellFormatter implements Function<Object, String>, Serializable { private String formatString(String untrimmedValue) { String value = untrimmedValue.trim(); this.builder.setLength(0); boolean changed = false; for (int i = 0; i < value.length(); i++) { char c = value.charAt(i); if (Character.isWhitespace(c)) { this.builder.append(' '); if (c != ' ') { changed = true; } } else { this.builder.append(c); } } return changed ? this.builder.toString() : value; } CellFormatter(double tolerance, boolean isGroupingUsed); @Override String apply(Object object); String format(Object value); } | @Test public void formatString() { CellFormatter formatter = new CellFormatter(0, false); Assert.assertEquals("", formatter.format("")); Assert.assertEquals("foo", formatter.format("foo")); Assert.assertEquals("foo", formatter.format(" foo ")); Assert.assertEquals("foo bar", formatter.format("foo bar")); Assert.assertEquals("foo bar", formatter.format("foo bar")); Assert.assertEquals("foo bar", formatter.format("foo\nbar ")); Assert.assertEquals("foo bar", formatter.format(" foo\rbar")); Assert.assertEquals("foo bar", formatter.format(" foo\r \nbar ")); Assert.assertEquals("foo", formatter.format("foo\r")); Assert.assertEquals("foo", formatter.format("\n foo")); Assert.assertEquals("", formatter.format("\n \r ")); Assert.assertEquals("", formatter.format(" \n \r")); } |
ExceptionHtml { static String stackTraceToString(Throwable e) throws UnsupportedEncodingException { ByteArrayOutputStream bytes = new ByteArrayOutputStream(); PrintStream out = new PrintStream(bytes, false, "UTF-8"); stackTraceToString(e, out); out.close(); return bytes.toString("UTF-8"); } private ExceptionHtml(); static void create(File resultsFile, Throwable reason); } | @Test public void testException() throws IOException { String stackTraceToString = ExceptionHtml.stackTraceToString(new RuntimeException(new IllegalArgumentException(new UnsupportedOperationException()))); List<Map.Entry<String, List<String>>> stackTraces = getStackLineCount(stackTraceToString); Assert.assertEquals(3, stackTraces.size()); Assert.assertEquals(RuntimeException.class.getName() + ": " + IllegalArgumentException.class.getName() + ": " + UnsupportedOperationException.class.getName(), stackTraces.get(0).getKey()); Assert.assertTrue(stackTraces.get(0).getValue().size() > 1); Assert.assertEquals("Caused by: " + IllegalArgumentException.class.getName() + ": " + UnsupportedOperationException.class.getName(), stackTraces.get(1).getKey()); Assert.assertTrue(stackTraces.get(1).getValue().size() > 1); Assert.assertEquals("Caused by: " + UnsupportedOperationException.class.getName(), stackTraces.get(2).getKey()); Assert.assertTrue(stackTraces.get(2).getValue().size() > 1); } |
UnmatchedIndexMap extends IndexMap { public void addMatch(int matchScore, UnmatchedIndexMap match) { if (this.equals(match)) { throw new IllegalArgumentException("Cannot add this as partial match"); } if (this.partialMatches == null) { this.partialMatches = new TreeSet<>(); } if (match.partialMatches == null) { match.partialMatches = new TreeSet<>(); } if (this.getExpectedIndex() < 0 || match.getActualIndex() < 0) { throw new IllegalStateException("Expecting this to be expected and that to be actual"); } this.partialMatches.add(new Match(matchScore, match)); match.partialMatches.add(new Match(matchScore, this)); } UnmatchedIndexMap(int expectedIndex, int actualIndex); void addMatch(int matchScore, UnmatchedIndexMap match); boolean match(); UnmatchedIndexMap getBestMutualMatch(); } | @Test(expected = IllegalArgumentException.class) public void testAddPartialMatchFailsIfSelf() { this.unmatched.addMatch(2, this.unmatched); } |
UnmatchedIndexMap extends IndexMap { public UnmatchedIndexMap getBestMutualMatch() { return this.bestMutualMatch; } UnmatchedIndexMap(int expectedIndex, int actualIndex); void addMatch(int matchScore, UnmatchedIndexMap match); boolean match(); UnmatchedIndexMap getBestMutualMatch(); } | @Test public void testInitialState() { Assert.assertNull(this.unmatched.getBestMutualMatch()); } |
TimeBoundPartialMatcher implements PartialMatcher { @Override public void match(final List<UnmatchedIndexMap> allMissingRows, final List<UnmatchedIndexMap> allSurplusRows, final List<IndexMap> matchedColumns) { LOGGER.debug("Starting partial match"); ExecutorService executorService = Executors.newSingleThreadExecutor(); Future<?> result = executorService.submit(() -> TimeBoundPartialMatcher.this.delegate.match(allMissingRows, allSurplusRows, matchedColumns)); try { result.get(this.timeoutMillis, TimeUnit.MILLISECONDS); LOGGER.debug("Partial match complete"); } catch (InterruptedException e) { LOGGER.error("Partial match interrupted", e); } catch (ExecutionException e) { LOGGER.error("Partial match exception", e); Throwable cause = e.getCause(); throw cause instanceof RuntimeException ? (RuntimeException) cause : new RuntimeException(cause); } catch (TimeoutException e) { LOGGER.error("Partial match timed out"); throw new RuntimeException(e); } finally { if (!executorService.isTerminated()) { executorService.shutdownNow(); } } } TimeBoundPartialMatcher(PartialMatcher delegate, long timeoutMillis); @Override void match(final List<UnmatchedIndexMap> allMissingRows, final List<UnmatchedIndexMap> allSurplusRows, final List<IndexMap> matchedColumns); } | @Test public void executionTimesOut() { try { PartialMatcher endlessMatcher = (allMissingRows, allSurplusRows, matchedColumns) -> { while (true); }; new TimeBoundPartialMatcher(endlessMatcher, 1L).match(null, null, null); Assert.fail("timeout expected"); } catch (RuntimeException e) { Assert.assertTrue(e.getCause() instanceof TimeoutException); } }
@Test(expected = IndexOutOfBoundsException.class) public void matchingExceptionPropagates() { PartialMatcher dyingMatcher = (allMissingRows, allSurplusRows, matchedColumns) -> Collections.singletonList("foo").get(2); new TimeBoundPartialMatcher(dyingMatcher, Long.MAX_VALUE).match(null, null, null); }
@Test public void matchingErrorPropagates() { PartialMatcher dyingMatcher = (allMissingRows, allSurplusRows, matchedColumns) -> { throw new NoSuchMethodError(); }; try { new TimeBoundPartialMatcher(dyingMatcher, Long.MAX_VALUE).match(null, null, null); Assert.fail(); } catch (RuntimeException e) { Assert.assertTrue(e.getCause() instanceof NoSuchMethodError); } }
@Test public void successfulMatch() { final AtomicBoolean matched = new AtomicBoolean(false); PartialMatcher matcher = (allMissingRows, allSurplusRows, matchedColumns) -> matched.set(true); new TimeBoundPartialMatcher(matcher, Long.MAX_VALUE).match(null, null, null); Assert.assertTrue(matched.get()); } |
IndexMap implements Comparable<IndexMap> { @Override public int compareTo(IndexMap that) { if (this.equals(that)) { return 0; } if (this.isMatched()) { if (that.actualIndex >= 0) { return compareUnequals(this.actualIndex, that.actualIndex, this.isSurplus()); } return compareUnequals(this.expectedIndex, that.expectedIndex, this.isSurplus()); } if (this.isSurplus()) { if (that.actualIndex >= 0) { return compareUnequals(this.actualIndex, that.actualIndex, this.isSurplus()); } return compareUnequals(this.actualIndex, that.expectedIndex, this.isSurplus()); } if (that.expectedIndex >= 0) { return compareUnequals(this.expectedIndex, that.expectedIndex, this.isSurplus()); } return compareUnequals(this.expectedIndex, that.actualIndex, this.isSurplus()); } IndexMap(int expectedIndex, int actualIndex); @Override boolean equals(Object obj); @Override int hashCode(); @Override int compareTo(IndexMap that); boolean isMissing(); boolean isSurplus(); boolean isMatched(); @Override String toString(); } | @Test public void compareTo1() { IndexMap im1 = new IndexMap(1, 2); IndexMap im2 = new IndexMap(2, 1); Assert.assertTrue(im1.compareTo(im2) > 0); Assert.assertTrue(im2.compareTo(im1) < 0); }
@Test public void compareTo2() { IndexMap im1 = new IndexMap(1, 2); IndexMap im2 = new IndexMap(2, -1); Assert.assertTrue(im1.compareTo(im2) < 0); Assert.assertTrue(im2.compareTo(im1) > 0); } |
SummaryResultTable implements FormattableTable, Serializable { public SummaryResultTable merge(SummaryResultTable resultTable) { List<ResultCell> nextHeaders = resultTable.getHeaders(); if (this.headers == null || nextHeaders.size() > this.headers.size()) { this.headers = nextHeaders; } this.passedCellCount += resultTable.getPassedCellCount(); this.totalCellCount += resultTable.getTotalCellCount(); for (Map.Entry<String, SummaryResult> entry : resultTable.getResultsByKey().entrySet()) { SummaryResult summaryResult = entry.getValue(); SummaryResult mergedResult = this.resultsByKey.get(entry.getKey()); if (mergedResult == null) { mergedResult = new SummaryResult(summaryResult); this.resultsByKey.put(entry.getKey(), mergedResult); } else { for (List<ResultCell> resultCells : summaryResult.firstFew) { mergedResult.addRow(resultCells); } mergedResult.mergeCardinalities(summaryResult.columnCardinalityList); mergedResult.totalRows += summaryResult.totalRows; } } return this; } SummaryResultTable(ResultTable resultTable); SummaryResultTable merge(SummaryResultTable resultTable); @Override boolean isSuccess(); @Override int getPassedCellCount(); @Override int getTotalCellCount(); @Override List<ResultCell> getHeaders(); @Override int getMatchedColumnsAhead(int col); @Override void appendTo(final String testName, final String tableName, final Element table, final HtmlOptions htmlOptions); } | @Test public void merge() { CellComparator cellComparator = new ToleranceCellComparator(new CellFormatter(1.0, false)); SummaryResultTable table1 = new SummaryResultTable(new ResultTable(new boolean[2], Arrays.asList( Arrays.asList(ResultCell.createMatchedCell(cellComparator, "Key", "Val")), Arrays.asList(ResultCell.createMatchedCell(cellComparator, "A", "A"))))); SummaryResultTable table2 = new SummaryResultTable(new ResultTable(new boolean[2], Arrays.asList( Arrays.asList(ResultCell.createMatchedCell(cellComparator, "Key", "Val")), Arrays.asList(ResultCell.createMatchedCell(cellComparator, "A", "B"))))); SummaryResultTable table3 = new SummaryResultTable(new ResultTable(new boolean[2], Arrays.asList( Arrays.asList(ResultCell.createMatchedCell(cellComparator, "Key", "Val")), Arrays.asList(ResultCell.createMatchedCell(cellComparator, "A", "B"))))); table1.merge(table2); table1.merge(table3); Assert.assertEquals("{0={firstFew=1, totalRows=1}, 31={firstFew=2, totalRows=2}}", asString(table1)); Assert.assertEquals("{31={firstFew=1, totalRows=1}}", asString(table2)); Assert.assertEquals("{31={firstFew=1, totalRows=1}}", asString(table3)); } |
MultiTableVerifier { public Map<String, ResultTable> verifyTables(Map<String, ? extends VerifiableTable> expectedResults, Map<String, ? extends VerifiableTable> actualResults) { Map<String, ResultTable> results = new LinkedHashMap<>(); List<String> allTableNames = new ArrayList<>(expectedResults.keySet()); for (String actualTable : actualResults.keySet()) { if (!expectedResults.containsKey(actualTable)) { allTableNames.add(actualTable); } } for (String tableName : allTableNames) { verifyTable(tableName, actualResults, expectedResults, results); } return results; } MultiTableVerifier(SingleTableVerifier singleSingleTableVerifier); Map<String, ResultTable> verifyTables(Map<String, ? extends VerifiableTable> expectedResults, Map<String, ? extends VerifiableTable> actualResults); } | @Test public void missingTable() { Map<String, ResultTable> results = verifyTables(createTables("assets"), createTables("assets", "liabs")); Assert.assertEquals(newPassTable(), results.get("assets").getVerifiedRows()); Assert.assertEquals(newMissingTable(), results.get("liabs").getVerifiedRows()); this.expectedTables = 2; }
@Test public void surplusTable() { Map<String, ResultTable> results = this.verifyTables(createTables("assets", "liabs"), createTables("liabs")); Assert.assertEquals(newSurplusTable(), results.get("assets").getVerifiedRows()); Assert.assertEquals(newPassTable(), results.get("liabs").getVerifiedRows()); this.expectedTables = 2; }
@Test public void misnamedTable() { Map<String, ResultTable> results = this.verifyTables(createTables("assets", "liabs"), createTables("assets", "liabz")); Assert.assertEquals(newPassTable(), results.get("assets").getVerifiedRows()); Assert.assertEquals(newSurplusTable(), results.get("liabs").getVerifiedRows()); Assert.assertEquals(newMissingTable(), results.get("liabz").getVerifiedRows()); this.expectedTables = 3; }
@Test(expected = IllegalStateException.class) public void noExpectedColumns() { this.verifyTables( Collections.singletonMap("table", TableTestUtils.createTable(1, "Col")), Collections.singletonMap("table", TableTestUtils.createTable(0))); }
@Test(expected = IllegalStateException.class) public void noActualColumns() { this.verifyTables( Collections.singletonMap("table", TableTestUtils.createTable(0)), Collections.singletonMap("table", TableTestUtils.createTable(1, "Col"))); } |
SparkVerifier { public SparkVerifier withTolerance(double tolerance) { this.columnComparatorsBuilder.withTolerance(tolerance); return this; } SparkVerifier(List<String> groupKeyColumns); final SparkVerifier withMetadata(String name, String value); SparkVerifier withIgnoreSurplusColumns(boolean ignoreSurplusColumns); SparkVerifier withColumnsToIgnore(Set<String> columnsToIgnore); SparkVerifier withTolerance(double tolerance); SparkVerifier withTolerance(String columnName, double tolerance); SparkVerifier withMaxGroupSize(int maxGroupSize); SparkResult verify(String dataName, Supplier<DistributedTable> actualDataSupplier, Supplier<DistributedTable> expectedDataSupplier); } | @Test public void withTolerance() throws IOException { List<GenericRecord> actual = Arrays.asList( row(AVSC, 12301, "123011", 12301, 123011.1), row(AVSC, 12301, "123012", 12302, 123012.2), row(AVSC, 12301, "123013", 12303, 123012.9), row(AVSC, 12302, "123021", 12301, 123020.8) ); List<GenericRecord> expected = Arrays.asList( row(AVSC, 12301, "123011", 12301, 123011.19), row(AVSC, 12301, "123012", 12302, 123012.11), row(AVSC, 12301, "123013", 12303, 123012.79), row(AVSC, 12302, "123021", 12301, 123020.91) ); runTest(actual, expected, false, newSparkVerifier(Collections.emptyList()) .withMaxGroupSize(2) .withTolerance(0.1)); } |
UnitOfWorkInvokerFactory { public Invoker create(Object service, Invoker rootInvoker, SessionFactory sessionFactory) { ImmutableMap.Builder<String, UnitOfWork> unitOfWorkMethodsBuilder = new ImmutableMap.Builder<>(); for (Method m : service.getClass().getMethods()) { if (m.isAnnotationPresent(UnitOfWork.class)) { unitOfWorkMethodsBuilder.put(m.getName(), m.getAnnotation(UnitOfWork.class)); } } ImmutableMap<String, UnitOfWork> unitOfWorkMethods = unitOfWorkMethodsBuilder.build(); Invoker invoker = rootInvoker; if (unitOfWorkMethods.size() > 0) { invoker = new UnitOfWorkInvoker(invoker, unitOfWorkMethods, sessionFactory); } return invoker; } Invoker create(Object service, Invoker rootInvoker, SessionFactory sessionFactory); } | @Test public void noAnnotation() { Invoker invoker = invokerBuilder.create(fooService, new FooInvoker(), null); this.setTargetMethod(exchange, "foo"); Object result = invoker.invoke(exchange, null); assertEquals("foo return", result); verifyZeroInteractions(sessionFactory); verifyZeroInteractions(session); verifyZeroInteractions(transaction); }
@Test public void unitOfWorkAnnotation() { Invoker invoker = invokerBuilder.create(fooService, new UnitOfWorkInvoker(false), sessionFactory); this.setTargetMethod(exchange, "unitOfWork", boolean.class); Object result = invoker.invoke(exchange, null); assertEquals("unitOfWork return", result); verify(session, times(1)).beginTransaction(); verify(transaction, times(1)).commit(); verify(transaction, times(0)).rollback(); verify(session, times(1)).close(); }
@Test public void unitOfWorkWithException() { Invoker invoker = invokerBuilder.create(fooService, new UnitOfWorkInvoker(true), sessionFactory); this.setTargetMethod(exchange, "unitOfWork", boolean.class); try { invoker.invoke(exchange, null); } catch (Exception e) { assertEquals("Uh oh", e.getMessage()); } verify(session, times(1)).beginTransaction(); verify(transaction, times(0)).commit(); verify(transaction, times(1)).rollback(); verify(session, times(1)).close(); } |
JAXWSEnvironment { public Endpoint publishEndpoint(EndpointBuilder endpointBuilder) { checkArgument(endpointBuilder != null, "EndpointBuilder is null"); EndpointImpl cxfendpoint = new EndpointImpl(bus, endpointBuilder.getService()); if(endpointBuilder.publishedEndpointUrl() != null) { cxfendpoint.setPublishedEndpointUrl(endpointBuilder.publishedEndpointUrl()); } else if(publishedEndpointUrlPrefix != null) { cxfendpoint.setPublishedEndpointUrl(publishedEndpointUrlPrefix + endpointBuilder.getPath()); } cxfendpoint.publish(endpointBuilder.getPath()); if (endpointBuilder.isMtomEnabled()) { ((SOAPBinding)cxfendpoint.getBinding()).setMTOMEnabled(true); } Invoker invoker = cxfendpoint.getService().getInvoker(); ValidatorFactory vf = Validation.buildDefaultValidatorFactory(); invoker = this.createValidatingInvoker(invoker, vf.getValidator()); if (endpointBuilder.getSessionFactory() != null) { invoker = unitOfWorkInvokerBuilder.create( endpointBuilder.getService(), invoker, endpointBuilder.getSessionFactory()); cxfendpoint.getService().setInvoker(invoker); } invoker = instrumentedInvokerBuilder.create(endpointBuilder.getService(), invoker); cxfendpoint.getService().setInvoker(invoker); if (endpointBuilder.getAuthentication() != null) { BasicAuthenticationInterceptor basicAuthInterceptor = this.createBasicAuthenticationInterceptor(); basicAuthInterceptor.setAuthenticator(endpointBuilder.getAuthentication()); cxfendpoint.getInInterceptors().add(basicAuthInterceptor); } if (endpointBuilder.getCxfInInterceptors() != null) { cxfendpoint.getInInterceptors().addAll(endpointBuilder.getCxfInInterceptors()); } if (endpointBuilder.getCxfInFaultInterceptors() != null) { cxfendpoint.getInFaultInterceptors().addAll(endpointBuilder.getCxfInFaultInterceptors()); } if (endpointBuilder.getCxfOutInterceptors() != null) { cxfendpoint.getOutInterceptors().addAll(endpointBuilder.getCxfOutInterceptors()); } if (endpointBuilder.getCxfOutFaultInterceptors() != null) { cxfendpoint.getOutFaultInterceptors().addAll(endpointBuilder.getCxfOutFaultInterceptors()); } if (endpointBuilder.getProperties() != null) { cxfendpoint.getProperties().putAll( endpointBuilder.getProperties()); } return cxfendpoint; } JAXWSEnvironment(String defaultPath); String getDefaultPath(); HttpServlet buildServlet(); void setPublishedEndpointUrlPrefix(String publishedEndpointUrlPrefix); void setInstrumentedInvokerBuilder(InstrumentedInvokerFactory instrumentedInvokerBuilder); void setUnitOfWorkInvokerBuilder(UnitOfWorkInvokerFactory unitOfWorkInvokerBuilder); void logEndpoints(); Endpoint publishEndpoint(EndpointBuilder endpointBuilder); T getClient(ClientBuilder<T> clientBuilder); } | @Test public void publishEndpointWithProperties() throws Exception { HashMap<String, Object> props = new HashMap<>(); props.put("key", "value"); Endpoint e = jaxwsEnvironment.publishEndpoint( new EndpointBuilder("local: .properties(props)); assertThat(e, is(notNullValue())); assertThat(e.getProperties().get("key"), equalTo("value")); verify(mockInvokerBuilder).create(any(), any(Invoker.class)); verifyZeroInteractions(mockUnitOfWorkInvokerBuilder); Node soapResponse = testutils.invoke("local: LocalTransportFactory.TRANSPORT_ID, soapRequest.getBytes()); verify(mockInvoker).invoke(any(Exchange.class), any()); testutils.assertValid("/soap:Envelope/soap:Body/a:fooResponse", soapResponse); }
@Test public void publishEndpointWithInvalidArguments() throws Exception { try { jaxwsEnvironment.publishEndpoint(new EndpointBuilder("foo", null)); } catch (IllegalArgumentException e) { } try { jaxwsEnvironment.publishEndpoint(new EndpointBuilder(null, service)); } catch (IllegalArgumentException e) { } try { jaxwsEnvironment.publishEndpoint(new EndpointBuilder(" ", service)); } catch (IllegalArgumentException e) { } }
@Test public void publishEndpoint() throws Exception { Endpoint e = jaxwsEnvironment.publishEndpoint(new EndpointBuilder("local: assertThat(e, is(notNullValue())); verify(mockInvokerBuilder).create(any(), any(Invoker.class)); verifyZeroInteractions(mockUnitOfWorkInvokerBuilder); Node soapResponse = testutils.invoke("local: LocalTransportFactory.TRANSPORT_ID, soapRequest.getBytes()); verify(mockInvoker).invoke(any(Exchange.class), any()); testutils.assertValid("/soap:Envelope/soap:Body/a:fooResponse", soapResponse); }
@Test public void publishEndpointWithAuthentication() throws Exception { jaxwsEnvironment.publishEndpoint( new EndpointBuilder("local: .authentication(mock(BasicAuthentication.class))); verify(mockInvokerBuilder).create(any(), any(Invoker.class)); verifyZeroInteractions(mockUnitOfWorkInvokerBuilder); Node soapResponse = testutils.invoke("local: LocalTransportFactory.TRANSPORT_ID, soapRequest.getBytes()); verify(mockInvoker).invoke(any(Exchange.class), any()); testutils.assertValid("/soap:Envelope/soap:Body/a:fooResponse", soapResponse); assertThat(mockBasicAuthInterceptorInvoked, equalTo(1)); }
@Test public void publishEndpointWithHibernateInvoker() throws Exception { jaxwsEnvironment.publishEndpoint( new EndpointBuilder("local: .sessionFactory(mock(SessionFactory.class))); verify(mockInvokerBuilder).create(any(), any(Invoker.class)); verify(mockUnitOfWorkInvokerBuilder).create(any(), any(Invoker.class), any(SessionFactory.class)); Node soapResponse = testutils.invoke("local: LocalTransportFactory.TRANSPORT_ID, soapRequest.getBytes()); verify(mockInvoker).invoke(any(Exchange.class), any()); testutils.assertValid("/soap:Envelope/soap:Body/a:fooResponse", soapResponse); }
@Test public void publishEndpointWithCxfInterceptors() throws Exception { TestInterceptor inInterceptor = new TestInterceptor(Phase.UNMARSHAL); TestInterceptor inInterceptor2 = new TestInterceptor(Phase.PRE_INVOKE); TestInterceptor outInterceptor = new TestInterceptor(Phase.MARSHAL); jaxwsEnvironment.publishEndpoint( new EndpointBuilder("local: .cxfInInterceptors(inInterceptor, inInterceptor2) .cxfOutInterceptors(outInterceptor)); verify(mockInvokerBuilder).create(any(), any(Invoker.class)); Node soapResponse = testutils.invoke("local: LocalTransportFactory.TRANSPORT_ID, soapRequest.getBytes()); verify(mockInvoker).invoke(any(Exchange.class), any()); assertThat(inInterceptor.getInvocationCount(), equalTo(1)); assertThat(inInterceptor2.getInvocationCount(), equalTo(1)); assertThat(outInterceptor.getInvocationCount(), equalTo(1)); testutils.assertValid("/soap:Envelope/soap:Body/a:fooResponse", soapResponse); soapResponse = testutils.invoke("local: LocalTransportFactory.TRANSPORT_ID, soapRequest.getBytes()); verify(mockInvoker, times(2)).invoke(any(Exchange.class), any()); assertThat(inInterceptor.getInvocationCount(), equalTo(2)); assertThat(inInterceptor2.getInvocationCount(), equalTo(2)); assertThat(outInterceptor.getInvocationCount(), equalTo(2)); testutils.assertValid("/soap:Envelope/soap:Body/a:fooResponse", soapResponse); }
@Test public void publishEndpointWithMtom() throws Exception { jaxwsEnvironment.publishEndpoint( new EndpointBuilder("local: .enableMtom()); verify(mockInvokerBuilder).create(any(), any(Invoker.class)); byte[] response = testutils.invokeBytes("local: verify(mockInvoker).invoke(any(Exchange.class), any()); MimeMultipart mimeMultipart = new MimeMultipart(new ByteArrayDataSource(response, "application/xop+xml; charset=UTF-8; type=\"text/xml\"")); assertThat(mimeMultipart.getCount(), equalTo(1)); testutils.assertValid("/soap:Envelope/soap:Body/a:fooResponse", StaxUtils.read(mimeMultipart.getBodyPart(0).getInputStream())); }
@Test public void publishEndpointWithCustomPublishedUrl() throws Exception { jaxwsEnvironment.publishEndpoint( new EndpointBuilder("local: .publishedEndpointUrl("http: ); verify(mockInvokerBuilder).create(any(), any(Invoker.class)); verifyZeroInteractions(mockUnitOfWorkInvokerBuilder); Server server = testutils.getServerForAddress("local: AbstractDestination destination = (AbstractDestination) server.getDestination(); String publishedEndpointUrl = destination.getEndpointInfo().getProperty(WSDLGetUtils.PUBLISHED_ENDPOINT_URL, String.class); assertThat(publishedEndpointUrl, equalTo("http: } |
JAXWSEnvironment { public <T> T getClient(ClientBuilder<T> clientBuilder) { JaxWsProxyFactoryBean proxyFactory = new JaxWsProxyFactoryBean(); proxyFactory.setServiceClass(clientBuilder.getServiceClass()); proxyFactory.setAddress(clientBuilder.getAddress()); if (clientBuilder.getHandlers() != null) { for (Handler h : clientBuilder.getHandlers()) { proxyFactory.getHandlers().add(h); } } if (clientBuilder.getBindingId() != null) { proxyFactory.setBindingId(clientBuilder.getBindingId()); } if (clientBuilder.getCxfInInterceptors() != null) { proxyFactory.getInInterceptors().addAll(clientBuilder.getCxfInInterceptors()); } if (clientBuilder.getCxfInFaultInterceptors() != null) { proxyFactory.getInFaultInterceptors().addAll(clientBuilder.getCxfInFaultInterceptors()); } if (clientBuilder.getCxfOutInterceptors() != null) { proxyFactory.getOutInterceptors().addAll(clientBuilder.getCxfOutInterceptors()); } if (clientBuilder.getCxfOutFaultInterceptors() != null) { proxyFactory.getOutFaultInterceptors().addAll(clientBuilder.getCxfOutFaultInterceptors()); } T proxy = clientBuilder.getServiceClass().cast(proxyFactory.create()); if (clientBuilder.isMtomEnabled()) { BindingProvider bp = (BindingProvider)proxy; SOAPBinding binding = (SOAPBinding)bp.getBinding(); binding.setMTOMEnabled(true); } HTTPConduit http = (HTTPConduit)ClientProxy.getClient(proxy).getConduit(); HTTPClientPolicy client = http.getClient(); client.setConnectionTimeout(clientBuilder.getConnectTimeout()); client.setReceiveTimeout(clientBuilder.getReceiveTimeout()); return proxy; } JAXWSEnvironment(String defaultPath); String getDefaultPath(); HttpServlet buildServlet(); void setPublishedEndpointUrlPrefix(String publishedEndpointUrlPrefix); void setInstrumentedInvokerBuilder(InstrumentedInvokerFactory instrumentedInvokerBuilder); void setUnitOfWorkInvokerBuilder(UnitOfWorkInvokerFactory unitOfWorkInvokerBuilder); void logEndpoints(); Endpoint publishEndpoint(EndpointBuilder endpointBuilder); T getClient(ClientBuilder<T> clientBuilder); } | @Test public void getClient() { String address = "http: Handler handler = mock(Handler.class); DummyInterface clientProxy = jaxwsEnvironment.getClient( new ClientBuilder<>(DummyInterface.class, address) ); assertThat(clientProxy, is(instanceOf(Proxy.class))); Client c = ClientProxy.getClient(clientProxy); assertThat(c.getEndpoint().getEndpointInfo().getAddress(), equalTo(address)); assertThat(c.getEndpoint().getService().get("endpoint.class").equals(DummyInterface.class), equalTo(true)); assertThat(((BindingProvider)clientProxy).getBinding() .getHandlerChain().size(), equalTo(0)); HTTPClientPolicy httpclient = ((HTTPConduit)c.getConduit()).getClient(); assertThat(httpclient.getConnectionTimeout(), equalTo(500L)); assertThat(httpclient.getReceiveTimeout(), equalTo(2000L)); TestInterceptor inInterceptor = new TestInterceptor(Phase.UNMARSHAL); TestInterceptor inInterceptor2 = new TestInterceptor(Phase.PRE_INVOKE); TestInterceptor outInterceptor = new TestInterceptor(Phase.MARSHAL); clientProxy = jaxwsEnvironment.getClient( new ClientBuilder<>(DummyInterface.class, address) .connectTimeout(123) .receiveTimeout(456) .handlers(handler) .bindingId(SoapBindingFactory.SOAP_12_BINDING) .cxfInInterceptors(inInterceptor, inInterceptor2) .cxfOutInterceptors(outInterceptor) .enableMtom()); c = ClientProxy.getClient(clientProxy); assertThat(((BindingProvider) clientProxy).getBinding().getBindingID(), equalTo("http: assertThat(c.getEndpoint().getEndpointInfo().getAddress(), equalTo(address)); assertThat(c.getEndpoint().getService().get("endpoint.class").equals(DummyInterface.class), equalTo(true)); httpclient = ((HTTPConduit)c.getConduit()).getClient(); assertThat(httpclient.getConnectionTimeout(), equalTo(123L)); assertThat(httpclient.getReceiveTimeout(), equalTo(456L)); assertThat(((BindingProvider)clientProxy).getBinding().getHandlerChain(), contains(handler)); BindingProvider bp = (BindingProvider)clientProxy; SOAPBinding binding = (SOAPBinding)bp.getBinding(); assertThat(binding.isMTOMEnabled(), equalTo(true)); } |
ValidatingInvoker extends AbstractInvoker { @Override public Object invoke(Exchange exchange, Object o) { Annotation[][] parameterAnnotations = this.getTargetMethod(exchange).getParameterAnnotations(); List<Object> params = null; if (o instanceof List) { params = CastUtils.cast((List<?>) o); } else if (o != null) { params = new MessageContentsList(o); } if (params != null) { int i = 0; try { for (Object parameter : params) { if(parameter == null || !AsyncHandler.class.isAssignableFrom(parameter.getClass())) { validate(parameterAnnotations[i++], parameter); } } } catch (ValidationException ve) { exchange.getInMessage().put(FaultMode.class, FaultMode.CHECKED_APPLICATION_FAULT); throw ve; } } return underlying.invoke(exchange, o); } ValidatingInvoker(Invoker underlying, Validator validator); @Override Object invoke(Exchange exchange, Object o); } | @Test public void invokeWithoutParams() { setTargetMethod(exchange, "noParams"); invoker.invoke(exchange, null); verify(underlying).invoke(exchange, null); }
@Test public void invokeWithoutValidation() { setTargetMethod(exchange, "noValidation", RootParam1.class, RootParam2.class); List<Object> params = Arrays.asList(null, null); invoker.invoke(exchange, params); verify(underlying).invoke(exchange, params); params = Arrays.asList(new RootParam1(null), new RootParam2(null)); invoker.invoke(exchange, params); verify(underlying).invoke(exchange, params); }
@Test public void invokeWithAsycHandler() { setTargetMethod(exchange, "asyncMethod", String.class); List<Object> params = Arrays.<Object>asList(null, new AsyncHandler(){ @Override public void handleResponse(Response res) { } }); invoker.invoke(exchange, params); verify(underlying).invoke(exchange, params); params = Arrays.asList("foo", new AsyncHandler(){ @Override public void handleResponse(Response res) { } }); invoker.invoke(exchange, params); verify(underlying).invoke(exchange, params); }
@Test public void invokeWithValidation() { setTargetMethod(exchange, "withValidation", RootParam1.class, RootParam2.class); List<Object> params = Arrays.asList(new RootParam1(new ChildParam("")), new RootParam2("ok")); try { invoker.invoke(exchange, params); fail(); } catch(Exception e) { assertThat(e, is(instanceOf(ValidationException.class))); } params = Arrays.asList(new RootParam1(new ChildParam("")), new RootParam2("ok")); try { invoker.invoke(exchange, params); fail(); } catch(Exception e) { assertThat(e, is(instanceOf(ValidationException.class))); } params = Arrays.asList(new RootParam1(new ChildParam("John")), new RootParam2("ok")); try { invoker.invoke(exchange, params); fail(); } catch(Exception e) { assertThat(e, is(instanceOf(ValidationException.class))); } verifyNoMoreInteractions(underlying); params = Arrays.asList(new RootParam1(new ChildParam("ok")), new RootParam2("ok")); invoker.invoke(exchange, params); verify(underlying).invoke(exchange, params); } |
InstrumentedInvokerFactory { public Invoker create(Object service, Invoker rootInvoker) { List<Method> timedmethods = new ArrayList<>(); List<Method> meteredmethods = new ArrayList<>(); List<Method> exceptionmeteredmethods = new ArrayList<>(); for (Method m : service.getClass().getMethods()) { if (m.isAnnotationPresent(Timed.class)) { timedmethods.add(m); } if (m.isAnnotationPresent(Metered.class)) { meteredmethods.add(m); } if (m.isAnnotationPresent(ExceptionMetered.class)) { exceptionmeteredmethods.add(m); } } Invoker invoker = rootInvoker; if (timedmethods.size() > 0) { invoker = this.timed(invoker, timedmethods); } if (meteredmethods.size() > 0) { invoker = this.metered(invoker, meteredmethods); } if (exceptionmeteredmethods.size() > 0) { invoker = this.exceptionMetered(invoker, exceptionmeteredmethods); } return invoker; } InstrumentedInvokerFactory(MetricRegistry metricRegistry); Invoker create(Object service, Invoker rootInvoker); } | @Test public void noAnnotation() { Timer timer = testMetricRegistry.timer("timed"); Meter meter = testMetricRegistry.meter("metered"); when(mockMetricRegistry.timer(anyString())).thenReturn(timer); when(mockMetricRegistry.meter(anyString())).thenReturn(meter); long oldtimervalue = timer.getCount(); long oldmetervalue = meter.getCount(); Invoker invoker = invokerBuilder.create(instrumentedService, new FooInvoker()); this.setTargetMethod(exchange, "foo"); Object result = invoker.invoke(exchange, null); assertEquals("fooReturn", result); assertThat(timer.getCount(), is(oldtimervalue)); assertThat(meter.getCount(), is(oldmetervalue)); }
@Test public void meteredAnnotation() { Timer timer = testMetricRegistry.timer("timed"); Meter meter = testMetricRegistry.meter("metered"); when(mockMetricRegistry.timer(anyString())).thenReturn(timer); when(mockMetricRegistry.meter(anyString())).thenReturn(meter); long oldtimervalue = timer.getCount(); long oldmetervalue = meter.getCount(); Invoker invoker = invokerBuilder.create(instrumentedService, new MeteredInvoker()); this.setTargetMethod(exchange, "metered"); Object result = invoker.invoke(exchange, null); assertEquals("meteredReturn", result); assertThat(timer.getCount(), is(oldtimervalue)); assertThat(meter.getCount(), is(1 + oldmetervalue)); }
@Test public void timedAnnotation() { Timer timer = testMetricRegistry.timer("timed"); Meter meter = testMetricRegistry.meter("metered"); when(mockMetricRegistry.timer(anyString())).thenReturn(timer); when(mockMetricRegistry.meter(anyString())).thenReturn(meter); long oldtimervalue = timer.getCount(); long oldmetervalue = meter.getCount(); Invoker invoker = invokerBuilder.create(instrumentedService, new TimedInvoker()); this.setTargetMethod(exchange, "timed"); Object result = invoker.invoke(exchange, null); assertEquals("timedReturn", result); assertThat(timer.getCount(), is(1 + oldtimervalue)); assertThat(meter.getCount(), is(oldmetervalue)); }
@Test public void exceptionMeteredAnnotation() { Timer timer = testMetricRegistry.timer("timed"); Meter meter = testMetricRegistry.meter("metered"); Meter exceptionmeter = testMetricRegistry.meter("exceptionMeteredExceptions"); when(mockMetricRegistry.timer(anyString())).thenReturn(timer); when(mockMetricRegistry.meter(contains("metered"))).thenReturn(meter); when(mockMetricRegistry.meter(contains("exceptionMetered"))).thenReturn(exceptionmeter); long oldtimervalue = timer.getCount(); long oldmetervalue = meter.getCount(); long oldexceptionmetervalue = exceptionmeter.getCount(); Invoker invoker = invokerBuilder.create(instrumentedService, new ExceptionMeteredInvoker(false)); this.setTargetMethod(exchange, "exceptionMetered", boolean.class); Object result = invoker.invoke(exchange, null); assertEquals("exceptionMeteredReturn", result); assertThat(timer.getCount(), is(oldtimervalue)); assertThat(meter.getCount(), is(oldmetervalue)); assertThat(exceptionmeter.getCount(), is(oldexceptionmetervalue)); invoker = invokerBuilder.create(instrumentedService, new ExceptionMeteredInvoker(true)); try { invoker.invoke(exchange, null); fail("Exception shall be thrown here"); } catch (Exception e) { assertThat(e, is(instanceOf(RuntimeException.class))); } assertThat(timer.getCount(), is(oldtimervalue)); assertThat(meter.getCount(), is(oldmetervalue)); assertThat(exceptionmeter.getCount(), is(1 + oldexceptionmetervalue)); } |
JAXWSBundle implements ConfiguredBundle<C> { public Endpoint publishEndpoint(EndpointBuilder endpointBuilder) { checkArgument(endpointBuilder != null, "EndpointBuilder is null"); return this.jaxwsEnvironment.publishEndpoint(endpointBuilder); } JAXWSBundle(); JAXWSBundle(String servletPath); JAXWSBundle(String servletPath, JAXWSEnvironment jaxwsEnvironment); @Override void initialize(Bootstrap<?> bootstrap); @Override void run(C configuration, Environment environment); Endpoint publishEndpoint(EndpointBuilder endpointBuilder); Endpoint publishEndpoint(String path, Object service); Endpoint publishEndpoint(String path, Object service, SessionFactory sessionFactory); Endpoint publishEndpoint(String path, Object service, BasicAuthentication authentication); Endpoint publishEndpoint(String path, Object service, BasicAuthentication auth,
SessionFactory sessionFactory); @Deprecated T getClient(Class<T> serviceClass, String address, Handler...handlers); T getClient(ClientBuilder<T> clientBuilder); } | @Test public void publishEndpoint() { JAXWSBundle<?> jaxwsBundle = new JAXWSBundle<>("/soap", jaxwsEnvironment); Object service = new Object(); try { jaxwsBundle.publishEndpoint(new EndpointBuilder("foo", null)); fail(); } catch (Exception e) { assertThat(e, is(instanceOf(IllegalArgumentException.class))); } try { jaxwsBundle.publishEndpoint(new EndpointBuilder(null, service)); fail(); } catch (Exception e) { assertThat(e, is(instanceOf(IllegalArgumentException.class))); } try { jaxwsBundle.publishEndpoint(new EndpointBuilder(" ", service)); fail(); } catch (Exception e) { assertThat(e, is(instanceOf(IllegalArgumentException.class))); } EndpointBuilder builder = mock(EndpointBuilder.class); jaxwsBundle.publishEndpoint(builder); verify(jaxwsEnvironment).publishEndpoint(builder); } |
JAXWSBundle implements ConfiguredBundle<C> { @Deprecated public <T> T getClient(Class<T> serviceClass, String address, Handler...handlers) { checkArgument(serviceClass != null, "ServiceClass is null"); checkArgument(address != null, "Address is null"); checkArgument((address).trim().length() > 0, "Address is empty"); return jaxwsEnvironment.getClient( new ClientBuilder<>(serviceClass, address).handlers(handlers)); } JAXWSBundle(); JAXWSBundle(String servletPath); JAXWSBundle(String servletPath, JAXWSEnvironment jaxwsEnvironment); @Override void initialize(Bootstrap<?> bootstrap); @Override void run(C configuration, Environment environment); Endpoint publishEndpoint(EndpointBuilder endpointBuilder); Endpoint publishEndpoint(String path, Object service); Endpoint publishEndpoint(String path, Object service, SessionFactory sessionFactory); Endpoint publishEndpoint(String path, Object service, BasicAuthentication authentication); Endpoint publishEndpoint(String path, Object service, BasicAuthentication auth,
SessionFactory sessionFactory); @Deprecated T getClient(Class<T> serviceClass, String address, Handler...handlers); T getClient(ClientBuilder<T> clientBuilder); } | @Test public void getClient() { JAXWSBundle<?> jaxwsBundle = new JAXWSBundle<>("/soap", jaxwsEnvironment); Class<?> cls = Object.class; String url = "http: try { jaxwsBundle.getClient(new ClientBuilder<>(null, null)); fail(); } catch (Exception e) { assertThat(e, is(instanceOf(IllegalArgumentException.class))); } try { jaxwsBundle.getClient(new ClientBuilder<>(null, url)); fail(); } catch (Exception e) { assertThat(e, is(instanceOf(IllegalArgumentException.class))); } try { jaxwsBundle.getClient(new ClientBuilder<>(cls, " ")); fail(); } catch (Exception e) { assertThat(e, is(instanceOf(IllegalArgumentException.class))); } ClientBuilder<?> builder = new ClientBuilder<>(cls, url); jaxwsBundle.getClient(builder); verify(jaxwsEnvironment).getClient(builder); } |
JAXWSEnvironment { public HttpServlet buildServlet() { CXFNonSpringServlet cxf = new CXFNonSpringServlet(); cxf.setBus(bus); return cxf; } JAXWSEnvironment(String defaultPath); String getDefaultPath(); HttpServlet buildServlet(); void setPublishedEndpointUrlPrefix(String publishedEndpointUrlPrefix); void setInstrumentedInvokerBuilder(InstrumentedInvokerFactory instrumentedInvokerBuilder); void setUnitOfWorkInvokerBuilder(UnitOfWorkInvokerFactory unitOfWorkInvokerBuilder); void logEndpoints(); Endpoint publishEndpoint(EndpointBuilder endpointBuilder); T getClient(ClientBuilder<T> clientBuilder); } | @Test public void buildServlet() { Object result = jaxwsEnvironment.buildServlet(); assertThat(result, is(instanceOf(CXFNonSpringServlet.class))); assertThat(((CXFNonSpringServlet) result).getBus(), is(instanceOf(Bus.class))); } |
TranslationUtils { public static Date toDate(DateTime date) { return (date == null) ? null : date.toDate(); } private TranslationUtils(); static Date toDate(DateTime date); static Date toDate(LocalDate ldate); static Date toDate(Calendar date); static Date toDate(Number timestamp); static Date toDate(Number timestamp, TimeUnit unit); static DateTime toDateTime(Date date); static LocalDate toLocalDate(Date date); static DataFile toDataFile(File file); static DataFile toDataFile(String filePath); static long toLong(Number longE); static long toLong(Date value); static long toLong(String value); static long toLong(Number longE, long defaultValue); static long toLong(Date value, long defaultValue); static long toLong(String stringContainingANumber, long defaultValue); static int toInt(Number number); static int toInt(String value); static int toInt(Number integer, int defaultV); static int toInt(String value, int defaultV); static Integer toInteger(String value, Integer defaultV); static boolean toBool(Boolean bool); static boolean toBool(String value); static boolean toBool(Boolean bool, boolean defaultB); static boolean toBool(String value, boolean defaultV); static double toDouble(Number value); static double toDouble(String value); static double toDouble(Number value, double defaultD); static double toDouble(String value, double defaultD); static URL toUrl(String url); static String toString(Object obj); static Base64 toBase64(Object obj); static byte[] toByteArray(Object obj); static synchronized Date convertTimestamp(String timestamp); static synchronized Date convertTimestamp(String timestamp, Date defaultDate); static synchronized Date convertTimestamp(String timestamp, DateFormat format, Date defaultDate); static synchronized Date convertTimestamp(String timestamp, DateFormat format); static synchronized Date convertRfc3339Timestamp(String timestamp); static synchronized Date convertRfc3339Timestamp(String timestamp, Date defaultDate); static synchronized String toDefaultTimestamp(Date date); static synchronized String toRfc3339Timestamp(Date date); static String toTimestamp(Date date, DateFormat format); static List<String> parseList(String string, String separator); static DateTime moveToUtc(Date date); static Date moveDateTimeToUtc(Date date); static String toUtcTimestamp(Date date); static Date convertStringToDate(String valueStr); static final String METHOD_CONVERT_STRING_TO_DATE; static final String METHOD_CONVERT_OTHER_TO_DATE; static final String METHOD_CONVERT_DATE_TO_DATETIME; static final String METHOD_CONVERT_DATE_TO_LOCALDATE; static final String METHOD_CONVERT_DATE_TO_STRING; static final String METHOD_CONVERT_STRING_TO_URL; static final String METHOD_CONVERT_BOOL_TO_BOOL; static final String METHOD_CONVERT_NUMBER_TO_LONG; static final String METHOD_CONVERT_NUMBER_TO_INT; static final String METHOD_CONVERT_NUMBER_TO_DOUBLE; static final String METHOD_CONVERT_ANY_TO_STRING; static final String METHOD_CONVERT_ANY_TO_BYTE_ARRAY; static final String METHOD_CONVERT_ANY_TO_BASE64; static final String METHOD_CONVERT_TO_DATA_FILE; } | @Test public void testToDateDateTime() { DateTime time = new DateTime(1000); assertEquals(new Date(1000), TranslationUtils.toDate(time)); }
@SuppressWarnings("boxing") @Test public void testToDateNumberTimeUnit() { Calendar calendar = Calendar.getInstance(); calendar.setTimeZone(TimeZone.getTimeZone("GMT")); calendar.set(Calendar.MILLISECOND, 0); calendar.set(1971, 0, 1, 0, 0, 0); assertEquals(calendar.getTime(), TranslationUtils.toDate(365, TimeUnit.DAYS)); calendar.set(1970, 0, 1, 0, 0, 0); assertEquals(calendar.getTime(), TranslationUtils.toDate(0, TimeUnit.DAYS)); calendar.set(1970, 0, 1, 0, 0, 1); assertEquals(calendar.getTime(), TranslationUtils.toDate(1000, TimeUnit.MILLISECONDS)); calendar.set(2069, 11, 7, 0, 0, 0); assertEquals(calendar.getTime(), TranslationUtils.toDate(36500, TimeUnit.DAYS)); } |
CertificateEnrollmentListOptions extends ListOptions { @Override public CertificateEnrollmentListOptions clone() { final CertificateEnrollmentListOptions opt = new CertificateEnrollmentListOptions(); opt.setOptions(this); return opt; } @Internal CertificateEnrollmentListOptions(Integer pageSize, Long maxResults, Order order, String after,
List<IncludeField> include, Filters filter); @Internal CertificateEnrollmentListOptions(CertificateEnrollmentListOptions certificateEnrollmentListOptions); CertificateEnrollmentListOptions(); @Internal CertificateEnrollmentListOptions(String after, Filters filter); List<Filter> getUpdatedAtFilters(); void addLessThanUpdatedAtFilter(Date filterByUpdatedAt); @SuppressWarnings("unchecked") T lessThanUpdatedAt(Date filterByUpdatedAt); void addGreaterThanUpdatedAtFilter(Date filterByUpdatedAt); @SuppressWarnings("unchecked") T greaterThanUpdatedAt(Date filterByUpdatedAt); List<Filter> getCertificateNameFilters(); void addEqualToCertificateNameFilter(String filterByCertificateName); @SuppressWarnings("unchecked") T equalToCertificateName(String filterByCertificateName); List<Filter> getDeviceIdFilters(); void addEqualToDeviceIdFilter(String filterByDeviceId); @SuppressWarnings("unchecked") T equalToDeviceId(String filterByDeviceId); List<Filter> getEnrollResultFilters(); void addNotEqualToEnrollResultFilter(CertificateEnrollmentEnrollResult filterByEnrollResult); @SuppressWarnings("unchecked") T notEqualToEnrollResult(CertificateEnrollmentEnrollResult filterByEnrollResult); void addEqualToEnrollResultFilter(CertificateEnrollmentEnrollResult filterByEnrollResult); @SuppressWarnings("unchecked") T equalToEnrollResult(CertificateEnrollmentEnrollResult filterByEnrollResult); List<Filter> getCreatedAtFilters(); void addLessThanCreatedAtFilter(Date filterByCreatedAt); @SuppressWarnings("unchecked") T lessThanCreatedAt(Date filterByCreatedAt); void addGreaterThanCreatedAtFilter(Date filterByCreatedAt); @SuppressWarnings("unchecked") T greaterThanCreatedAt(Date filterByCreatedAt); List<Filter> getEnrollStatusFilters(); void addNotEqualToEnrollStatusFilter(CertificateEnrollmentEnrollStatus filterByEnrollStatus); @SuppressWarnings("unchecked") T notEqualToEnrollStatus(CertificateEnrollmentEnrollStatus filterByEnrollStatus); void addEqualToEnrollStatusFilter(CertificateEnrollmentEnrollStatus filterByEnrollStatus); @SuppressWarnings("unchecked") T equalToEnrollStatus(CertificateEnrollmentEnrollStatus filterByEnrollStatus); @Override String toString(); @Override CertificateEnrollmentListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); static final String TAG_FILTER_BY_CERTIFICATE_NAME; static final String TAG_FILTER_BY_CREATED_AT; static final String TAG_FILTER_BY_DEVICE_ID; static final String TAG_FILTER_BY_ENROLL_RESULT; static final String TAG_FILTER_BY_ENROLL_STATUS; static final String TAG_FILTER_BY_UPDATED_AT; } | @SuppressWarnings("resource") @Test public void testClone() { try { CertificateEnrollmentListOptions certificateenrollmentlistoptions1 = new CertificateEnrollmentListOptions(Integer.valueOf(48), Long.valueOf(36), Order.getDefault(), "b0f5fbe1-99ac-48ae-9b47-721559e6ccff", null, null); CertificateEnrollmentListOptions certificateenrollmentlistoptions2 = certificateenrollmentlistoptions1.clone(); assertNotNull(certificateenrollmentlistoptions1); assertNotNull(certificateenrollmentlistoptions2); assertNotSame(certificateenrollmentlistoptions2, certificateenrollmentlistoptions1); assertEquals(certificateenrollmentlistoptions2, certificateenrollmentlistoptions1); } catch (Exception exception) { fail(exception.getMessage()); } } |
CertificateEnrollmentListOptions extends ListOptions { @Override @SuppressWarnings("PMD.UselessOverridingMethod") public int hashCode() { return super.hashCode(); } @Internal CertificateEnrollmentListOptions(Integer pageSize, Long maxResults, Order order, String after,
List<IncludeField> include, Filters filter); @Internal CertificateEnrollmentListOptions(CertificateEnrollmentListOptions certificateEnrollmentListOptions); CertificateEnrollmentListOptions(); @Internal CertificateEnrollmentListOptions(String after, Filters filter); List<Filter> getUpdatedAtFilters(); void addLessThanUpdatedAtFilter(Date filterByUpdatedAt); @SuppressWarnings("unchecked") T lessThanUpdatedAt(Date filterByUpdatedAt); void addGreaterThanUpdatedAtFilter(Date filterByUpdatedAt); @SuppressWarnings("unchecked") T greaterThanUpdatedAt(Date filterByUpdatedAt); List<Filter> getCertificateNameFilters(); void addEqualToCertificateNameFilter(String filterByCertificateName); @SuppressWarnings("unchecked") T equalToCertificateName(String filterByCertificateName); List<Filter> getDeviceIdFilters(); void addEqualToDeviceIdFilter(String filterByDeviceId); @SuppressWarnings("unchecked") T equalToDeviceId(String filterByDeviceId); List<Filter> getEnrollResultFilters(); void addNotEqualToEnrollResultFilter(CertificateEnrollmentEnrollResult filterByEnrollResult); @SuppressWarnings("unchecked") T notEqualToEnrollResult(CertificateEnrollmentEnrollResult filterByEnrollResult); void addEqualToEnrollResultFilter(CertificateEnrollmentEnrollResult filterByEnrollResult); @SuppressWarnings("unchecked") T equalToEnrollResult(CertificateEnrollmentEnrollResult filterByEnrollResult); List<Filter> getCreatedAtFilters(); void addLessThanCreatedAtFilter(Date filterByCreatedAt); @SuppressWarnings("unchecked") T lessThanCreatedAt(Date filterByCreatedAt); void addGreaterThanCreatedAtFilter(Date filterByCreatedAt); @SuppressWarnings("unchecked") T greaterThanCreatedAt(Date filterByCreatedAt); List<Filter> getEnrollStatusFilters(); void addNotEqualToEnrollStatusFilter(CertificateEnrollmentEnrollStatus filterByEnrollStatus); @SuppressWarnings("unchecked") T notEqualToEnrollStatus(CertificateEnrollmentEnrollStatus filterByEnrollStatus); void addEqualToEnrollStatusFilter(CertificateEnrollmentEnrollStatus filterByEnrollStatus); @SuppressWarnings("unchecked") T equalToEnrollStatus(CertificateEnrollmentEnrollStatus filterByEnrollStatus); @Override String toString(); @Override CertificateEnrollmentListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); static final String TAG_FILTER_BY_CERTIFICATE_NAME; static final String TAG_FILTER_BY_CREATED_AT; static final String TAG_FILTER_BY_DEVICE_ID; static final String TAG_FILTER_BY_ENROLL_RESULT; static final String TAG_FILTER_BY_ENROLL_STATUS; static final String TAG_FILTER_BY_UPDATED_AT; } | @SuppressWarnings("resource") @Test public void testHashCode() { try { CertificateEnrollmentListOptions certificateenrollmentlistoptions1 = new CertificateEnrollmentListOptions(Integer.valueOf(58), Long.valueOf(40), Order.getDefault(), "a079c181-0afe-4474-a989-af61026abaab", null, null); CertificateEnrollmentListOptions certificateenrollmentlistoptions2 = new CertificateEnrollmentListOptions(Integer.valueOf(58), Long.valueOf(40), Order.getDefault(), "a079c181-0afe-4474-a989-af61026abaab", null, null); assertNotNull(certificateenrollmentlistoptions1); assertNotNull(certificateenrollmentlistoptions2); assertNotSame(certificateenrollmentlistoptions2, certificateenrollmentlistoptions1); assertEquals(certificateenrollmentlistoptions2, certificateenrollmentlistoptions1); assertEquals(certificateenrollmentlistoptions2.hashCode(), certificateenrollmentlistoptions1.hashCode()); int hashCode = certificateenrollmentlistoptions1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, certificateenrollmentlistoptions1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } } |
CertificateEnrollmentListOptions extends ListOptions { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!super.equals(obj)) { return false; } if (!(obj instanceof CertificateEnrollmentListOptions)) { return false; } final CertificateEnrollmentListOptions other = (CertificateEnrollmentListOptions) obj; if (!other.canEqual(this)) { return false; } return true; } @Internal CertificateEnrollmentListOptions(Integer pageSize, Long maxResults, Order order, String after,
List<IncludeField> include, Filters filter); @Internal CertificateEnrollmentListOptions(CertificateEnrollmentListOptions certificateEnrollmentListOptions); CertificateEnrollmentListOptions(); @Internal CertificateEnrollmentListOptions(String after, Filters filter); List<Filter> getUpdatedAtFilters(); void addLessThanUpdatedAtFilter(Date filterByUpdatedAt); @SuppressWarnings("unchecked") T lessThanUpdatedAt(Date filterByUpdatedAt); void addGreaterThanUpdatedAtFilter(Date filterByUpdatedAt); @SuppressWarnings("unchecked") T greaterThanUpdatedAt(Date filterByUpdatedAt); List<Filter> getCertificateNameFilters(); void addEqualToCertificateNameFilter(String filterByCertificateName); @SuppressWarnings("unchecked") T equalToCertificateName(String filterByCertificateName); List<Filter> getDeviceIdFilters(); void addEqualToDeviceIdFilter(String filterByDeviceId); @SuppressWarnings("unchecked") T equalToDeviceId(String filterByDeviceId); List<Filter> getEnrollResultFilters(); void addNotEqualToEnrollResultFilter(CertificateEnrollmentEnrollResult filterByEnrollResult); @SuppressWarnings("unchecked") T notEqualToEnrollResult(CertificateEnrollmentEnrollResult filterByEnrollResult); void addEqualToEnrollResultFilter(CertificateEnrollmentEnrollResult filterByEnrollResult); @SuppressWarnings("unchecked") T equalToEnrollResult(CertificateEnrollmentEnrollResult filterByEnrollResult); List<Filter> getCreatedAtFilters(); void addLessThanCreatedAtFilter(Date filterByCreatedAt); @SuppressWarnings("unchecked") T lessThanCreatedAt(Date filterByCreatedAt); void addGreaterThanCreatedAtFilter(Date filterByCreatedAt); @SuppressWarnings("unchecked") T greaterThanCreatedAt(Date filterByCreatedAt); List<Filter> getEnrollStatusFilters(); void addNotEqualToEnrollStatusFilter(CertificateEnrollmentEnrollStatus filterByEnrollStatus); @SuppressWarnings("unchecked") T notEqualToEnrollStatus(CertificateEnrollmentEnrollStatus filterByEnrollStatus); void addEqualToEnrollStatusFilter(CertificateEnrollmentEnrollStatus filterByEnrollStatus); @SuppressWarnings("unchecked") T equalToEnrollStatus(CertificateEnrollmentEnrollStatus filterByEnrollStatus); @Override String toString(); @Override CertificateEnrollmentListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); static final String TAG_FILTER_BY_CERTIFICATE_NAME; static final String TAG_FILTER_BY_CREATED_AT; static final String TAG_FILTER_BY_DEVICE_ID; static final String TAG_FILTER_BY_ENROLL_RESULT; static final String TAG_FILTER_BY_ENROLL_STATUS; static final String TAG_FILTER_BY_UPDATED_AT; } | @SuppressWarnings("resource") @Test public void testEquals() { try { CertificateEnrollmentListOptions certificateenrollmentlistoptions1 = new CertificateEnrollmentListOptions(Integer.valueOf(1), Long.valueOf(-38), Order.getDefault(), "4c2f0459-26a3-4bf3-930d-2cc2a4358b6e", null, null); CertificateEnrollmentListOptions certificateenrollmentlistoptions2 = new CertificateEnrollmentListOptions(Integer.valueOf(1), Long.valueOf(-38), Order.getDefault(), "4c2f0459-26a3-4bf3-930d-2cc2a4358b6e", null, null); CertificateEnrollmentListOptions certificateenrollmentlistoptions3 = new CertificateEnrollmentListOptions(Integer.valueOf(-127), Long.valueOf(59), Order.getDefault(), "befffe12-e706-430f-85f8-49a031b8334a", null, null); assertNotNull(certificateenrollmentlistoptions1); assertNotNull(certificateenrollmentlistoptions2); assertNotNull(certificateenrollmentlistoptions3); assertNotSame(certificateenrollmentlistoptions2, certificateenrollmentlistoptions1); assertNotSame(certificateenrollmentlistoptions3, certificateenrollmentlistoptions1); assertEquals(certificateenrollmentlistoptions2, certificateenrollmentlistoptions1); assertEquals(certificateenrollmentlistoptions2, certificateenrollmentlistoptions1); assertEquals(certificateenrollmentlistoptions1, certificateenrollmentlistoptions2); assertEquals(certificateenrollmentlistoptions1, certificateenrollmentlistoptions1); assertFalse(certificateenrollmentlistoptions1.equals(null)); assertNotEquals(certificateenrollmentlistoptions3, certificateenrollmentlistoptions1); } catch (Exception exception) { fail(exception.getMessage()); } } |
SubtenantTrustedCertificateListOptions extends ListOptions { @Override public SubtenantTrustedCertificateListOptions clone() { final SubtenantTrustedCertificateListOptions opt = new SubtenantTrustedCertificateListOptions(); opt.setOptions(this); return opt; } @Internal SubtenantTrustedCertificateListOptions(Integer pageSize, Long maxResults, Order order, String after,
List<IncludeField> include, Filters filter); @Internal SubtenantTrustedCertificateListOptions(SubtenantTrustedCertificateListOptions subtenantTrustedCertificateListOptions); SubtenantTrustedCertificateListOptions(); @Internal SubtenantTrustedCertificateListOptions(String after, Filters filter); List<Filter> getValidFilters(); void addEqualToValidFilter(boolean filterByValid); @SuppressWarnings("unchecked") T equalToValid(boolean filterByValid); List<Filter> getNameFilters(); void addEqualToNameFilter(String filterByName); @SuppressWarnings("unchecked") T equalToName(String filterByName); List<Filter> getStatusFilters(); void addEqualToStatusFilter(SubtenantTrustedCertificateStatus filterByStatus); @SuppressWarnings("unchecked") T equalToStatus(SubtenantTrustedCertificateStatus filterByStatus); List<Filter> getDeviceExecutionModeFilters(); void addEqualToDeviceExecutionModeFilter(int filterByDeviceExecutionMode); @SuppressWarnings("unchecked") T equalToDeviceExecutionMode(int filterByDeviceExecutionMode); void addNotEqualToDeviceExecutionModeFilter(int filterByDeviceExecutionMode); @SuppressWarnings("unchecked") T notEqualToDeviceExecutionMode(int filterByDeviceExecutionMode); List<Filter> getIssuerFilters(); void addLikeIssuerFilter(String filterByIssuer); @SuppressWarnings("unchecked") T likeIssuer(String filterByIssuer); List<Filter> getServiceFilters(); void addEqualToServiceFilter(SubtenantTrustedCertificateService filterByService); @SuppressWarnings("unchecked") T equalToService(SubtenantTrustedCertificateService filterByService); List<Filter> getSubjectFilters(); void addLikeSubjectFilter(String filterBySubject); @SuppressWarnings("unchecked") T likeSubject(String filterBySubject); List<Filter> getEnrollmentModeFilters(); void addEqualToEnrollmentModeFilter(boolean filterByEnrollmentMode); @SuppressWarnings("unchecked") T equalToEnrollmentMode(boolean filterByEnrollmentMode); @Override String toString(); @Override SubtenantTrustedCertificateListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); static final String TAG_FILTER_BY_DEVICE_EXECUTION_MODE; static final String TAG_FILTER_BY_ENROLLMENT_MODE; static final String TAG_FILTER_BY_ISSUER; static final String TAG_FILTER_BY_NAME; static final String TAG_FILTER_BY_SERVICE; static final String TAG_FILTER_BY_STATUS; static final String TAG_FILTER_BY_SUBJECT; static final String TAG_FILTER_BY_VALID; } | @SuppressWarnings("resource") @Test public void testClone() { try { SubtenantTrustedCertificateListOptions subtenanttrustedcertificatelistoptions1 = new SubtenantTrustedCertificateListOptions(Integer.valueOf(50), Long.valueOf(-30), Order.getDefault(), "23d23473-f6f1-4a08-a77d-a56d2983c571", null, null); SubtenantTrustedCertificateListOptions subtenanttrustedcertificatelistoptions2 = subtenanttrustedcertificatelistoptions1.clone(); assertNotNull(subtenanttrustedcertificatelistoptions1); assertNotNull(subtenanttrustedcertificatelistoptions2); assertNotSame(subtenanttrustedcertificatelistoptions2, subtenanttrustedcertificatelistoptions1); assertEquals(subtenanttrustedcertificatelistoptions2, subtenanttrustedcertificatelistoptions1); } catch (Exception exception) { fail(exception.getMessage()); } } |
SubtenantTrustedCertificateListOptions extends ListOptions { @Override @SuppressWarnings("PMD.UselessOverridingMethod") public int hashCode() { return super.hashCode(); } @Internal SubtenantTrustedCertificateListOptions(Integer pageSize, Long maxResults, Order order, String after,
List<IncludeField> include, Filters filter); @Internal SubtenantTrustedCertificateListOptions(SubtenantTrustedCertificateListOptions subtenantTrustedCertificateListOptions); SubtenantTrustedCertificateListOptions(); @Internal SubtenantTrustedCertificateListOptions(String after, Filters filter); List<Filter> getValidFilters(); void addEqualToValidFilter(boolean filterByValid); @SuppressWarnings("unchecked") T equalToValid(boolean filterByValid); List<Filter> getNameFilters(); void addEqualToNameFilter(String filterByName); @SuppressWarnings("unchecked") T equalToName(String filterByName); List<Filter> getStatusFilters(); void addEqualToStatusFilter(SubtenantTrustedCertificateStatus filterByStatus); @SuppressWarnings("unchecked") T equalToStatus(SubtenantTrustedCertificateStatus filterByStatus); List<Filter> getDeviceExecutionModeFilters(); void addEqualToDeviceExecutionModeFilter(int filterByDeviceExecutionMode); @SuppressWarnings("unchecked") T equalToDeviceExecutionMode(int filterByDeviceExecutionMode); void addNotEqualToDeviceExecutionModeFilter(int filterByDeviceExecutionMode); @SuppressWarnings("unchecked") T notEqualToDeviceExecutionMode(int filterByDeviceExecutionMode); List<Filter> getIssuerFilters(); void addLikeIssuerFilter(String filterByIssuer); @SuppressWarnings("unchecked") T likeIssuer(String filterByIssuer); List<Filter> getServiceFilters(); void addEqualToServiceFilter(SubtenantTrustedCertificateService filterByService); @SuppressWarnings("unchecked") T equalToService(SubtenantTrustedCertificateService filterByService); List<Filter> getSubjectFilters(); void addLikeSubjectFilter(String filterBySubject); @SuppressWarnings("unchecked") T likeSubject(String filterBySubject); List<Filter> getEnrollmentModeFilters(); void addEqualToEnrollmentModeFilter(boolean filterByEnrollmentMode); @SuppressWarnings("unchecked") T equalToEnrollmentMode(boolean filterByEnrollmentMode); @Override String toString(); @Override SubtenantTrustedCertificateListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); static final String TAG_FILTER_BY_DEVICE_EXECUTION_MODE; static final String TAG_FILTER_BY_ENROLLMENT_MODE; static final String TAG_FILTER_BY_ISSUER; static final String TAG_FILTER_BY_NAME; static final String TAG_FILTER_BY_SERVICE; static final String TAG_FILTER_BY_STATUS; static final String TAG_FILTER_BY_SUBJECT; static final String TAG_FILTER_BY_VALID; } | @SuppressWarnings("resource") @Test public void testHashCode() { try { SubtenantTrustedCertificateListOptions subtenanttrustedcertificatelistoptions1 = new SubtenantTrustedCertificateListOptions(Integer.valueOf(38), Long.valueOf(79), Order.getDefault(), "f2d79052-cdeb-468c-81c9-c72f1883423c", null, null); SubtenantTrustedCertificateListOptions subtenanttrustedcertificatelistoptions2 = new SubtenantTrustedCertificateListOptions(Integer.valueOf(38), Long.valueOf(79), Order.getDefault(), "f2d79052-cdeb-468c-81c9-c72f1883423c", null, null); assertNotNull(subtenanttrustedcertificatelistoptions1); assertNotNull(subtenanttrustedcertificatelistoptions2); assertNotSame(subtenanttrustedcertificatelistoptions2, subtenanttrustedcertificatelistoptions1); assertEquals(subtenanttrustedcertificatelistoptions2, subtenanttrustedcertificatelistoptions1); assertEquals(subtenanttrustedcertificatelistoptions2.hashCode(), subtenanttrustedcertificatelistoptions1.hashCode()); int hashCode = subtenanttrustedcertificatelistoptions1.hashCode(); for (int i = 0; i < 5; i++) { assertEquals(hashCode, subtenanttrustedcertificatelistoptions1.hashCode()); } } catch (Exception exception) { fail(exception.getMessage()); } } |
SubtenantTrustedCertificateListOptions extends ListOptions { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!super.equals(obj)) { return false; } if (!(obj instanceof SubtenantTrustedCertificateListOptions)) { return false; } final SubtenantTrustedCertificateListOptions other = (SubtenantTrustedCertificateListOptions) obj; if (!other.canEqual(this)) { return false; } return true; } @Internal SubtenantTrustedCertificateListOptions(Integer pageSize, Long maxResults, Order order, String after,
List<IncludeField> include, Filters filter); @Internal SubtenantTrustedCertificateListOptions(SubtenantTrustedCertificateListOptions subtenantTrustedCertificateListOptions); SubtenantTrustedCertificateListOptions(); @Internal SubtenantTrustedCertificateListOptions(String after, Filters filter); List<Filter> getValidFilters(); void addEqualToValidFilter(boolean filterByValid); @SuppressWarnings("unchecked") T equalToValid(boolean filterByValid); List<Filter> getNameFilters(); void addEqualToNameFilter(String filterByName); @SuppressWarnings("unchecked") T equalToName(String filterByName); List<Filter> getStatusFilters(); void addEqualToStatusFilter(SubtenantTrustedCertificateStatus filterByStatus); @SuppressWarnings("unchecked") T equalToStatus(SubtenantTrustedCertificateStatus filterByStatus); List<Filter> getDeviceExecutionModeFilters(); void addEqualToDeviceExecutionModeFilter(int filterByDeviceExecutionMode); @SuppressWarnings("unchecked") T equalToDeviceExecutionMode(int filterByDeviceExecutionMode); void addNotEqualToDeviceExecutionModeFilter(int filterByDeviceExecutionMode); @SuppressWarnings("unchecked") T notEqualToDeviceExecutionMode(int filterByDeviceExecutionMode); List<Filter> getIssuerFilters(); void addLikeIssuerFilter(String filterByIssuer); @SuppressWarnings("unchecked") T likeIssuer(String filterByIssuer); List<Filter> getServiceFilters(); void addEqualToServiceFilter(SubtenantTrustedCertificateService filterByService); @SuppressWarnings("unchecked") T equalToService(SubtenantTrustedCertificateService filterByService); List<Filter> getSubjectFilters(); void addLikeSubjectFilter(String filterBySubject); @SuppressWarnings("unchecked") T likeSubject(String filterBySubject); List<Filter> getEnrollmentModeFilters(); void addEqualToEnrollmentModeFilter(boolean filterByEnrollmentMode); @SuppressWarnings("unchecked") T equalToEnrollmentMode(boolean filterByEnrollmentMode); @Override String toString(); @Override SubtenantTrustedCertificateListOptions clone(); @Override boolean equals(Object obj); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); static final String TAG_FILTER_BY_DEVICE_EXECUTION_MODE; static final String TAG_FILTER_BY_ENROLLMENT_MODE; static final String TAG_FILTER_BY_ISSUER; static final String TAG_FILTER_BY_NAME; static final String TAG_FILTER_BY_SERVICE; static final String TAG_FILTER_BY_STATUS; static final String TAG_FILTER_BY_SUBJECT; static final String TAG_FILTER_BY_VALID; } | @SuppressWarnings("resource") @Test public void testEquals() { try { SubtenantTrustedCertificateListOptions subtenanttrustedcertificatelistoptions1 = new SubtenantTrustedCertificateListOptions(Integer.valueOf(65), Long.valueOf(61), Order.getDefault(), "6646edc5-d533-4033-b553-763fb25382fd", null, null); SubtenantTrustedCertificateListOptions subtenanttrustedcertificatelistoptions2 = new SubtenantTrustedCertificateListOptions(Integer.valueOf(65), Long.valueOf(61), Order.getDefault(), "6646edc5-d533-4033-b553-763fb25382fd", null, null); SubtenantTrustedCertificateListOptions subtenanttrustedcertificatelistoptions3 = new SubtenantTrustedCertificateListOptions(Integer.valueOf(-9), Long.valueOf(79), Order.getDefault(), "0a4a71de-968f-49dd-8f4c-bc2efa782cd7", null, null); assertNotNull(subtenanttrustedcertificatelistoptions1); assertNotNull(subtenanttrustedcertificatelistoptions2); assertNotNull(subtenanttrustedcertificatelistoptions3); assertNotSame(subtenanttrustedcertificatelistoptions2, subtenanttrustedcertificatelistoptions1); assertNotSame(subtenanttrustedcertificatelistoptions3, subtenanttrustedcertificatelistoptions1); assertEquals(subtenanttrustedcertificatelistoptions2, subtenanttrustedcertificatelistoptions1); assertEquals(subtenanttrustedcertificatelistoptions2, subtenanttrustedcertificatelistoptions1); assertEquals(subtenanttrustedcertificatelistoptions1, subtenanttrustedcertificatelistoptions2); assertEquals(subtenanttrustedcertificatelistoptions1, subtenanttrustedcertificatelistoptions1); assertFalse(subtenanttrustedcertificatelistoptions1.equals(null)); assertNotEquals(subtenanttrustedcertificatelistoptions3, subtenanttrustedcertificatelistoptions1); } catch (Exception exception) { fail(exception.getMessage()); } } |
CertificateEnrollmentDao extends AbstractModelDao<CertificateEnrollment> implements ReadDao<CertificateEnrollment> { @Override @SuppressWarnings({ "resource", "unused" }) public CertificateEnrollmentDao clone() { try { return new CertificateEnrollmentDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } CertificateEnrollmentDao(); CertificateEnrollmentDao(ApiClientWrapper client); CertificateEnrollmentDao(ConnectionOptions options); CertificateEnrollmentDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) CertificateEnrollmentDao clone(); @Override CertificateEnrollment read(); CertificateEnrollment read(@NonNull CertificateEnrollment certificateEnrollment); @Override CertificateEnrollment read(@NonNull String id); } | @SuppressWarnings("resource") @Test public void testClone() { try { CertificateEnrollmentDao certificateenrollmentdao1 = new CertificateEnrollmentDao(); CertificateEnrollmentDao certificateenrollmentdao2 = certificateenrollmentdao1.clone(); assertNotNull(certificateenrollmentdao1); assertNotNull(certificateenrollmentdao2); assertNotSame(certificateenrollmentdao2, certificateenrollmentdao1); assertEquals(certificateenrollmentdao2, certificateenrollmentdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
PreSharedKeyDao extends AbstractPreSharedKeyDao { @Override @SuppressWarnings({ "resource", "unused" }) public PreSharedKeyDao clone() { try { return new PreSharedKeyDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } PreSharedKeyDao(); PreSharedKeyDao(ApiClientWrapper client); PreSharedKeyDao(ConnectionOptions options); PreSharedKeyDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) PreSharedKeyDao clone(); @Override @NotImplemented PreSharedKey create(); @Override @NotImplemented PreSharedKey create(PreSharedKey modelToCreate); void create(PreSharedKey modelToCreate, @NonNull String secretHex); @Override @NotImplemented void delete(PreSharedKey modelToDelete); } | @SuppressWarnings("resource") @Test public void testClone() { try { PreSharedKeyDao presharedkeydao1 = new PreSharedKeyDao(); PreSharedKeyDao presharedkeydao2 = presharedkeydao1.clone(); assertNotNull(presharedkeydao1); assertNotNull(presharedkeydao2); assertNotSame(presharedkeydao2, presharedkeydao1); assertEquals(presharedkeydao2, presharedkeydao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
CertificateEnrollmentListDao extends
AbstractModelListDao<CertificateEnrollment, CertificateEnrollmentListOptions> implements
ModelListDao<CertificateEnrollment, CertificateEnrollmentListOptions> { @Override @SuppressWarnings({ "resource", "unused" }) public CertificateEnrollmentListDao clone() { try { return new CertificateEnrollmentListDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } CertificateEnrollmentListDao(); CertificateEnrollmentListDao(ApiClientWrapper client); CertificateEnrollmentListDao(ConnectionOptions options); CertificateEnrollmentListDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) CertificateEnrollmentListDao clone(); @Override @Internal @SuppressWarnings("unchecked") Class<CertificateEnrollmentDao> getModelDaoClass(); @Override @Internal @SuppressWarnings({ "unchecked", "resource" }) CertificateEnrollmentDao getNewModelDao(); } | @SuppressWarnings("resource") @Test public void testClone() { try { CertificateEnrollmentListDao certificateenrollmentlistdao1 = new CertificateEnrollmentListDao(); CertificateEnrollmentListDao certificateenrollmentlistdao2 = certificateenrollmentlistdao1.clone(); assertNotNull(certificateenrollmentlistdao1); assertNotNull(certificateenrollmentlistdao2); assertNotSame(certificateenrollmentlistdao2, certificateenrollmentlistdao1); assertEquals(certificateenrollmentlistdao2, certificateenrollmentlistdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
CertificateIssuerConfigListDao extends
AbstractModelListDao<CertificateIssuerConfig,
CertificateIssuerConfigListOptions> implements
ModelListDao<CertificateIssuerConfig, CertificateIssuerConfigListOptions> { @Override @SuppressWarnings({ "resource", "unused" }) public CertificateIssuerConfigListDao clone() { try { return new CertificateIssuerConfigListDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } CertificateIssuerConfigListDao(); CertificateIssuerConfigListDao(ApiClientWrapper client); CertificateIssuerConfigListDao(ConnectionOptions options); CertificateIssuerConfigListDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) CertificateIssuerConfigListDao clone(); @Override @Internal @SuppressWarnings("unchecked") Class<CertificateIssuerConfigDao> getModelDaoClass(); @Override @Internal @SuppressWarnings({ "unchecked", "resource" }) CertificateIssuerConfigDao getNewModelDao(); } | @SuppressWarnings("resource") @Test public void testClone() { try { CertificateIssuerConfigListDao certificateissuerconfiglistdao1 = new CertificateIssuerConfigListDao(); CertificateIssuerConfigListDao certificateissuerconfiglistdao2 = certificateissuerconfiglistdao1.clone(); assertNotNull(certificateissuerconfiglistdao1); assertNotNull(certificateissuerconfiglistdao2); assertNotSame(certificateissuerconfiglistdao2, certificateissuerconfiglistdao1); assertEquals(certificateissuerconfiglistdao2, certificateissuerconfiglistdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
TranslationUtils { public static double toDouble(Number value) { return toDouble(value, 0.0); } private TranslationUtils(); static Date toDate(DateTime date); static Date toDate(LocalDate ldate); static Date toDate(Calendar date); static Date toDate(Number timestamp); static Date toDate(Number timestamp, TimeUnit unit); static DateTime toDateTime(Date date); static LocalDate toLocalDate(Date date); static DataFile toDataFile(File file); static DataFile toDataFile(String filePath); static long toLong(Number longE); static long toLong(Date value); static long toLong(String value); static long toLong(Number longE, long defaultValue); static long toLong(Date value, long defaultValue); static long toLong(String stringContainingANumber, long defaultValue); static int toInt(Number number); static int toInt(String value); static int toInt(Number integer, int defaultV); static int toInt(String value, int defaultV); static Integer toInteger(String value, Integer defaultV); static boolean toBool(Boolean bool); static boolean toBool(String value); static boolean toBool(Boolean bool, boolean defaultB); static boolean toBool(String value, boolean defaultV); static double toDouble(Number value); static double toDouble(String value); static double toDouble(Number value, double defaultD); static double toDouble(String value, double defaultD); static URL toUrl(String url); static String toString(Object obj); static Base64 toBase64(Object obj); static byte[] toByteArray(Object obj); static synchronized Date convertTimestamp(String timestamp); static synchronized Date convertTimestamp(String timestamp, Date defaultDate); static synchronized Date convertTimestamp(String timestamp, DateFormat format, Date defaultDate); static synchronized Date convertTimestamp(String timestamp, DateFormat format); static synchronized Date convertRfc3339Timestamp(String timestamp); static synchronized Date convertRfc3339Timestamp(String timestamp, Date defaultDate); static synchronized String toDefaultTimestamp(Date date); static synchronized String toRfc3339Timestamp(Date date); static String toTimestamp(Date date, DateFormat format); static List<String> parseList(String string, String separator); static DateTime moveToUtc(Date date); static Date moveDateTimeToUtc(Date date); static String toUtcTimestamp(Date date); static Date convertStringToDate(String valueStr); static final String METHOD_CONVERT_STRING_TO_DATE; static final String METHOD_CONVERT_OTHER_TO_DATE; static final String METHOD_CONVERT_DATE_TO_DATETIME; static final String METHOD_CONVERT_DATE_TO_LOCALDATE; static final String METHOD_CONVERT_DATE_TO_STRING; static final String METHOD_CONVERT_STRING_TO_URL; static final String METHOD_CONVERT_BOOL_TO_BOOL; static final String METHOD_CONVERT_NUMBER_TO_LONG; static final String METHOD_CONVERT_NUMBER_TO_INT; static final String METHOD_CONVERT_NUMBER_TO_DOUBLE; static final String METHOD_CONVERT_ANY_TO_STRING; static final String METHOD_CONVERT_ANY_TO_BYTE_ARRAY; static final String METHOD_CONVERT_ANY_TO_BASE64; static final String METHOD_CONVERT_TO_DATA_FILE; } | @Test public void testToDoubleConversion() { double doubleValue = 156433465.45464564; String doubleString = String.valueOf(doubleValue); assertEquals(doubleValue, TranslationUtils.toDouble(doubleString, 0), 0); doubleValue = Double.MAX_VALUE; doubleString = String.valueOf(doubleValue); assertEquals(doubleValue, TranslationUtils.toDouble(doubleString, 0), 0); assertEquals(10.0, TranslationUtils.toDouble(new Integer(10)), 0); assertEquals(10, TranslationUtils.toDouble("fsdlfsfkls", 10), 0); assertEquals(0.0, TranslationUtils.toDouble("fsdlfsfkls"), 0); } |
CertificateIssuerConfigDao extends AbstractModelDao<CertificateIssuerConfig> implements CrudDao<CertificateIssuerConfig> { @Override @SuppressWarnings({ "resource", "unused" }) public CertificateIssuerConfigDao clone() { try { return new CertificateIssuerConfigDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } CertificateIssuerConfigDao(); CertificateIssuerConfigDao(ApiClientWrapper client); CertificateIssuerConfigDao(ConnectionOptions options); CertificateIssuerConfigDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) CertificateIssuerConfigDao clone(); @Override CertificateIssuerConfig create(); @Override CertificateIssuerConfig create(@NonNull CertificateIssuerConfig createCertificateIssuerConfig); @Override void delete(); @Override void delete(@NonNull CertificateIssuerConfig certificateIssuerConfig); @Override void delete(@NonNull String id); CertificateIssuerConfig getDefault(); @Override CertificateIssuerConfig read(); CertificateIssuerConfig read(@NonNull CertificateIssuerConfig certificateIssuerConfig); @Override CertificateIssuerConfig read(@NonNull String id); @Override CertificateIssuerConfig update(); CertificateIssuerConfig update(@NonNull CertificateIssuerConfig certificateIssuerConfigRequest,
@NonNull String id); @Override CertificateIssuerConfig update(@NonNull CertificateIssuerConfig certificateIssuerConfig); CertificateIssuerConfig update(@NonNull String id); } | @SuppressWarnings("resource") @Test public void testClone() { try { CertificateIssuerConfigDao certificateissuerconfigdao1 = new CertificateIssuerConfigDao(); CertificateIssuerConfigDao certificateissuerconfigdao2 = certificateissuerconfigdao1.clone(); assertNotNull(certificateissuerconfigdao1); assertNotNull(certificateissuerconfigdao2); assertNotSame(certificateissuerconfigdao2, certificateissuerconfigdao1); assertEquals(certificateissuerconfigdao2, certificateissuerconfigdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
ServerCredentialsDao extends AbstractModelDao<ServerCredentials> { @Override @SuppressWarnings({ "resource", "unused" }) public ServerCredentialsDao clone() { try { return new ServerCredentialsDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } ServerCredentialsDao(); ServerCredentialsDao(ApiClientWrapper client); ServerCredentialsDao(ConnectionOptions options); ServerCredentialsDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) ServerCredentialsDao clone(); ServerCredentials getBootstrap(); ServerCredentials getLwm2m(); } | @SuppressWarnings("resource") @Test public void testClone() { try { ServerCredentialsDao servercredentialsdao1 = new ServerCredentialsDao(); ServerCredentialsDao servercredentialsdao2 = servercredentialsdao1.clone(); assertNotNull(servercredentialsdao1); assertNotNull(servercredentialsdao2); assertNotSame(servercredentialsdao2, servercredentialsdao1); assertEquals(servercredentialsdao2, servercredentialsdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
TrustedCertificateListDao extends AbstractModelListDao<TrustedCertificate, TrustedCertificateListOptions> implements ModelListDao<TrustedCertificate, TrustedCertificateListOptions> { @Override @SuppressWarnings({ "resource", "unused" }) public TrustedCertificateListDao clone() { try { return new TrustedCertificateListDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } TrustedCertificateListDao(); TrustedCertificateListDao(ApiClientWrapper client); TrustedCertificateListDao(ConnectionOptions options); TrustedCertificateListDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) TrustedCertificateListDao clone(); @Override @Internal @SuppressWarnings("unchecked") Class<TrustedCertificateDao> getModelDaoClass(); @Override @Internal @SuppressWarnings({ "unchecked", "resource" }) TrustedCertificateDao getNewModelDao(); } | @SuppressWarnings("resource") @Test public void testClone() { try { TrustedCertificateListDao trustedcertificatelistdao1 = new TrustedCertificateListDao(); TrustedCertificateListDao trustedcertificatelistdao2 = trustedcertificatelistdao1.clone(); assertNotNull(trustedcertificatelistdao1); assertNotNull(trustedcertificatelistdao2); assertNotSame(trustedcertificatelistdao2, trustedcertificatelistdao1); assertEquals(trustedcertificatelistdao2, trustedcertificatelistdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
CertificateIssuerDao extends AbstractCertificateIssuerDao { @Override @SuppressWarnings({ "resource", "unused" }) public CertificateIssuerDao clone() { try { return new CertificateIssuerDao().configureAndGet(getModuleOrThrow() == null ? null : getModuleOrThrow().clone()); } catch (MbedCloudException exception) { return null; } } CertificateIssuerDao(); CertificateIssuerDao(ApiClientWrapper client); CertificateIssuerDao(ConnectionOptions options); CertificateIssuerDao(SdkContext sdkContext); @Override @SuppressWarnings({ "resource", "unused" }) CertificateIssuerDao clone(); @Override @NotImplemented CertificateIssuer create(); @Override @NotImplemented CertificateIssuer create(CertificateIssuer modelToCreate); } | @SuppressWarnings("resource") @Test public void testClone() { try { CertificateIssuerDao certificateissuerdao1 = new CertificateIssuerDao(); CertificateIssuerDao certificateissuerdao2 = certificateissuerdao1.clone(); assertNotNull(certificateissuerdao1); assertNotNull(certificateissuerdao2); assertNotSame(certificateissuerdao2, certificateissuerdao1); assertEquals(certificateissuerdao2, certificateissuerdao1); } catch (Exception exception) { fail(exception.getMessage()); } } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.