Datasets:
Minata
/
1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files
xet
Community
1
method2testcases
stringlengths
118
6.63k
### Question: AbstractProjection implements Projection { @Override public double getDistanceFromModelCenterM(GeographicPosition position) { return 0; } static boolean isTerrainLocked(); static void setTerrainLocked(boolean lock); static void toggleTerrainLocked(); @Override long getActivationTimestamp(); @Override long getCreationTimestamp(); @Override double getDistanceFromModelCenterM(GeographicPosition position); @Override double getElevationOnTerrainM(GeographicPosition position); @Override Vector3d getModelCenter(); @Override Matrix4d getModelViewAdjustment(); @Override Projection getSnapshot(); @Override Collection<GeographicBoundingBox> handleElevationChange(ElevationChangedEvent event); @Override Collection<GeographicBoundingBox> handleModelDensityChanged(int density); boolean isModelCenterLocked(); @Override boolean isOutsideModel(Vector3d modelCoordinates); @Override void setActivationTimestamp(); void setModelCenter(Vector3d modelCenter); void setModelCenterLocked(boolean modelCenterLocked); void setProjectionChangeListener(ProjectionChangeSupport.ProjectionChangeListener projectionChangeListener); void useElevationOrderManager(OrderManager elevationOrderManager); static final boolean HIGH_ACCURACY_ALLOWED; static final int HIGH_ACCURACY_MIN_MODEL_DISTANCE; static final int HIGH_ACCURACY_THRESHOLD; }### Answer: @Test public void testGetDistanceFromModelCenterM() { assertEquals(0.0, myTestObject.getDistanceFromModelCenterM(null), 0); }
### Question: HttpServerProvider implements ServerProvider<HttpServer>, ServerCreator<HttpServer> { @Override public synchronized HttpServer getServer(String host, String protocol, int port) { String connectionKey = createConnectionKey(protocol, host, port); if (!myServers.containsKey(connectionKey)) { HttpServer server = createServer(host, protocol, port); myServers.put(connectionKey, server); notifyListeners(server); } return myServers.get(connectionKey); } HttpServerProvider(Toolbox toolbox, ServerFactory factory); @Override void addServerChangedListener(ServerChangedListener<HttpServer> listener); @Override synchronized void clearServers(); void close(); @Override HttpServer createServer(URL url); @Override synchronized HttpServer getServer(String host, String protocol, int port); @Override HttpServer getServer(URL url); @Override void removeServerChangedListener(ServerChangedListener<HttpServer> listener); }### Answer: @Test public void testGetServerAlreadyCreated() throws GeneralSecurityException, IOException { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = createToolbox(support); HttpServer server = support.createMock(HttpServer.class); int port = 1000; String serverKey = ourHost + ':' + port; ServerFactory factory = createFactory(support, port, serverKey, toolbox, server); support.replayAll(); URL url = new URL(ourProtocol + ": HttpServerProvider provider = new HttpServerProvider(toolbox, factory); HttpServer actualServer = provider.getServer(url); assertEquals(server, actualServer); HttpServer sameServer = provider.getServer(url); assertSame(actualServer, sameServer); support.verifyAll(); } @Test public void testGetServerURL() throws GeneralSecurityException, IOException { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = createToolbox(support); HttpServer server = support.createMock(HttpServer.class); int port = 1000; String serverKey = ourHost + ':' + port; ServerFactory factory = createFactory(support, port, serverKey, toolbox, server); support.replayAll(); URL url = new URL(ourProtocol + ": HttpServerProvider provider = new HttpServerProvider(toolbox, factory); HttpServer actualServer = provider.getServer(url); assertEquals(server, actualServer); support.verifyAll(); } @Test public void testGetServerURLNoPort() throws GeneralSecurityException, IOException { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = createToolbox(support); HttpServer server = support.createMock(HttpServer.class); URL url = new URL(ourProtocol + ": int port = url.getDefaultPort(); String serverKey = ourHost + ":" + port; ServerFactory factory = createFactory(support, port, serverKey, toolbox, server); support.replayAll(); HttpServerProvider provider = new HttpServerProvider(toolbox, factory); HttpServer actualServer = provider.getServer(url); assertEquals(server, actualServer); assertTrue(-1 != port); support.verifyAll(); }
### Question: ServerConfigEventHandler implements EventListener<ServerConfigEvent> { @Override public void notify(ServerConfigEvent event) { if (event.getEventAction() == ServerEventAction.ACTIVATE) { handleActivate(event); } } ServerConfigEventHandler(EventManager eventManager, ServerProvider<HttpServer> provider); @Override void notify(ServerConfigEvent event); void close(); }### Answer: @Test public void test() throws MalformedURLException { EasyMockSupport support = new EasyMockSupport(); EventManager eventManager = createEventManager(support); ServerProvider<HttpServer> provider = createServerProvider(support); ServerConfigEvent event = createEvent(support, ServerEventAction.ACTIVATE); ServerConfigEvent nonActivateEvent = createEvent(support, ServerEventAction.LOADCOMPLETE); support.replayAll(); ServerConfigEventHandler handler = new ServerConfigEventHandler(eventManager, provider); handler.notify(event); handler.notify(nonActivateEvent); support.verifyAll(); }
### Question: STKElevationImageReader implements ElevationImageReader { @Override public void init(GeographicBoundingBox bounds, double missingDataValue, String crs, String orderId) { myBounds = bounds; myProjection = crs; myOrderId = orderId; } STKElevationImageReader(); STKElevationImageReader(GeographicBoundingBox bounds, String projection, String orderId); @Override GeographicBoundingBox getBoundingBox(); @Override String getCRS(); @Override String getElevationOrderId(); @Override String getImageFormat(); @Override double getMissingDataValue(); @Override void init(GeographicBoundingBox bounds, double missingDataValue, String crs, String orderId); @Override double readElevation(GeographicPosition position, Image image, GeographicBoundingBox bounds, boolean approximate); }### Answer: @Test public void testInit() { ServiceLoader<ElevationImageReader> loader = ServiceLoader.load(ElevationImageReader.class); STKElevationImageReader reader = null; for (ElevationImageReader aReader : loader) { if (aReader instanceof STKElevationImageReader) { reader = (STKElevationImageReader)aReader; } } assertNotNull(reader); GeographicBoundingBox box = new GeographicBoundingBox(LatLonAlt.createFromDegrees(0, 0), LatLonAlt.createFromDegrees(10, 10)); reader.init(box, 0, "proj", "IamId"); assertEquals(box, reader.getBoundingBox()); assertEquals(-Short.MIN_VALUE, reader.getMissingDataValue(), 0); assertEquals("proj", reader.getCRS()); assertEquals("IamId", reader.getElevationOrderId()); }
### Question: AttributionTransformer extends DefaultTransformer implements DataRegistryListener<TileSetMetadata> { @Override public void allValuesRemoved(Object source) { List<LabelGeometry> removals = New.list(myGeometries.values()); myGeometries.clear(); publishGeometries(Collections.emptyList(), removals); } AttributionTransformer(DataRegistry dataRegistry, MapManager mapManager); @Override void open(); @Override void close(); @Override void allValuesRemoved(Object source); @Override boolean isIdArrayNeeded(); @Override boolean isWantingRemovedObjects(); @Override void valuesAdded(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> newValues, Object source); @Override void valuesRemoved(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> removedValues, Object source); @Override void valuesRemoved(DataModelCategory dataModelCategory, long[] ids, Object source); @Override void valuesUpdated(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> newValues, Object source); }### Answer: @Test public void testAllValuesRemoved() { EasyMockSupport support = new EasyMockSupport(); DataRegistry dataRegistry = createDataRegistry(support); List<Geometry> publishedGeometries = New.list(); GenericSubscriber<Geometry> subscriber = createSubscriber(support, publishedGeometries); MapManager mapManager = createMapManager(support); support.replayAll(); AttributionTransformer transformer = new AttributionTransformer(dataRegistry, mapManager); transformer.addSubscriber(subscriber); transformer.open(); TileSetMetadata metadata = new TileSetMetadata(); metadata.setAttribution("I am attribution"); transformer.valuesAdded(new DataModelCategory(ourServer, TileSetMetadata.class.getName(), ourTileSet), new long[] { 1 }, New.list(metadata), this); assertEquals(1, publishedGeometries.size()); assertEquals("Terrain provided by I am attribution", ((LabelGeometry)publishedGeometries.get(0)).getText()); transformer.allValuesRemoved(this); assertEquals(0, publishedGeometries.size()); transformer.close(); support.verifyAll(); }
### Question: AttributionTransformer extends DefaultTransformer implements DataRegistryListener<TileSetMetadata> { @Override public void valuesAdded(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> newValues, Object source) { LabelGeometry.Builder<ScreenPosition> builder = new Builder<>(); builder.setText("Terrain provided by " + newValues.iterator().next().getAttribution()); builder.setOutlined(true); builder.setPosition(getPosition()); builder.setFont(""); LabelRenderProperties props = new DefaultLabelRenderProperties(ZOrderRenderProperties.TOP_Z, true, false); props.setColor(Color.white); LabelGeometry label = new LabelGeometry(builder, props, null); myGeometries.put(dataModelCategory.getSource() + dataModelCategory.getCategory(), label); publishGeometries(Collections.singletonList(label), Collections.emptyList()); } AttributionTransformer(DataRegistry dataRegistry, MapManager mapManager); @Override void open(); @Override void close(); @Override void allValuesRemoved(Object source); @Override boolean isIdArrayNeeded(); @Override boolean isWantingRemovedObjects(); @Override void valuesAdded(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> newValues, Object source); @Override void valuesRemoved(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> removedValues, Object source); @Override void valuesRemoved(DataModelCategory dataModelCategory, long[] ids, Object source); @Override void valuesUpdated(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> newValues, Object source); }### Answer: @Test public void testValuesAdded() { EasyMockSupport support = new EasyMockSupport(); DataRegistry dataRegistry = createDataRegistry(support); List<Geometry> publishedGeometries = New.list(); GenericSubscriber<Geometry> subscriber = createSubscriber(support, publishedGeometries); MapManager mapManager = createMapManager(support); support.replayAll(); AttributionTransformer transformer = new AttributionTransformer(dataRegistry, mapManager); transformer.addSubscriber(subscriber); transformer.open(); TileSetMetadata metadata = new TileSetMetadata(); metadata.setAttribution("I am attribution"); transformer.valuesAdded(new DataModelCategory(ourServer, TileSetMetadata.class.getName(), ourTileSet), new long[] { 1 }, New.list(metadata), this); assertEquals(1, publishedGeometries.size()); LabelGeometry label = (LabelGeometry)publishedGeometries.get(0); assertEquals("Terrain provided by I am attribution", label.getText()); assertEquals(2, label.getPosition().asVector2d().getX(), 0); assertEquals(498, label.getPosition().asVector2d().getY(), 0); transformer.valuesRemoved(new DataModelCategory(ourServer, TileSetMetadata.class.getName(), "Some other Tile"), new long[] { 2 }, this); assertEquals(1, publishedGeometries.size()); transformer.valuesRemoved(new DataModelCategory(ourServer, TileSetMetadata.class.getName(), ourTileSet), new long[] { 1 }, this); assertEquals(0, publishedGeometries.size()); transformer.close(); support.verifyAll(); }
### Question: STKTerrainImageProvider implements ImageProvider<ZYXImageKey> { @Override public Image getImage(ZYXImageKey key) { DataModelCategory category = new DataModelCategory(myServerUrl, QuantizedMesh.class.getName(), myTileSetName); List<PropertyMatcher<?>> matchers = New.list(); ZYXKeyPropertyMatcher keyMatcher = new ZYXKeyPropertyMatcher(Constants.KEY_PROPERTY_DESCRIPTOR, key); matchers.add(keyMatcher); SimpleQuery<QuantizedMesh> query = new SimpleQuery<>(category, Constants.QUANTIZED_MESH_PROPERTY_DESCRIPTOR, matchers); QueryTracker tracker = myDataRegistry.performQuery(query); QuantizedMesh mesh = null; if (query.getResults() != null && !query.getResults().isEmpty()) { mesh = query.getResults().get(0); } else if (tracker.getException() != null) { LOGGER.error(tracker.getException(), tracker.getException()); } return mesh; } STKTerrainImageProvider(DataRegistry dataRegistry, String serverUrl, String tileSetName); @Override Image getImage(ZYXImageKey key); }### Answer: @Test public void testGetImage() { EasyMockSupport support = new EasyMockSupport(); QuantizedMesh mesh = new QuantizedMesh(ByteBuffer.wrap(QuantizedMeshTest.createMeshByes())); DataRegistry dataRegistry = createDataRegistry(support, mesh); support.replayAll(); STKTerrainImageProvider provider = new STKTerrainImageProvider(dataRegistry, ourServerUrl, ourTileSetName); Image image = provider.getImage(ourImageKey); assertEquals(mesh, image); support.verifyAll(); } @Test public void testGetImageNull() { EasyMockSupport support = new EasyMockSupport(); DataRegistry dataRegistry = createDataRegistry(support, null); support.replayAll(); STKTerrainImageProvider provider = new STKTerrainImageProvider(dataRegistry, ourServerUrl, ourTileSetName); Image image = provider.getImage(ourImageKey); assertNull(image); support.verifyAll(); }
### Question: AbstractProjection implements Projection { @Override public double getElevationOnTerrainM(GeographicPosition position) { return 0; } static boolean isTerrainLocked(); static void setTerrainLocked(boolean lock); static void toggleTerrainLocked(); @Override long getActivationTimestamp(); @Override long getCreationTimestamp(); @Override double getDistanceFromModelCenterM(GeographicPosition position); @Override double getElevationOnTerrainM(GeographicPosition position); @Override Vector3d getModelCenter(); @Override Matrix4d getModelViewAdjustment(); @Override Projection getSnapshot(); @Override Collection<GeographicBoundingBox> handleElevationChange(ElevationChangedEvent event); @Override Collection<GeographicBoundingBox> handleModelDensityChanged(int density); boolean isModelCenterLocked(); @Override boolean isOutsideModel(Vector3d modelCoordinates); @Override void setActivationTimestamp(); void setModelCenter(Vector3d modelCenter); void setModelCenterLocked(boolean modelCenterLocked); void setProjectionChangeListener(ProjectionChangeSupport.ProjectionChangeListener projectionChangeListener); void useElevationOrderManager(OrderManager elevationOrderManager); static final boolean HIGH_ACCURACY_ALLOWED; static final int HIGH_ACCURACY_MIN_MODEL_DISTANCE; static final int HIGH_ACCURACY_THRESHOLD; }### Answer: @Test public void testGetElevationOnTerrainM() { assertEquals(0.0, myTestObject.getElevationOnTerrainM(null), 0); }
### Question: STKImageReader implements ImageReader { @Override public String getImageFormat() { return Constants.IMAGE_FORMAT; } @Override String getImageFormat(); @Override Image readImage(ByteBuffer imageBytes); }### Answer: @Test public void testGetImageFormat() { STKImageReader reader = new STKImageReader(); STKElevationImageReader elevationReader = new STKElevationImageReader( new GeographicBoundingBox(LatLonAlt.createFromDegrees(0, 0), LatLonAlt.createFromDegrees(10, 10)), "EPSG:4283", "order"); assertEquals(elevationReader.getImageFormat(), reader.getImageFormat()); }
### Question: STKImageReader implements ImageReader { @Override public Image readImage(ByteBuffer imageBytes) { QuantizedMesh mesh = new QuantizedMesh(imageBytes); return mesh; } @Override String getImageFormat(); @Override Image readImage(ByteBuffer imageBytes); }### Answer: @Test public void testReadImage() { STKImageReader reader = new STKImageReader(); QuantizedMesh mesh = (QuantizedMesh)reader.readImage(ByteBuffer.wrap(QuantizedMeshTest.createMeshByes())); assertEquals(5, mesh.getHeader().getMaxHeight(), 0); }
### Question: STKTerrainTileDivider extends AbstractDivider<GeographicPosition> { @Override public Collection<AbstractTileGeometry<?>> divide(AbstractTileGeometry<?> parent) { int generation = parent.getGeneration() + 1; if (generation > myTileSetMetadata.getMaxzoom()) { throw new IllegalArgumentException("Not enough zoom levels to divide geometry: " + parent); } List<AbstractTileGeometry<?>> dividedTiles = New.list(); Object imageKey = parent.getImageManager().getImageKey(); if (imageKey instanceof ZYXImageKey) { ZYXImageKey zyx = (ZYXImageKey)imageKey; int y = zyx.getY(); int x = zyx.getX(); int[] newXs = calculateNewXorY(x); int[] newYs = calculateNewXorY(y); List<GeographicBoundingBox> newBoxes = calculateNewBoxes(zyx.getBounds()); int index = 0; for (int newY : newYs) { for (int newX : newXs) { GeographicBoundingBox newBounds = newBoxes.get(index); ZYXImageKey newKey = new ZYXImageKey(generation, newY, newX, newBounds); STKTerrainTileDivider divider = this; if (generation + 1 > myTileSetMetadata.getMaxzoom()) { divider = null; } AbstractTileGeometry<?> subTile = parent.createSubTile(newBounds, newKey, divider); dividedTiles.add(subTile); index++; } } } return dividedTiles; } STKTerrainTileDivider(String layerKey, TileSetMetadata tileSetMetadata); @Override Collection<AbstractTileGeometry<?>> divide(AbstractTileGeometry<?> parent); }### Answer: @Test public void testDivide() { EasyMockSupport support = new EasyMockSupport(); DataRegistry dataRegistry = support.createMock(DataRegistry.class); TileRenderProperties props = support.createMock(TileRenderProperties.class); support.replayAll(); String typeKey = "I am type key"; String serverUrl = "http: String tileSetName = "world"; TileSetMetadata tileSetMetadata = new TileSetMetadata(); tileSetMetadata.setMaxzoom(2); STKTerrainTileDivider divider = new STKTerrainTileDivider(typeKey, tileSetMetadata); STKGeometryBuilder builder = new STKGeometryBuilder(dataRegistry); List<TerrainTileGeometry> geometries = builder.buildInitialGeometries(typeKey, serverUrl, tileSetName, tileSetMetadata, divider, props); assertGeometries(geometries, ourZeroExpectedKeys, divider); List<TerrainTileGeometry> zoomLevelOneGeoms = divideTiles(geometries, divider); assertGeometries(zoomLevelOneGeoms, ourOneExpectedKeys, divider); List<TerrainTileGeometry> zoomLevelTwoGeoms = divideTiles(zoomLevelOneGeoms, divider); assertGeometries(zoomLevelTwoGeoms, ourTwoExpectedKeys, null); support.verifyAll(); }
### Question: STKLayerTransformer extends DefaultTransformer implements DataRegistryListener<TileSetMetadata> { @Override public void allValuesRemoved(Object source) { List<TerrainTileGeometry> removals = New.list(); for (Entry<String, List<TerrainTileGeometry>> entry : myPublishedGeometries.entrySet()) { removals.addAll(entry.getValue()); } myPublishedGeometries.clear(); publishGeometries(New.collection(), removals); } STKLayerTransformer(DataRegistry dataRegistry, DataGroupController groupController, EventManager eventManager); @Override void allValuesRemoved(Object source); @Override void close(); @Override boolean isIdArrayNeeded(); @Override boolean isWantingRemovedObjects(); @Override void valuesAdded(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> newValues, Object source); @Override void valuesRemoved(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> removedValues, Object source); @Override void valuesRemoved(DataModelCategory dataModelCategory, long[] ids, Object source); @Override void valuesUpdated(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> newValues, Object source); }### Answer: @Test public void testAllValuesRemoved() { EasyMockSupport support = new EasyMockSupport(); DataRegistry dataRegistry = createDataRegistry(support); List<Geometry> publishedGeometries = New.list(); GenericSubscriber<Geometry> subscriber = createSubscriber(support, publishedGeometries); DataGroupController groupController = createGroupController(support, Boolean.TRUE); EventManager eventManager = createEventManager(support); support.replayAll(); STKLayerTransformer transformer = new STKLayerTransformer(dataRegistry, groupController, eventManager); transformer.addSubscriber(subscriber); transformer.open(); TileSetMetadata metadata = new TileSetMetadata(); transformer.valuesAdded(new DataModelCategory(ourServer, TileSetMetadata.class.getName(), ourTileSet), new long[] { 1 }, New.list(metadata), this); assertEquals(2, publishedGeometries.size()); transformer.allValuesRemoved(this); assertEquals(0, publishedGeometries.size()); transformer.close(); support.verifyAll(); }
### Question: STKLayerTransformer extends DefaultTransformer implements DataRegistryListener<TileSetMetadata> { @Override public void valuesAdded(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> newValues, Object source) { String serverUrl = dataModelCategory.getSource(); String tileSetName = dataModelCategory.getCategory(); String layerKey = serverUrl + tileSetName; TileSetMetadata tileSetMetadata = newValues.iterator().next(); STKTerrainTileDivider divider = new STKTerrainTileDivider(layerKey, tileSetMetadata); DataTypeInfo dataType = myGroupController.findMemberById(layerKey); List<TerrainTileGeometry> geometries = myBuilder.buildInitialGeometries(layerKey, serverUrl, tileSetName, tileSetMetadata, divider, dataType.getMapVisualizationInfo().getTileRenderProperties()); myPublishedGeometries.put(layerKey, geometries); if (dataType.isVisible()) { publishGeometries(geometries, New.collection()); } } STKLayerTransformer(DataRegistry dataRegistry, DataGroupController groupController, EventManager eventManager); @Override void allValuesRemoved(Object source); @Override void close(); @Override boolean isIdArrayNeeded(); @Override boolean isWantingRemovedObjects(); @Override void valuesAdded(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> newValues, Object source); @Override void valuesRemoved(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> removedValues, Object source); @Override void valuesRemoved(DataModelCategory dataModelCategory, long[] ids, Object source); @Override void valuesUpdated(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSetMetadata> newValues, Object source); }### Answer: @Test public void testValuesAdded() { EasyMockSupport support = new EasyMockSupport(); DataRegistry dataRegistry = createDataRegistry(support); List<Geometry> publishedGeometries = New.list(); GenericSubscriber<Geometry> subscriber = createSubscriber(support, publishedGeometries); DataGroupController typeController = createGroupController(support, Boolean.TRUE); EventManager eventManager = createEventManager(support); support.replayAll(); STKLayerTransformer transformer = new STKLayerTransformer(dataRegistry, typeController, eventManager); transformer.addSubscriber(subscriber); transformer.open(); TileSetMetadata metadata = new TileSetMetadata(); transformer.valuesAdded(new DataModelCategory(ourServer, TileSetMetadata.class.getName(), ourTileSet), new long[] { 1 }, New.list(metadata), this); assertEquals(2, publishedGeometries.size()); int index = 0; for (ZYXImageKey key : ourZeroExpectedKeys) { TerrainTileGeometry geometry = (TerrainTileGeometry)publishedGeometries.get(index); assertEquals(key.toString(), geometry.getImageManager().getImageKey().toString()); index++; } transformer.valuesRemoved(new DataModelCategory(ourServer, TileSetMetadata.class.getName(), "Some other Tile"), new long[] { 2 }, this); assertEquals(2, publishedGeometries.size()); transformer.valuesRemoved(new DataModelCategory(ourServer, TileSetMetadata.class.getName(), ourTileSet), new long[] { 1 }, this); assertEquals(0, publishedGeometries.size()); transformer.close(); support.verifyAll(); }
### Question: STKDataGroupBuilder { public DataGroupInfo createGroupAndType(TileSet tileSet, String serverUrl) { String id = serverUrl + tileSet.getName(); DefaultDataGroupInfo dataGroup = new DefaultDataGroupInfo(false, myToolbox, Constants.PROVIDER_TYPE, serverUrl + tileSet.getName(), tileSet.getName()); dataGroup.activationProperty().addListener(myActivationListener); dataGroup.setGroupDescription(buildDescription(tileSet)); DefaultDataTypeInfo dataType = new DefaultDataTypeInfo(myToolbox, serverUrl, id, tileSet.getName(), tileSet.getName(), false); dataType.setUrl(serverUrl); OrderParticipantKey orderKey = new DefaultOrderParticipantKey(DefaultOrderCategory.DEFAULT_ELEVATION_FAMILY, DefaultOrderCategory.EARTH_ELEVATION_CATEGORY, id); dataType.setOrderKey(orderKey); int zOrder = myOrderManager.activateParticipant(orderKey); DefaultTileRenderProperties props = new DefaultTileRenderProperties(zOrder, true, false); ServerMapVisualizationInfo mapInfo = new ServerMapVisualizationInfo(MapVisualizationType.TERRAIN_TILE, props); dataType.setMapVisualizationInfo(mapInfo); dataGroup.addMember(dataType, this); return dataGroup; } STKDataGroupBuilder(Toolbox toolbox); DataGroupInfo createGroupAndType(TileSet tileSet, String serverUrl); }### Answer: @Test public void testCreateGroupAndType() { EasyMockSupport support = new EasyMockSupport(); TileSet tileSet = createTileSet(); Toolbox toolbox = createToolbox(support); support.replayAll(); STKDataGroupBuilder builder = new STKDataGroupBuilder(toolbox); DataGroupInfo dataGroup = builder.createGroupAndType(tileSet, ourServer); assertEquals(ourServer + ourTileSetName, dataGroup.getId()); assertEquals(ourTileSetName, dataGroup.getDisplayName()); assertTrue(dataGroup.activationProperty().getListeners().get(0) instanceof STKDataGroupActivationListener); String description = dataGroup.getGroupDescription(); assertTrue(description.contains("I am description")); assertTrue(description.endsWith("source1, source2")); DataTypeInfo dataType = dataGroup.getMemberById(ourServer + ourTileSetName, false); assertEquals(ourServer + ourTileSetName, dataType.getTypeKey()); assertEquals(ourTileSetName, dataType.getDisplayName()); assertEquals(ourTileSetName, dataType.getTypeName()); assertEquals(ourServer, dataType.getSourcePrefix()); MapVisualizationInfo mapVisInfo = dataType.getMapVisualizationInfo(); assertTrue(mapVisInfo.getVisualizationType().isTerrainTileType()); assertEquals(2016, mapVisInfo.getTileRenderProperties().getZOrder()); support.verifyAll(); }
### Question: STKDataGroupController extends DataRegistryListenerAdapter<TileSet> { public void close() { myDataRegistry.removeChangeListener(this); myGroupController.removeDataGroupInfo(myRootGroup, this); } STKDataGroupController(Toolbox toolbox, String serverName, String serverUrl); void close(); @Override boolean isIdArrayNeeded(); @Override void valuesAdded(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSet> newValues, Object source); }### Answer: @Test public void testClose() { EasyMockSupport support = new EasyMockSupport(); List<DataGroupInfo> rootGroups = New.list(); DataRegistry dataRegistry = createDataRegistryForClose(support); DataGroupController groupController = createGroupControllerForClose(support, rootGroups); MantleToolbox mantleBox = createMantleToolbox(support, groupController); Toolbox toolbox = createToolbox(support, dataRegistry, mantleBox); support.replayAll(); STKDataGroupController controller = new STKDataGroupController(toolbox, ourServerName, ourServerUrl); assertEquals(ourServerName, rootGroups.get(0).getDisplayName()); assertFalse(controller.isIdArrayNeeded()); controller.close(); assertTrue(rootGroups.isEmpty()); support.verifyAll(); }
### Question: STKDataGroupController extends DataRegistryListenerAdapter<TileSet> { @Override public void valuesAdded(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSet> newValues, Object source) { String serverUrl = dataModelCategory.getSource(); for (TileSet tileSet : newValues) { DataGroupInfo dataGroup = myBuilder.createGroupAndType(tileSet, serverUrl); myRootGroup.addChild(dataGroup, this); } } STKDataGroupController(Toolbox toolbox, String serverName, String serverUrl); void close(); @Override boolean isIdArrayNeeded(); @Override void valuesAdded(DataModelCategory dataModelCategory, long[] ids, Iterable<? extends TileSet> newValues, Object source); }### Answer: @Test public void testValuesAddedDataModelCategoryLongArrayIterableOfQextendsTileSetObject() { EasyMockSupport support = new EasyMockSupport(); List<DataGroupInfo> rootGroups = New.list(); DataRegistry dataRegistry = createDataRegistry(support); DataGroupController groupController = createGroupController(support, rootGroups); MantleToolbox mantleBox = createMantleToolboxForAdd(support, groupController); Toolbox toolbox = createToolbox(support, dataRegistry, mantleBox); support.replayAll(); STKDataGroupController controller = new STKDataGroupController(toolbox, ourServerName, ourServerUrl); List<TileSet> tileSets = createTileSets(); controller.valuesAdded(new DataModelCategory(ourServerName, TileSet.class.getName(), TileSet.class.getName()), new long[] { 0, 1 }, tileSets, this); assertEquals(1, rootGroups.size()); DataGroupInfo rootGroup = rootGroups.get(0); assertTrue(rootGroup.isRootNode()); assertEquals(ourServerUrl, rootGroup.getId()); assertEquals(ourServerName, rootGroup.getDisplayName()); Collection<DataGroupInfo> dataGroups = rootGroup.getChildren(); assertEquals(ourTileSetNames.size(), dataGroups.size()); for (DataGroupInfo dataGroup : dataGroups) { assertTrue(ourTileSetNames.contains(dataGroup.getDisplayName())); } support.verifyAll(); }
### Question: STKDataGroupActivationListener extends AbstractActivationListener { @Override public void handleCommit(boolean active, DataGroupInfo dgi, PhasedTaskCanceller canceller) { super.handleCommit(active, dgi, canceller); if (active) { handleActivated(dgi); } else { handleDeactivated(dgi); } } STKDataGroupActivationListener(DataRegistry dataRegistry); @Override void handleCommit(boolean active, DataGroupInfo dgi, PhasedTaskCanceller canceller); }### Answer: @Test public void testHandleCommitActivated() { EasyMockSupport support = new EasyMockSupport(); DataGroupInfo dataGroup = createDataGroup(support); DataRegistry dataRegistry = support.createMock(DataRegistry.class); EasyMock.expect(dataRegistry.submitQuery(EasyMock.isA(SimpleQuery.class))).andAnswer(this::queryAnswer); support.replayAll(); STKDataGroupActivationListener listener = new STKDataGroupActivationListener(dataRegistry); listener.handleCommit(true, dataGroup, null); support.verifyAll(); } @Test public void testHandleCommitDeactivated() { EasyMockSupport support = new EasyMockSupport(); DataGroupInfo dataGroup = createDataGroup(support); DataRegistry dataRegistry = support.createMock(DataRegistry.class); EasyMock.expect(dataRegistry.removeModels( EasyMock.eq(new DataModelCategory(ourServerUrl, TileSetMetadata.class.getName(), ourLayerName)), EasyMock.eq(false))).andReturn(new long[] {}); support.replayAll(); STKDataGroupActivationListener listener = new STKDataGroupActivationListener(dataRegistry); listener.handleCommit(false, dataGroup, null); support.verifyAll(); }
### Question: AbstractProjection implements Projection { @Override public Vector3d getModelCenter() { return myModelCenter; } static boolean isTerrainLocked(); static void setTerrainLocked(boolean lock); static void toggleTerrainLocked(); @Override long getActivationTimestamp(); @Override long getCreationTimestamp(); @Override double getDistanceFromModelCenterM(GeographicPosition position); @Override double getElevationOnTerrainM(GeographicPosition position); @Override Vector3d getModelCenter(); @Override Matrix4d getModelViewAdjustment(); @Override Projection getSnapshot(); @Override Collection<GeographicBoundingBox> handleElevationChange(ElevationChangedEvent event); @Override Collection<GeographicBoundingBox> handleModelDensityChanged(int density); boolean isModelCenterLocked(); @Override boolean isOutsideModel(Vector3d modelCoordinates); @Override void setActivationTimestamp(); void setModelCenter(Vector3d modelCenter); void setModelCenterLocked(boolean modelCenterLocked); void setProjectionChangeListener(ProjectionChangeSupport.ProjectionChangeListener projectionChangeListener); void useElevationOrderManager(OrderManager elevationOrderManager); static final boolean HIGH_ACCURACY_ALLOWED; static final int HIGH_ACCURACY_MIN_MODEL_DISTANCE; static final int HIGH_ACCURACY_THRESHOLD; }### Answer: @Test public void testGetModelCenter() { assertEquals(Vector3d.ORIGIN, myTestObject.getModelCenter()); }
### Question: STKPlugin extends PluginAdapter { @SuppressWarnings("unused") @Override public void initialize(PluginLoaderData plugindata, Toolbox toolbox) { myTransformer = new STKLayerTransformer(toolbox.getDataRegistry(), MantleToolboxUtils.getMantleToolbox(toolbox).getDataGroupController(), toolbox.getEventManager()); myAttributionTransformer = new AttributionTransformer(toolbox.getDataRegistry(), toolbox.getMapManager()); ServerToolboxUtils.getServerToolbox(toolbox).getServerSourceControllerManager() .setPreferencesTopic(STKServerSourceController.class, STKPlugin.class); new EnvoyDebuggins(toolbox); } @Override Collection<? extends Transformer> getTransformers(); @SuppressWarnings("unused") @Override void initialize(PluginLoaderData plugindata, Toolbox toolbox); }### Answer: @Test public void testInitialize() { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = createToolbox(support); PluginLoaderData loaderData = new PluginLoaderData(); support.replayAll(); STKPlugin plugin = new STKPlugin(); plugin.initialize(loaderData, toolbox); support.verifyAll(); }
### Question: TileSetMetadataEnvoy extends AbstractEnvoy implements DataRegistryDataProvider { @Override public String getThreadPoolName() { return Constants.ENVOY_THREAD_POOL_NAME + myServerUrl; } TileSetMetadataEnvoy(Toolbox toolbox, String serverUrl); @Override Collection<? extends Satisfaction> getSatisfaction(DataModelCategory dataModelCategory, Collection<? extends IntervalPropertyValueSet> intervalSets); @Override String getThreadPoolName(); @Override void open(); @Override boolean providesDataFor(DataModelCategory category); @Override void query(DataModelCategory category, Collection<? extends Satisfaction> satisfactions, List<? extends PropertyMatcher<?>> parameters, List<? extends OrderSpecifier> orderSpecifiers, int limit, Collection<? extends PropertyDescriptor<?>> propertyDescriptors, CacheDepositReceiver queryReceiver); }### Answer: @Test public void testGetThreadPoolName() { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = support.createMock(Toolbox.class); support.replayAll(); TileSetMetadataEnvoy envoy = new TileSetMetadataEnvoy(toolbox, ourTestServer); assertEquals(Constants.ENVOY_THREAD_POOL_NAME + ourTestServer, envoy.getThreadPoolName()); support.verifyAll(); }
### Question: TileSetMetadataEnvoy extends AbstractEnvoy implements DataRegistryDataProvider { @Override public boolean providesDataFor(DataModelCategory category) { boolean isServer = category.getSource() == null || myServerUrl.equals(category.getSource()); return isServer && TileSetMetadata.class.getName().equals(category.getFamily()) && !StringUtils.isBlank(category.getCategory()); } TileSetMetadataEnvoy(Toolbox toolbox, String serverUrl); @Override Collection<? extends Satisfaction> getSatisfaction(DataModelCategory dataModelCategory, Collection<? extends IntervalPropertyValueSet> intervalSets); @Override String getThreadPoolName(); @Override void open(); @Override boolean providesDataFor(DataModelCategory category); @Override void query(DataModelCategory category, Collection<? extends Satisfaction> satisfactions, List<? extends PropertyMatcher<?>> parameters, List<? extends OrderSpecifier> orderSpecifiers, int limit, Collection<? extends PropertyDescriptor<?>> propertyDescriptors, CacheDepositReceiver queryReceiver); }### Answer: @Test public void testProvidesDataFor() { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = support.createMock(Toolbox.class); DataModelCategory provides = new DataModelCategory(null, TileSetMetadata.class.getName(), ourTestTileSet); DataModelCategory noProvidy = new DataModelCategory(null, TileSetMetadata.class.getName(), null); DataModelCategory noProvidyToo = new DataModelCategory(null, null, null); DataModelCategory providesServer = new DataModelCategory(ourTestServer, TileSetMetadata.class.getName(), ourTestTileSet); DataModelCategory noProvides = new DataModelCategory("http: ourTestTileSet); support.replayAll(); TileSetMetadataEnvoy envoy = new TileSetMetadataEnvoy(toolbox, ourTestServer); assertTrue(envoy.providesDataFor(provides)); assertFalse(envoy.providesDataFor(noProvidy)); assertFalse(envoy.providesDataFor(noProvidyToo)); assertTrue(envoy.providesDataFor(providesServer)); assertFalse(envoy.providesDataFor(noProvides)); support.verifyAll(); }
### Question: TileSetEnvoy extends AbstractEnvoy implements DataRegistryDataProvider { @Override public String getThreadPoolName() { return Constants.ENVOY_THREAD_POOL_NAME + myServerUrl; } TileSetEnvoy(Toolbox toolbox, DefaultValidatorSupport validatorSupport, String serverUrl); @Override Collection<? extends Satisfaction> getSatisfaction(DataModelCategory dataModelCategory, Collection<? extends IntervalPropertyValueSet> intervalSets); @Override String getThreadPoolName(); DefaultValidatorSupport getValidatorSupport(); @Override void open(); @Override boolean providesDataFor(DataModelCategory category); @Override void query(DataModelCategory category, Collection<? extends Satisfaction> satisfactions, List<? extends PropertyMatcher<?>> parameters, List<? extends OrderSpecifier> orderSpecifiers, int limit, Collection<? extends PropertyDescriptor<?>> propertyDescriptors, CacheDepositReceiver queryReceiver); }### Answer: @Test public void testGetThreadPoolName() { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = support.createMock(Toolbox.class); DefaultValidatorSupport validatorSupport = new DefaultValidatorSupport(null); support.replayAll(); TileSetEnvoy envoy = new TileSetEnvoy(toolbox, validatorSupport, ourTestServer); assertEquals(Constants.ENVOY_THREAD_POOL_NAME + ourTestServer, envoy.getThreadPoolName()); support.verifyAll(); }
### Question: TileSetEnvoy extends AbstractEnvoy implements DataRegistryDataProvider { @Override public void open() { try { query(new DataModelCategory(null, TileSet.class.getName(), null), New.collection(), New.list(), New.list(), -1, New.collection(), new CacheDepositReceiver() { @Override public <T> long[] receive(CacheDeposit<T> deposit) { myValidatorSupport.setValidationResult(ValidationStatus.VALID, null); return getDataRegistry().addModels(deposit); } }); } catch (InterruptedException | QueryException e) { myValidatorSupport.setValidationResult(ValidationStatus.ERROR, e.getMessage()); LOGGER.error(e, e); } } TileSetEnvoy(Toolbox toolbox, DefaultValidatorSupport validatorSupport, String serverUrl); @Override Collection<? extends Satisfaction> getSatisfaction(DataModelCategory dataModelCategory, Collection<? extends IntervalPropertyValueSet> intervalSets); @Override String getThreadPoolName(); DefaultValidatorSupport getValidatorSupport(); @Override void open(); @Override boolean providesDataFor(DataModelCategory category); @Override void query(DataModelCategory category, Collection<? extends Satisfaction> satisfactions, List<? extends PropertyMatcher<?>> parameters, List<? extends OrderSpecifier> orderSpecifiers, int limit, Collection<? extends PropertyDescriptor<?>> propertyDescriptors, CacheDepositReceiver queryReceiver); }### Answer: @Test public void testOpen() throws IOException, URISyntaxException { EasyMockSupport support = new EasyMockSupport(); DataRegistry dataRegistry = createDataRegistry(support); Toolbox toolbox = createToolbox(support, dataRegistry); support.replayAll(); DefaultValidatorSupport validatorSupport = new DefaultValidatorSupport(null); TileSetEnvoy envoy = new TileSetEnvoy(toolbox, validatorSupport, ourTestServer); envoy.open(); assertEquals(ValidationStatus.VALID, validatorSupport.getValidationStatus()); support.verifyAll(); }
### Question: TileSetEnvoy extends AbstractEnvoy implements DataRegistryDataProvider { @Override public boolean providesDataFor(DataModelCategory category) { boolean isServer = category.getSource() == null || myServerUrl.equals(category.getSource()); return isServer && TileSet.class.getName().equals(category.getFamily()); } TileSetEnvoy(Toolbox toolbox, DefaultValidatorSupport validatorSupport, String serverUrl); @Override Collection<? extends Satisfaction> getSatisfaction(DataModelCategory dataModelCategory, Collection<? extends IntervalPropertyValueSet> intervalSets); @Override String getThreadPoolName(); DefaultValidatorSupport getValidatorSupport(); @Override void open(); @Override boolean providesDataFor(DataModelCategory category); @Override void query(DataModelCategory category, Collection<? extends Satisfaction> satisfactions, List<? extends PropertyMatcher<?>> parameters, List<? extends OrderSpecifier> orderSpecifiers, int limit, Collection<? extends PropertyDescriptor<?>> propertyDescriptors, CacheDepositReceiver queryReceiver); }### Answer: @Test public void testProvidesDataFor() { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = support.createMock(Toolbox.class); DefaultValidatorSupport validatorSupport = new DefaultValidatorSupport(null); support.replayAll(); TileSetEnvoy envoy = new TileSetEnvoy(toolbox, validatorSupport, ourTestServer); DataModelCategory category = new DataModelCategory(null, TileSet.class.getName(), null); DataModelCategory noProvidy = new DataModelCategory(null, null, null); DataModelCategory provides = new DataModelCategory(ourTestServer, TileSet.class.getName(), null); DataModelCategory noProvides = new DataModelCategory("http: assertTrue(envoy.providesDataFor(category)); assertFalse(envoy.providesDataFor(noProvidy)); assertTrue(envoy.providesDataFor(provides)); assertFalse(envoy.providesDataFor(noProvides)); support.verifyAll(); }
### Question: QuantizedMeshEnvoy extends AbstractEnvoy implements DataRegistryDataProvider { @Override public String getThreadPoolName() { return Constants.ENVOY_THREAD_POOL_NAME + myServerUrl; } QuantizedMeshEnvoy(Toolbox toolbox, String serverUrl); @Override Collection<? extends Satisfaction> getSatisfaction(DataModelCategory dataModelCategory, Collection<? extends IntervalPropertyValueSet> intervalSets); @Override String getThreadPoolName(); @Override void open(); @Override boolean providesDataFor(DataModelCategory category); @Override void query(DataModelCategory category, Collection<? extends Satisfaction> satisfactions, List<? extends PropertyMatcher<?>> parameters, List<? extends OrderSpecifier> orderSpecifiers, int limit, Collection<? extends PropertyDescriptor<?>> propertyDescriptors, CacheDepositReceiver queryReceiver); }### Answer: @Test public void testGetThreadPoolName() { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = support.createMock(Toolbox.class); support.replayAll(); QuantizedMeshEnvoy envoy = new QuantizedMeshEnvoy(toolbox, ourTestServer); assertEquals(Constants.ENVOY_THREAD_POOL_NAME + ourTestServer, envoy.getThreadPoolName()); support.verifyAll(); }
### Question: AbstractProjection implements Projection { @Override public Matrix4d getModelViewAdjustment() { return myModelViewAdjustment; } static boolean isTerrainLocked(); static void setTerrainLocked(boolean lock); static void toggleTerrainLocked(); @Override long getActivationTimestamp(); @Override long getCreationTimestamp(); @Override double getDistanceFromModelCenterM(GeographicPosition position); @Override double getElevationOnTerrainM(GeographicPosition position); @Override Vector3d getModelCenter(); @Override Matrix4d getModelViewAdjustment(); @Override Projection getSnapshot(); @Override Collection<GeographicBoundingBox> handleElevationChange(ElevationChangedEvent event); @Override Collection<GeographicBoundingBox> handleModelDensityChanged(int density); boolean isModelCenterLocked(); @Override boolean isOutsideModel(Vector3d modelCoordinates); @Override void setActivationTimestamp(); void setModelCenter(Vector3d modelCenter); void setModelCenterLocked(boolean modelCenterLocked); void setProjectionChangeListener(ProjectionChangeSupport.ProjectionChangeListener projectionChangeListener); void useElevationOrderManager(OrderManager elevationOrderManager); static final boolean HIGH_ACCURACY_ALLOWED; static final int HIGH_ACCURACY_MIN_MODEL_DISTANCE; static final int HIGH_ACCURACY_THRESHOLD; }### Answer: @Test public void testGetModelViewAdjustment() { assertNull(myTestObject.getModelViewAdjustment()); }
### Question: QuantizedMeshEnvoy extends AbstractEnvoy implements DataRegistryDataProvider { @Override public boolean providesDataFor(DataModelCategory category) { boolean isServer = category.getSource() == null || myServerUrl.equals(category.getSource()); return isServer && QuantizedMesh.class.getName().equals(category.getFamily()) && !StringUtils.isBlank(category.getCategory()); } QuantizedMeshEnvoy(Toolbox toolbox, String serverUrl); @Override Collection<? extends Satisfaction> getSatisfaction(DataModelCategory dataModelCategory, Collection<? extends IntervalPropertyValueSet> intervalSets); @Override String getThreadPoolName(); @Override void open(); @Override boolean providesDataFor(DataModelCategory category); @Override void query(DataModelCategory category, Collection<? extends Satisfaction> satisfactions, List<? extends PropertyMatcher<?>> parameters, List<? extends OrderSpecifier> orderSpecifiers, int limit, Collection<? extends PropertyDescriptor<?>> propertyDescriptors, CacheDepositReceiver queryReceiver); }### Answer: @Test public void testProvidesDataFor() { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = support.createMock(Toolbox.class); support.replayAll(); DataModelCategory provides = new DataModelCategory(null, QuantizedMesh.class.getName(), ourTestTileSet); DataModelCategory providesToo = new DataModelCategory(ourTestServer, QuantizedMesh.class.getName(), ourTestTileSet); DataModelCategory noProvidy = new DataModelCategory(null, QuantizedMesh.class.getName(), null); DataModelCategory noProvidyToo = new DataModelCategory("http: ourTestTileSet); DataModelCategory noProvidyAsWell = new DataModelCategory(null, null, null); QuantizedMeshEnvoy envoy = new QuantizedMeshEnvoy(toolbox, ourTestServer); assertTrue(envoy.providesDataFor(provides)); assertTrue(envoy.providesDataFor(providesToo)); assertFalse(envoy.providesDataFor(noProvidy)); assertFalse(envoy.providesDataFor(noProvidyToo)); assertFalse(envoy.providesDataFor(noProvidyAsWell)); support.verifyAll(); }
### Question: STKValidatorSupport extends DefaultValidatorSupport { @Override public void setValidationResult(ValidationStatus successful, String message) { if (successful == ValidationStatus.ERROR) { Notify.error(message, Method.TOAST); } else if (successful == ValidationStatus.WARNING) { Notify.warn(message, Method.TOAST); } boolean success = successful != ValidationStatus.ERROR; if (!success) { mySource.setLoadError(true, this); mySourceController.deactivateSource(mySource); } } STKValidatorSupport(IDataSource server, STKServerController controller); @Override void setValidationResult(ValidationStatus successful, String message); }### Answer: @Test public void testSetValidationResult() { EasyMockSupport support = new EasyMockSupport(); IDataSource server = support.createMock(IDataSource.class); STKServerController serverController = support.createMock(STKServerController.class); support.replayAll(); STKValidatorSupport validatorSupport = new STKValidatorSupport(server, serverController); validatorSupport.setValidationResult(ValidationStatus.VALID, null); support.verifyAll(); } @Test public void testSetValidationResultError() { EasyMockSupport support = new EasyMockSupport(); IDataSource server = createServer(support); STKServerController serverController = createController(support, server); List<UserMessageEvent> events = New.list(); createToolbox(support, events); support.replayAll(); STKValidatorSupport validatorSupport = new STKValidatorSupport(server, serverController); validatorSupport.setValidationResult(ValidationStatus.ERROR, "Error Message"); assertEquals(1, events.size()); UserMessageEvent event = events.get(0); assertEquals(Type.ERROR, event.getType()); assertEquals("Error Message", event.getMessage()); assertFalse(event.isMakeVisible()); assertTrue(event.isShowToast()); support.verifyAll(); } @Test public void testSetValidationResultWarning() { EasyMockSupport support = new EasyMockSupport(); IDataSource server = support.createMock(IDataSource.class); STKServerController serverController = support.createMock(STKServerController.class); List<UserMessageEvent> events = New.list(); createToolbox(support, events); support.replayAll(); STKValidatorSupport validatorSupport = new STKValidatorSupport(server, serverController); validatorSupport.setValidationResult(ValidationStatus.WARNING, "Warning Message"); assertEquals(1, events.size()); UserMessageEvent event = events.get(0); assertEquals(Type.WARNING, event.getType()); assertEquals("Warning Message", event.getMessage()); assertFalse(event.isMakeVisible()); assertTrue(event.isShowToast()); support.verifyAll(); }
### Question: WFSTransformer extends DefaultTransformer { public void transform(long[] ids, TimeSpan timeSpan, GeographicPosition[] pos, Color[] color, int zOrder, Collection<? super Geometry> geometries) { PointGeometry.Builder<GeographicPosition> pointBuilder = new PointGeometry.Builder<GeographicPosition>(); final float size = 3f; Constraints constraints = new Constraints(TimeConstraint.getTimeConstraint(timeSpan)); for (int index = 0; index < ids.length; ++index) { pointBuilder.setPosition(pos[index]); pointBuilder.setDataModelId(ids[index]); PointRenderProperties props = new DefaultPointRenderProperties(zOrder, true, true, false); props.setSize(size); props.setColor(color[index]); geometries.add(new PointGeometry(pointBuilder, props, constraints)); } } WFSTransformer(Toolbox toolbox); protected WFSTransformer(DataRegistry dataRegistry, EventManager eventManager); @Override void close(); void transform(long[] ids, TimeSpan timeSpan, GeographicPosition[] pos, Color[] color, int zOrder, Collection<? super Geometry> geometries); }### Answer: @Test public void testTransform() { final double lat1 = 24.4f; final double lon1 = 10.1f; final double lat2 = 25.2f; final double lon2 = 11.0f; GeographicPosition[] positions = { new GeographicPosition(LatLonAlt.createFromDegrees(lat1, lon1)), new GeographicPosition(LatLonAlt.createFromDegrees(lat2, lon2)), }; Color[] colors = { Color.BLUE, Color.green, }; WFSTransformer transformer = new WFSTransformer(getTestToolbox()); Collection<Geometry> geometries = new ArrayList<>(); int zOrder = 0; transformer.transform(new long[] { 1L, 2L }, TimeSpan.ZERO, positions, colors, zOrder, geometries); assertEquals(2, geometries.size()); boolean found1 = false; boolean found2 = false; for (Geometry geom : geometries) { PointGeometry ptGeom = (PointGeometry)geom; LatLonAlt lla = ((GeographicPosition)ptGeom.getPosition()).getLatLonAlt(); if (lla.getLatD() == lat1 && lla.getLonD() == lon1 && ptGeom.getRenderProperties().getColor().equals(Color.BLUE)) { found1 = true; } else if (lla.getLatD() == lat2 && lla.getLonD() == lon2 && ptGeom.getRenderProperties().getColor().equals(Color.GREEN)) { found2 = true; } } assertTrue(found1 && found2); }
### Question: AbstractProjection implements Projection { @Override public Projection getSnapshot() { return this; } static boolean isTerrainLocked(); static void setTerrainLocked(boolean lock); static void toggleTerrainLocked(); @Override long getActivationTimestamp(); @Override long getCreationTimestamp(); @Override double getDistanceFromModelCenterM(GeographicPosition position); @Override double getElevationOnTerrainM(GeographicPosition position); @Override Vector3d getModelCenter(); @Override Matrix4d getModelViewAdjustment(); @Override Projection getSnapshot(); @Override Collection<GeographicBoundingBox> handleElevationChange(ElevationChangedEvent event); @Override Collection<GeographicBoundingBox> handleModelDensityChanged(int density); boolean isModelCenterLocked(); @Override boolean isOutsideModel(Vector3d modelCoordinates); @Override void setActivationTimestamp(); void setModelCenter(Vector3d modelCenter); void setModelCenterLocked(boolean modelCenterLocked); void setProjectionChangeListener(ProjectionChangeSupport.ProjectionChangeListener projectionChangeListener); void useElevationOrderManager(OrderManager elevationOrderManager); static final boolean HIGH_ACCURACY_ALLOWED; static final int HIGH_ACCURACY_MIN_MODEL_DISTANCE; static final int HIGH_ACCURACY_THRESHOLD; }### Answer: @Test public void testGetSnapshot() { assertEquals(myTestObject, myTestObject.getSnapshot()); }
### Question: WFSGovernor extends TimeSpanGovernor implements QueryTrackerListener { @Override public void clearData() { try { myDataClearer.removeAll(); super.clearData(); } catch (DataElementLookupException e) { LOGGER.error(e, e); } } WFSGovernor(MantleToolbox mantle, DataRegistry dataRegistry, DataTypeInfo wfsLayer, QueryRegion region); @Override void clearData(); @Override void clearData(Collection<? extends TimeSpan> spans); @Override void fractionCompleteChanged(QueryTracker tracker, float fractionComplete); @Override void statusChanged(QueryTracker tracker, QueryStatus status); }### Answer: @Test public void testClearData() throws DataElementLookupException { EasyMockSupport support = new EasyMockSupport(); TimeSpan span1 = TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis() - 5000); TimeSpan span2 = TimeSpan.get(System.currentTimeMillis() - 3000, System.currentTimeMillis()); List<Long> allIds = New.list(Long.valueOf(0), Long.valueOf(1), Long.valueOf(2), Long.valueOf(3)); DataTypeInfo layer = createLayerClear(support); List<MapGeometrySupport> geometrySupports = New.list(); List<DataElement> elements = createElements(span1, span2, geometrySupports); DataElementCache cache = createCache(support, layer, allIds, null); DataElementLookupUtils lookupUtils = createLookup(support, layer, allIds, elements); DataTypeController typeController = createTypeController(support, layer, new long[] { 1, 3 }); MapGeometrySupportConverterRegistry converter = createConverter(support, geometrySupports); MantleToolbox mantle = createMantle(support, cache, lookupUtils, typeController, converter); QueryRegion queryArea = createRegion(support); DataRegistry registry = support.createMock(DataRegistry.class); support.replayAll(); WFSGovernor governor = new WFSGovernor(mantle, registry, layer, queryArea); governor.clearData(); support.verifyAll(); } @Test public void testClearDataSpan() throws DataElementLookupException { EasyMockSupport support = new EasyMockSupport(); TimeSpan span1 = TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis() - 5000); TimeSpan span2 = TimeSpan.get(System.currentTimeMillis() - 3000, System.currentTimeMillis()); List<Long> allIds = New.list(Long.valueOf(0), Long.valueOf(1), Long.valueOf(2), Long.valueOf(3)); DataTypeInfo layer = createLayerClear(support); List<MapGeometrySupport> geometrySupports = New.list(); List<DataElement> elements = createElements(span1, span2, geometrySupports); DataElementCache cache = createCache(support, layer, allIds, New.list(span1, span1, span2, span2)); DataElementLookupUtils lookupUtils = createLookup(support, layer, New.list(Long.valueOf(2), Long.valueOf(3)), New.list(elements.get(2), elements.get(3))); DataTypeController typeController = createTypeController(support, layer, new long[] { 3 }); MapGeometrySupportConverterRegistry converter = createConverter(support, New.list(geometrySupports.get(2), geometrySupports.get(3))); MantleToolbox mantle = createMantle(support, cache, lookupUtils, typeController, converter); QueryRegion queryArea = createRegion(support); DataRegistry registry = support.createMock(DataRegistry.class); support.replayAll(); WFSGovernor governor = new WFSGovernor(mantle, registry, layer, queryArea); governor.clearData(New.list(span2)); support.verifyAll(); }
### Question: WFSGovernor extends TimeSpanGovernor implements QueryTrackerListener { @Override protected boolean performRequest(List<? extends TimeSpan> spans) { DataModelCategory category = new DataModelCategory(null, MapDataElement.class.getName(), myWfsLayer.getTypeKey()); GeneralIntervalPropertyMatcher<DataFilter> filter = null; if (myRegion.getTypeKeyToFilterMap().get(myWfsLayer.getTypeKey()) != null) { filter = new GeneralIntervalPropertyMatcher<>(WFSDataRegistryHelper.DATA_FILTER_PROPERTY_DESCRIPTOR, myRegion.getTypeKeyToFilterMap().get(myWfsLayer.getTypeKey())); } for (Polygon poly : JTSCoreGeometryUtilities.convertToJTSPolygonsAndSplit(myRegion.getGeometries())) { GeometryMatcher geometry = new GeometryMatcher(GeometryAccessor.GEOMETRY_PROPERTY_NAME, GeometryMatcher.OperatorType.INTERSECTS, poly); for (TimeSpan span : spans) { TimeSpan toUse = span; if (span.equals(ourAllTime)) { toUse = TimeSpan.TIMELESS; } TimeSpanMatcher time = new TimeSpanMatcher(TimeSpanAccessor.TIME_PROPERTY_NAME, toUse); List<PropertyMatcher<?>> matchers = New.list(geometry, time); if (filter != null) { matchers.add(filter); } DefaultQuery query = new DefaultQuery(category, Collections.emptyList(), matchers, null); QueryTracker tracker = myDataRegistry.submitQuery(query); tracker.addListener(this); } } return true; } WFSGovernor(MantleToolbox mantle, DataRegistry dataRegistry, DataTypeInfo wfsLayer, QueryRegion region); @Override void clearData(); @Override void clearData(Collection<? extends TimeSpan> spans); @Override void fractionCompleteChanged(QueryTracker tracker, float fractionComplete); @Override void statusChanged(QueryTracker tracker, QueryStatus status); }### Answer: @Test public void testQueryRegion() { EasyMockSupport support = new EasyMockSupport(); DataTypeInfo layer = createLayer(support); TimeSpan span = TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis()); DataRegistry registry = createRegistry(support, null, span); QueryRegion region = createRegion(support, null); MantleToolbox mantle = support.createNiceMock(MantleToolbox.class); support.replayAll(); WFSGovernor governor = new WFSGovernor(mantle, registry, layer, region); assertTrue(governor.performRequest(New.list(span))); support.verifyAll(); } @Test public void testQueryRegionFilter() { EasyMockSupport support = new EasyMockSupport(); DataFilter filter = createFilter(support); DataTypeInfo layer = createLayer(support); TimeSpan span = TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis()); DataRegistry registry = createRegistry(support, filter, span); QueryRegion region = createRegion(support, filter); MantleToolbox mantle = support.createNiceMock(MantleToolbox.class); support.replayAll(); WFSGovernor governor = new WFSGovernor(mantle, registry, layer, region); assertTrue(governor.performRequest(New.list(span))); support.verifyAll(); }
### Question: WFSDataClearer { public void removeAll() throws DataElementLookupException { List<Long> elementIds = myCache.getElementIdsForTypeAsList(myLayer); removeIds(elementIds); } WFSDataClearer(MantleToolbox mantleToolbox, DataTypeInfo layer, QueryRegion queryArea); void removeAll(); void removeFeatures(TimeSpan span); }### Answer: @Test public void testRemoveAll() throws DataElementLookupException { EasyMockSupport support = new EasyMockSupport(); TimeSpan span1 = TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis() - 5000); TimeSpan span2 = TimeSpan.get(System.currentTimeMillis() - 3000, System.currentTimeMillis()); List<Long> allIds = New.list(Long.valueOf(0), Long.valueOf(1), Long.valueOf(2), Long.valueOf(3)); DataTypeInfo layer = createLayer(support); List<MapGeometrySupport> geometrySupports = New.list(); List<DataElement> elements = createElements(span1, span2, geometrySupports); DataElementCache cache = createCache(support, layer, allIds, null); DataElementLookupUtils lookupUtils = createLookup(support, layer, allIds, elements); DataTypeController typeController = createTypeController(support, layer, new long[] { 1, 3 }); MapGeometrySupportConverterRegistry converter = createConverter(support, geometrySupports); MantleToolbox mantle = createMantle(support, cache, lookupUtils, typeController, converter); QueryRegion queryArea = createRegion(support); support.replayAll(); WFSDataClearer clearer = new WFSDataClearer(mantle, layer, queryArea); clearer.removeAll(); support.verifyAll(); }
### Question: WFSDataClearer { public void removeFeatures(TimeSpan span) throws DataElementLookupException { List<Long> idsWithinTime = idsWithinTime(span); removeIds(idsWithinTime); } WFSDataClearer(MantleToolbox mantleToolbox, DataTypeInfo layer, QueryRegion queryArea); void removeAll(); void removeFeatures(TimeSpan span); }### Answer: @Test public void testRemoveFeatures() throws DataElementLookupException { EasyMockSupport support = new EasyMockSupport(); TimeSpan span1 = TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis() - 5000); TimeSpan span2 = TimeSpan.get(System.currentTimeMillis() - 3000, System.currentTimeMillis()); List<Long> allIds = New.list(Long.valueOf(0), Long.valueOf(1), Long.valueOf(2), Long.valueOf(3)); DataTypeInfo layer = createLayer(support); List<MapGeometrySupport> geometrySupports = New.list(); List<DataElement> elements = createElements(span1, span2, geometrySupports); DataElementCache cache = createCache(support, layer, allIds, New.list(span1, span1, span2, span2)); DataElementLookupUtils lookupUtils = createLookup(support, layer, New.list(Long.valueOf(2), Long.valueOf(3)), New.list(elements.get(2), elements.get(3))); DataTypeController typeController = createTypeController(support, layer, new long[] { 3 }); MapGeometrySupportConverterRegistry converter = createConverter(support, New.list(geometrySupports.get(2), geometrySupports.get(3))); MantleToolbox mantle = createMantle(support, cache, lookupUtils, typeController, converter); QueryRegion queryArea = createRegion(support); support.replayAll(); WFSDataClearer clearer = new WFSDataClearer(mantle, layer, queryArea); clearer.removeFeatures(span2); support.verifyAll(); }
### Question: WFSQueryController implements QueryRegionListener, EventListener<ActiveDataGroupsChangedEvent>, ListDataListener<TimeSpan> { @Override public void allQueriesRemoved(boolean animationPlanCancelled) { myGovernorManager.clearData(new Pair<>(null, null)); } WFSQueryController(Toolbox toolbox); @Override void allQueriesRemoved(boolean animationPlanCancelled); void close(); @Override void elementsAdded(ListDataEvent<TimeSpan> e); @Override void elementsChanged(ListDataEvent<TimeSpan> e); @Override void elementsRemoved(ListDataEvent<TimeSpan> e); @Override void notify(ActiveDataGroupsChangedEvent event); @Override void queryRegionAdded(QueryRegion region); @Override void queryRegionRemoved(QueryRegion region); }### Answer: @Test public void testAllQueriesRemoved() throws InterruptedException, DataElementLookupException { EasyMockSupport support = new EasyMockSupport(); EventManager eventManager = createEventManager(support); TimeManager timeManager = createTimeManager(support); TimeSpan loadSpan = TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis()); CountDownLatch latch = new CountDownLatch(1); DataRegistry dataRegistry = createRegistry(support, New.list(loadSpan), New.list(latch)); QueryRegionManager queryManager = createRegionManager(support); List<DataTypeInfo> dataTypes = createTypes(support, TimeSpan.get(1000, System.currentTimeMillis())); DataTypeInfo wfsType = dataTypes.get(dataTypes.size() - 1); DataTypeController typeController = createTypeControllerRemove(support, dataTypes, wfsType, new long[] { 0, 1 }); List<Long> allIds = New.list(Long.valueOf(0), Long.valueOf(1)); DataElementCache cache = createCache(support, wfsType, allIds, null); List<MapGeometrySupport> geometrySupports = New.list(); List<DataElement> elements = createElements(loadSpan, geometrySupports); DataElementLookupUtils lookupUtils = createLookup(support, wfsType, allIds, elements); MapGeometrySupportConverterRegistry converter = createConverter(support, geometrySupports); MantleToolbox mantle = createMantle(support, queryManager, typeController, cache, lookupUtils, converter); Toolbox toolbox = createToolbox(support, eventManager, timeManager, dataRegistry, mantle); QueryRegion region = createRegion(support); support.replayAll(); timeManager.getLoadTimeSpans().add(loadSpan); WFSQueryController controller = new WFSQueryController(toolbox); myRegionListener.queryRegionAdded(region); assertTrue(latch.await(5, TimeUnit.SECONDS)); myRegionListener.allQueriesRemoved(false); assertTrue(controller.getGovernorManager().findGovernors(p -> true).isEmpty()); controller.close(); assertNull(myEventListener); assertNull(myRegionListener); support.verifyAll(); }
### Question: WFSQueryController implements QueryRegionListener, EventListener<ActiveDataGroupsChangedEvent>, ListDataListener<TimeSpan> { @Override public void elementsAdded(ListDataEvent<TimeSpan> e) { myGovernorManager.requestData(new Pair<>(null, null), e.getChangedElements()); } WFSQueryController(Toolbox toolbox); @Override void allQueriesRemoved(boolean animationPlanCancelled); void close(); @Override void elementsAdded(ListDataEvent<TimeSpan> e); @Override void elementsChanged(ListDataEvent<TimeSpan> e); @Override void elementsRemoved(ListDataEvent<TimeSpan> e); @Override void notify(ActiveDataGroupsChangedEvent event); @Override void queryRegionAdded(QueryRegion region); @Override void queryRegionRemoved(QueryRegion region); }### Answer: @Test public void testElementsAdded() throws DataElementLookupException, InterruptedException { EasyMockSupport support = new EasyMockSupport(); EventManager eventManager = createEventManager(support); TimeManager timeManager = createTimeManager(support); TimeSpan loadSpan = TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis()); CountDownLatch latch = new CountDownLatch(1); TimeSpan loadSpan2 = TimeSpan.get(System.currentTimeMillis() - 20000, System.currentTimeMillis() - 15000); CountDownLatch latch2 = new CountDownLatch(1); DataRegistry dataRegistry = createRegistry(support, New.list(loadSpan, loadSpan2), New.list(latch, latch2)); QueryRegionManager queryManager = createRegionManager(support); List<DataTypeInfo> dataTypes = createTypes(support, TimeSpan.get(1000, System.currentTimeMillis())); DataTypeInfo wfsType = dataTypes.get(dataTypes.size() - 1); DataTypeController typeController = createTypeControllerRemove(support, dataTypes, wfsType, new long[] { 0, 1 }); List<Long> allIds = New.list(Long.valueOf(0), Long.valueOf(1)); DataElementCache cache = createCache(support, wfsType, allIds, null); List<MapGeometrySupport> geometrySupports = New.list(); List<DataElement> elements = createElements(loadSpan, geometrySupports); DataElementLookupUtils lookupUtils = createLookup(support, wfsType, allIds, elements); MapGeometrySupportConverterRegistry converter = createConverter(support, geometrySupports); MantleToolbox mantle = createMantle(support, queryManager, typeController, cache, lookupUtils, converter); Toolbox toolbox = createToolbox(support, eventManager, timeManager, dataRegistry, mantle); QueryRegion region = createRegion(support); support.replayAll(); timeManager.getLoadTimeSpans().add(loadSpan); WFSQueryController controller = new WFSQueryController(toolbox); myRegionListener.queryRegionAdded(region); assertTrue(latch.await(5, TimeUnit.SECONDS)); timeManager.getLoadTimeSpans().add(loadSpan2); assertTrue(latch2.await(5, TimeUnit.SECONDS)); controller.close(); assertNull(myEventListener); assertNull(myRegionListener); support.verifyAll(); }
### Question: WFSQueryController implements QueryRegionListener, EventListener<ActiveDataGroupsChangedEvent>, ListDataListener<TimeSpan> { @Override public void elementsRemoved(ListDataEvent<TimeSpan> e) { myGovernorManager.clearData(new Pair<>(null, null), e.getChangedElements()); } WFSQueryController(Toolbox toolbox); @Override void allQueriesRemoved(boolean animationPlanCancelled); void close(); @Override void elementsAdded(ListDataEvent<TimeSpan> e); @Override void elementsChanged(ListDataEvent<TimeSpan> e); @Override void elementsRemoved(ListDataEvent<TimeSpan> e); @Override void notify(ActiveDataGroupsChangedEvent event); @Override void queryRegionAdded(QueryRegion region); @Override void queryRegionRemoved(QueryRegion region); }### Answer: @Test public void testElementsRemoved() throws InterruptedException, DataElementLookupException { EasyMockSupport support = new EasyMockSupport(); EventManager eventManager = createEventManager(support); TimeManager timeManager = createTimeManager(support); TimeSpan loadSpan = TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis()); CountDownLatch latch = new CountDownLatch(1); DataRegistry dataRegistry = createRegistry(support, New.list(loadSpan), New.list(latch)); QueryRegionManager queryManager = createRegionManager(support); List<DataTypeInfo> dataTypes = createTypes(support, TimeSpan.get(1000, System.currentTimeMillis())); DataTypeInfo wfsType = dataTypes.get(dataTypes.size() - 1); DataTypeController typeController = createTypeControllerRemove(support, dataTypes, wfsType, new long[] { 0, 1 }); EasyMock.expectLastCall().times(2); List<Long> allIds = New.list(Long.valueOf(0), Long.valueOf(1)); DataElementCache cache = createCache(support, wfsType, allIds, New.list(loadSpan, loadSpan)); EasyMock.expect(cache.getElementIdsForTypeAsList(wfsType)).andReturn(allIds); List<MapGeometrySupport> geometrySupports = New.list(); List<DataElement> elements = createElements(loadSpan, geometrySupports); DataElementLookupUtils lookupUtils = createLookup(support, wfsType, allIds, elements); EasyMock.expectLastCall().times(2); List<MapGeometrySupport> allSupports = New.list(); allSupports.addAll(geometrySupports); allSupports.addAll(geometrySupports); MapGeometrySupportConverterRegistry converter = createConverter(support, allSupports); MantleToolbox mantle = createMantle(support, queryManager, typeController, cache, lookupUtils, converter); Toolbox toolbox = createToolbox(support, eventManager, timeManager, dataRegistry, mantle); QueryRegion region = createRegion(support); support.replayAll(); timeManager.getLoadTimeSpans().add(loadSpan); WFSQueryController controller = new WFSQueryController(toolbox); myRegionListener.queryRegionAdded(region); assertTrue(latch.await(5, TimeUnit.SECONDS)); timeManager.getLoadTimeSpans().remove(0); controller.close(); assertNull(myEventListener); assertNull(myRegionListener); support.verifyAll(); }
### Question: WFSQueryController implements QueryRegionListener, EventListener<ActiveDataGroupsChangedEvent>, ListDataListener<TimeSpan> { @Override public void queryRegionAdded(QueryRegion region) { Collection<WFSDataType> wfsLayers = CollectionUtilities.filterDowncast(myTypeController.getDataTypeInfo(), WFSDataType.class); for (DataTypeInfo wfsLayer : wfsLayers) { if (wfsLayer.isVisible()) { Collection<? extends TimeSpan> timeSpans = myTimeManager.getLoadTimeSpans(); if (wfsLayer.getTimeExtents() == null || wfsLayer.getTimeExtents().getExtent().isTimeless()) { timeSpans = New.list(TimeSpan.TIMELESS); } myGovernorManager.requestData(new Pair<DataTypeInfo, QueryRegion>(wfsLayer, region), timeSpans); } } } WFSQueryController(Toolbox toolbox); @Override void allQueriesRemoved(boolean animationPlanCancelled); void close(); @Override void elementsAdded(ListDataEvent<TimeSpan> e); @Override void elementsChanged(ListDataEvent<TimeSpan> e); @Override void elementsRemoved(ListDataEvent<TimeSpan> e); @Override void notify(ActiveDataGroupsChangedEvent event); @Override void queryRegionAdded(QueryRegion region); @Override void queryRegionRemoved(QueryRegion region); }### Answer: @Test public void testQueryRegionAdded() throws DataElementLookupException, InterruptedException { EasyMockSupport support = new EasyMockSupport(); EventManager eventManager = createEventManager(support); TimeManager timeManager = createTimeManager(support); TimeSpan loadSpan = TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis()); CountDownLatch latch = new CountDownLatch(1); DataRegistry dataRegistry = createRegistry(support, New.list(loadSpan), New.list(latch)); QueryRegionManager queryManager = createRegionManager(support); List<DataTypeInfo> dataTypes = createTypes(support, TimeSpan.get(1000, System.currentTimeMillis())); DataTypeInfo wfsType = dataTypes.get(dataTypes.size() - 1); DataTypeController typeController = createTypeControllerRemove(support, dataTypes, wfsType, new long[] { 0, 1 }); List<Long> allIds = New.list(Long.valueOf(0), Long.valueOf(1)); DataElementCache cache = createCache(support, wfsType, allIds, null); List<MapGeometrySupport> geometrySupports = New.list(); List<DataElement> elements = createElements(loadSpan, geometrySupports); DataElementLookupUtils lookupUtils = createLookup(support, wfsType, allIds, elements); MapGeometrySupportConverterRegistry converter = createConverter(support, geometrySupports); MantleToolbox mantle = createMantle(support, queryManager, typeController, cache, lookupUtils, converter); Toolbox toolbox = createToolbox(support, eventManager, timeManager, dataRegistry, mantle); QueryRegion region = createRegion(support); support.replayAll(); timeManager.getLoadTimeSpans().add(loadSpan); WFSQueryController controller = new WFSQueryController(toolbox); myRegionListener.queryRegionAdded(region); assertTrue(latch.await(5, TimeUnit.SECONDS)); controller.close(); assertNull(myEventListener); assertNull(myRegionListener); support.verifyAll(); }
### Question: AbstractProjection implements Projection { @Override public Collection<GeographicBoundingBox> handleElevationChange(ElevationChangedEvent event) { return null; } static boolean isTerrainLocked(); static void setTerrainLocked(boolean lock); static void toggleTerrainLocked(); @Override long getActivationTimestamp(); @Override long getCreationTimestamp(); @Override double getDistanceFromModelCenterM(GeographicPosition position); @Override double getElevationOnTerrainM(GeographicPosition position); @Override Vector3d getModelCenter(); @Override Matrix4d getModelViewAdjustment(); @Override Projection getSnapshot(); @Override Collection<GeographicBoundingBox> handleElevationChange(ElevationChangedEvent event); @Override Collection<GeographicBoundingBox> handleModelDensityChanged(int density); boolean isModelCenterLocked(); @Override boolean isOutsideModel(Vector3d modelCoordinates); @Override void setActivationTimestamp(); void setModelCenter(Vector3d modelCenter); void setModelCenterLocked(boolean modelCenterLocked); void setProjectionChangeListener(ProjectionChangeSupport.ProjectionChangeListener projectionChangeListener); void useElevationOrderManager(OrderManager elevationOrderManager); static final boolean HIGH_ACCURACY_ALLOWED; static final int HIGH_ACCURACY_MIN_MODEL_DISTANCE; static final int HIGH_ACCURACY_THRESHOLD; }### Answer: @Test public void testHandleElevationChange() { assertNull(myTestObject.handleElevationChange(null)); }
### Question: WFSQueryController implements QueryRegionListener, EventListener<ActiveDataGroupsChangedEvent>, ListDataListener<TimeSpan> { @Override public void queryRegionRemoved(QueryRegion region) { myGovernorManager.clearData(new Pair<>(null, region)); } WFSQueryController(Toolbox toolbox); @Override void allQueriesRemoved(boolean animationPlanCancelled); void close(); @Override void elementsAdded(ListDataEvent<TimeSpan> e); @Override void elementsChanged(ListDataEvent<TimeSpan> e); @Override void elementsRemoved(ListDataEvent<TimeSpan> e); @Override void notify(ActiveDataGroupsChangedEvent event); @Override void queryRegionAdded(QueryRegion region); @Override void queryRegionRemoved(QueryRegion region); }### Answer: @Test public void testQueryRegionRemoved() throws DataElementLookupException, InterruptedException { EasyMockSupport support = new EasyMockSupport(); EventManager eventManager = createEventManager(support); TimeManager timeManager = createTimeManager(support); TimeSpan loadSpan = TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis()); CountDownLatch latch = new CountDownLatch(1); DataRegistry dataRegistry = createRegistry(support, New.list(loadSpan), New.list(latch)); QueryRegionManager queryManager = createRegionManager(support); List<DataTypeInfo> dataTypes = createTypes(support, TimeSpan.get(1000, System.currentTimeMillis())); DataTypeInfo wfsType = dataTypes.get(dataTypes.size() - 1); DataTypeController typeController = createTypeControllerRemove(support, dataTypes, wfsType, new long[] { 0, 1 }); List<Long> allIds = New.list(Long.valueOf(0), Long.valueOf(1)); DataElementCache cache = createCache(support, wfsType, allIds, null); List<MapGeometrySupport> geometrySupports = New.list(); List<DataElement> elements = createElements(loadSpan, geometrySupports); DataElementLookupUtils lookupUtils = createLookup(support, wfsType, allIds, elements); MapGeometrySupportConverterRegistry converter = createConverter(support, geometrySupports); MantleToolbox mantle = createMantle(support, queryManager, typeController, cache, lookupUtils, converter); Toolbox toolbox = createToolbox(support, eventManager, timeManager, dataRegistry, mantle); QueryRegion region = createRegion(support); support.replayAll(); timeManager.getLoadTimeSpans().add(loadSpan); WFSQueryController controller = new WFSQueryController(toolbox); myRegionListener.queryRegionAdded(region); assertTrue(latch.await(5, TimeUnit.SECONDS)); myRegionListener.queryRegionRemoved(region); assertTrue(controller.getGovernorManager().findGovernors(p -> true).isEmpty()); controller.close(); assertNull(myEventListener); assertNull(myRegionListener); support.verifyAll(); }
### Question: SaxElement { public SaxElement(String uri, String localName, String qName, Attributes attributes) { myUri = uri; myLocalName = localName; myQName = qName; for (int i = 0, n = attributes.getLength(); i < n; i++) { myAttributes.put(attributes.getQName(i), attributes.getValue(i)); } } SaxElement(String uri, String localName, String qName, Attributes attributes); String getUri(); String getLocalName(); String getQName(); Map<String, String> getAttributes(); @Override String toString(); }### Answer: @Test public void testSaxElement() { assertNotNull(myTestObject); }
### Question: SaxElement { public String getUri() { return myUri; } SaxElement(String uri, String localName, String qName, Attributes attributes); String getUri(); String getLocalName(); String getQName(); Map<String, String> getAttributes(); @Override String toString(); }### Answer: @Test public void testGetUri() { assertEquals(myUri, myTestObject.getUri()); }
### Question: SaxElement { public String getLocalName() { return myLocalName; } SaxElement(String uri, String localName, String qName, Attributes attributes); String getUri(); String getLocalName(); String getQName(); Map<String, String> getAttributes(); @Override String toString(); }### Answer: @Test public void testGetLocalName() { assertEquals(myLocalName, myTestObject.getLocalName()); }
### Question: SaxElement { public String getQName() { return myQName; } SaxElement(String uri, String localName, String qName, Attributes attributes); String getUri(); String getLocalName(); String getQName(); Map<String, String> getAttributes(); @Override String toString(); }### Answer: @Test public void testGetQName() { assertEquals(myQName, myTestObject.getQName()); }
### Question: SaxElement { public Map<String, String> getAttributes() { return myAttributes; } SaxElement(String uri, String localName, String qName, Attributes attributes); String getUri(); String getLocalName(); String getQName(); Map<String, String> getAttributes(); @Override String toString(); }### Answer: @Test public void testGetAttributes() { Map<String, String> attributes = myTestObject.getAttributes(); assertEquals(2, attributes.size()); assertEquals(attributes.get("zero"), "zero-value"); assertEquals(attributes.get("one"), "one-value"); }
### Question: SaxElement { @Override public String toString() { return myLocalName; } SaxElement(String uri, String localName, String qName, Attributes attributes); String getUri(); String getLocalName(); String getQName(); Map<String, String> getAttributes(); @Override String toString(); }### Answer: @Test public void testToString() { assertEquals(myLocalName, myTestObject.toString()); }
### Question: FilterReader { public static List<AbstractMapGeometrySupport> parse(String xmlText) { List<AbstractMapGeometrySupport> geometries; SAXParserFactory factory = SAXParserFactory.newInstance(); factory.setNamespaceAware(true); try { SAXParser saxParser = factory.newSAXParser(); FilterHandler handler = new FilterHandler(); byte[] bytes = xmlText.getBytes(StringUtilities.DEFAULT_CHARSET); saxParser.parse(new ByteArrayInputStream(bytes), handler); geometries = handler.getGeometries(); } catch (ParserConfigurationException | SAXException | IOException e) { geometries = Collections.emptyList(); LOGGER.error(e); } return geometries; } private FilterReader(); static List<AbstractMapGeometrySupport> parse(String xmlText); }### Answer: @Test public void testParse() { String xmlText = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + "<wfs:GetFeature xmlns:wfs=\"http: + "resultType=\"results\" service=\"WFS\" version=\"1.1.0\"><wfs:Query srsName=\"EPSG:4326\" " + "typeName=\"twitter_all\"><Filter xmlns=\"http: + " combinator=\"true\"><And><And><PropertyIsGreaterThanOrEqualTo><PropertyName>validTime</PropertyName>" + "<Sub><Function name=\"GET_CURRENT_DATE_TIME\"/><Literal>PT10M</Literal></Sub></PropertyIsGreaterThanOrEqualTo>" + "</And><Or><And><BBOX areanamehint=\"temp area 1\"><PropertyName>GEOM</PropertyName><gml:Envelope srsName=\"CRS:84\">" + "<gml:lowerCorner>-121.82080507278442 30.111331343650818</gml:lowerCorner><gml:upperCorner>-73.30518007278442 51.20508134365082</gml:upperCorner>" + "</gml:Envelope></BBOX></And></Or></And></Filter></wfs:Query></wfs:GetFeature>"; List<AbstractMapGeometrySupport> geoms = FilterReader.parse(xmlText); assertEquals(1, geoms.size()); DefaultMapPolygonGeometrySupport bbox = (DefaultMapPolygonGeometrySupport)geoms.get(0); assertEquals(4, bbox.getLocations().size()); assertEquals(LatLonAlt.createFromDegrees(30.111331343650818, -121.82080507278442), bbox.getLocations().get(0)); assertEquals(LatLonAlt.createFromDegrees(30.111331343650818, -73.30518007278442), bbox.getLocations().get(1)); assertEquals(LatLonAlt.createFromDegrees(51.20508134365082, -73.30518007278442), bbox.getLocations().get(2)); assertEquals(LatLonAlt.createFromDegrees(51.20508134365082, -121.82080507278442), bbox.getLocations().get(3)); }
### Question: FilterHandler extends BetterDefaultHandler { @Override public void startElement(String uri, String localName, String qName, Attributes attributes) { super.startElement(uri, localName, qName, attributes); if (GeometryHandlerFactory.GML_POLYGON_TAG.equals(localName)) { myCurrentGeometryHandler = GeometryHandlerFactory.getGeometryHandler(localName, false); } else if (EnvelopeHandler.ENVELOPE_TAG.equals(localName)) { myCurrentGeometryHandler = new EnvelopeHandler(); } if (myCurrentGeometryHandler != null) { myCurrentGeometryHandler.handleOpeningTag(localName); } } @Override void startElement(String uri, String localName, String qName, Attributes attributes); @Override void endElement(String uri, String localName, String qName); List<AbstractMapGeometrySupport> getGeometries(); }### Answer: @Test public void testStartElement() throws IllegalArgumentException, IllegalAccessException { myTestObject.startElement(myUri, myLocalName, myQName, myAttributes); assertEquals(1, myTestObject.getElementStack().size()); SaxElement element = myTestObject.getElementStack().getFirst(); assertEquals(myUri, element.getUri()); assertEquals(myLocalName, element.getLocalName()); assertEquals(myQName, element.getQName()); Map<String, String> attributes = element.getAttributes(); assertEquals(2, attributes.size()); assertEquals(attributes.get("zero"), "zero-value"); assertEquals(attributes.get("one"), "one-value"); assertEquals("", myTestObject.getCurrentValue()); AbstractGmlGeometryHandler currentFilterHandler = (AbstractGmlGeometryHandler)ourCurrentGeometryHandlerField .get(myTestObject); assertNotNull(currentFilterHandler); assertEquals(myLocalName, currentFilterHandler.getTagName()); }
### Question: BetterDefaultHandler extends DefaultHandler { @Override public void startElement(String uri, String localName, String qName, Attributes attributes) { myElementStack.push(new SaxElement(uri, localName, qName, attributes)); myCurrentValue.setLength(0); } @Override void startElement(String uri, String localName, String qName, Attributes attributes); @Override void endElement(String uri, String localName, String qName); @Override void characters(char[] ch, int start, int length); }### Answer: @Test public void testStartElement() { myTestObject.startElement(myUri, myLocalName, myQName, myAttributes); assertEquals(1, myTestObject.getElementStack().size()); SaxElement element = myTestObject.getElementStack().getFirst(); assertEquals(myUri, element.getUri()); assertEquals(myLocalName, element.getLocalName()); assertEquals(myQName, element.getQName()); Map<String, String> attributes = element.getAttributes(); assertEquals(2, attributes.size()); assertEquals(attributes.get("zero"), "zero-value"); assertEquals(attributes.get("one"), "one-value"); assertEquals("", myTestObject.getCurrentValue()); }
### Question: AbstractProjection implements Projection { @Override public Collection<GeographicBoundingBox> handleModelDensityChanged(int density) { return null; } static boolean isTerrainLocked(); static void setTerrainLocked(boolean lock); static void toggleTerrainLocked(); @Override long getActivationTimestamp(); @Override long getCreationTimestamp(); @Override double getDistanceFromModelCenterM(GeographicPosition position); @Override double getElevationOnTerrainM(GeographicPosition position); @Override Vector3d getModelCenter(); @Override Matrix4d getModelViewAdjustment(); @Override Projection getSnapshot(); @Override Collection<GeographicBoundingBox> handleElevationChange(ElevationChangedEvent event); @Override Collection<GeographicBoundingBox> handleModelDensityChanged(int density); boolean isModelCenterLocked(); @Override boolean isOutsideModel(Vector3d modelCoordinates); @Override void setActivationTimestamp(); void setModelCenter(Vector3d modelCenter); void setModelCenterLocked(boolean modelCenterLocked); void setProjectionChangeListener(ProjectionChangeSupport.ProjectionChangeListener projectionChangeListener); void useElevationOrderManager(OrderManager elevationOrderManager); static final boolean HIGH_ACCURACY_ALLOWED; static final int HIGH_ACCURACY_MIN_MODEL_DISTANCE; static final int HIGH_ACCURACY_THRESHOLD; }### Answer: @Test public void testHandleModelDensityChanged() { assertNull(myTestObject.handleModelDensityChanged(0)); }
### Question: BetterDefaultHandler extends DefaultHandler { protected Deque<SaxElement> getElementStack() { return myElementStack; } @Override void startElement(String uri, String localName, String qName, Attributes attributes); @Override void endElement(String uri, String localName, String qName); @Override void characters(char[] ch, int start, int length); }### Answer: @Test public void testGetElementStack() { assertEquals(0, myTestObject.getElementStack().size()); myTestObject.startElement(myUri, myLocalName, myQName, myAttributes); assertEquals(1, myTestObject.getElementStack().size()); SaxElement element = myTestObject.getElementStack().getFirst(); assertEquals(myUri, element.getUri()); assertEquals(myLocalName, element.getLocalName()); assertEquals(myQName, element.getQName()); Map<String, String> attributes = element.getAttributes(); assertEquals(2, attributes.size()); assertEquals(attributes.get("zero"), "zero-value"); assertEquals(attributes.get("one"), "one-value"); assertEquals("", myTestObject.getCurrentValue()); }
### Question: WFSNodeReader { public List<WFSLayerState> readNode(Node node) { List<WFSLayerState> layerStates = New.list(); findChildren(node, layerStates); return layerStates; } WFSNodeReader(WFSLayerConfigurationManager stateConfigurationManager); List<WFSLayerState> readNode(Node node); }### Answer: @Test public void test() throws JAXBException, ParserConfigurationException, XPathExpressionException { Node node = createWFSNodes(); WFSNodeReader reader = new WFSNodeReader(myLayerConfigurationManager); List<WFSLayerState> states = reader.readNode(node); assertEquals(3, states.size()); assertEquals("wfs", states.get(0).getType()); assertEquals("geoserverWFS", states.get(1).getType()); assertEquals("arcWFS", states.get(2).getType()); }
### Question: WFSNodeWriter { public static void writeToNode(Node node, List<WFSLayerState> layerStates) { Document doc = node instanceof Document ? (Document)node : node.getOwnerDocument(); try { Element dataLayerNode = (Element)StateXML.createChildNode(node, doc, node, StateConstants.DATA_LAYERS_PATH, StateConstants.LAYERS_NAME); dataLayerNode.setAttribute("type", StateConstants.DATA_LAYERS_TYPE); addToNode(dataLayerNode, layerStates); } catch (XPathExpressionException e) { LOGGER.error(e.getMessage(), e); } } private WFSNodeWriter(); static void writeToNode(Node node, List<WFSLayerState> layerStates); }### Answer: @Test public void test() throws JAXBException, ParserConfigurationException, XPathExpressionException { Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument(); Node node = doc.appendChild(StateXML.createElement(doc, ModuleStateController.STATE_NAME)); List<WFSLayerState> layerStates = New.list(); for (LayerConfiguration configuration : myLayerConfigurationManager.getAllConfigurations()) { createLayerStates(layerStates, configuration.getName()); } WFSNodeWriter.writeToNode(node, layerStates); NodeList nodes = node.getFirstChild().getChildNodes(); assertTrue(nodes.getLength() == 3); assertEquals("wfs", nodes.item(0).getAttributes().getNamedItem("type").getTextContent()); assertEquals("geoserverWFS", nodes.item(1).getAttributes().getNamedItem("type").getTextContent()); assertEquals("arcWFS", nodes.item(2).getAttributes().getNamedItem("type").getTextContent()); }
### Question: DataTypeControllerFeatureConsumer extends FeatureConsumer { @Override public void flush() { List<MapDataElement> features = consumeFeatures(); if (features == null || features.isEmpty()) { return; } synchronized (idSet) { if (killed) { return; } if (!ctrl.hasDataTypeInfoForTypeKey(myType.getTypeKey())) { ctrl.addDataType(getClass().getSimpleName(), myType.getTypeKey(), myType, this); } features = dontAddElementOutsideLoadTime(features); if (!features.isEmpty()) { idSet.addAll(ctrl.addMapDataElements(myType, null, null, features, this)); } } } DataTypeControllerFeatureConsumer(DataTypeController dataTypeController, TimeManager timeManager, DataTypeInfo info, int flushSize); @Override void cleanup(); @Override void flush(); }### Answer: @Test public void testFlushNoTime() { EasyMockSupport support = new EasyMockSupport(); DataTypeInfo dataType = createDataType(support); List<TimeSpan> loadSpans = New.list(TimeSpan.get(System.currentTimeMillis() - 20000, System.currentTimeMillis() - 15000), TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis())); List<MapDataElement> elements = createFeatures(support, loadSpans, false); TimeManager timeManager = null; DataTypeController typeController = createTypeController(support, dataType, elements); support.replayAll(); DataTypeControllerFeatureConsumer consumer = new DataTypeControllerFeatureConsumer(typeController, timeManager, dataType, 1); consumer.addFeatures(elements); consumer.flush(); support.verifyAll(); } @Test public void testFlushTime() { EasyMockSupport support = new EasyMockSupport(); DataTypeInfo dataType = createDataType(support); List<TimeSpan> loadSpans = New.list(TimeSpan.get(System.currentTimeMillis() - 20000, System.currentTimeMillis() - 15000), TimeSpan.get(System.currentTimeMillis() - 10000, System.currentTimeMillis())); List<MapDataElement> elements = createFeatures(support, loadSpans, true); TimeManager timeManager = createTimeManager(support, loadSpans); DataTypeController typeController = createTypeController(support, dataType, New.list(elements.get(0), elements.get(2), elements.get(3))); support.replayAll(); DataTypeControllerFeatureConsumer consumer = new DataTypeControllerFeatureConsumer(typeController, timeManager, dataType, 1); consumer.addFeatures(elements); consumer.flush(); support.verifyAll(); }
### Question: FeatureConsumerManager { public FeatureConsumer requestConsumer(DataTypeInfo type, boolean isLoadTimeAware) { Utilities.checkNull(type, "type"); Utilities.checkNull(type.getTypeKey(), "type.getTypeKey()"); FeatureConsumer consumer = myConsumerList.get(new Pair<>(type.getTypeKey(), Boolean.valueOf(isLoadTimeAware))); if (consumer == null) { int flushSize = myMantleToolbox.getDataElementCache().getPreferredInsertBlockSize(); if (flushSize <= 0) { flushSize = 5000; } consumer = new DataTypeControllerFeatureConsumer(myMantleToolbox.getDataTypeController(), isLoadTimeAware ? myTimeManager : null, type, flushSize); myConsumerList.put(new Pair<>(type.getTypeKey(), Boolean.valueOf(isLoadTimeAware)), consumer); } return consumer; } FeatureConsumerManager(MantleToolbox mantleToolbox, TimeManager timeManager); void removeType(WFSDataType type); FeatureConsumer requestConsumer(DataTypeInfo type, boolean isLoadTimeAware); }### Answer: @Test public void testRequestConsumer() { EasyMockSupport support = new EasyMockSupport(); DataTypeInfo dataType = createDataType(support); TimeManager timeManager = createTimeManager(support); MantleToolbox mantle = createMantle(support); support.replayAll(); FeatureConsumerManager manager = new FeatureConsumerManager(mantle, timeManager); DataTypeControllerFeatureConsumer timeAware = (DataTypeControllerFeatureConsumer)manager.requestConsumer(dataType, true); assertEquals(timeManager, timeAware.getTimeManager()); DataTypeControllerFeatureConsumer timeUnaware = (DataTypeControllerFeatureConsumer)manager.requestConsumer(dataType, false); assertNull(timeUnaware.getTimeManager()); support.verifyAll(); }
### Question: WFSDataType extends AbstractServerDataTypeInfo { @Override @SuppressWarnings("PMD.UselessOverridingMethod") public boolean equals(Object obj) { return super.equals(obj); } @SuppressWarnings("PMD.ConstructorCallsOverridableMethod") WFSDataType(Toolbox tb, String serverName, String layerKey, String name, String title, MetaDataInfo properties, LayerConfiguration stateConfiguration); protected WFSDataType(Toolbox pToolbox, String pServerName, String pLayerKey, String pLayerTypeName, String pDisplayTitle, LayerConfiguration pStateConfiguration, boolean pFiltersData); @Override void changeTimeColumns(); boolean chooseTimeColumns(Object source); @Override @SuppressWarnings("PMD.UselessOverridingMethod") boolean equals(Object obj); @Override Collection<String> getNamesForComparison(); @Override OrderParticipantKey getOrderKey(); OGCOutputFormat getOutputFormat(); Map<String, Class<?>> getProperties(); LayerConfiguration getStateConfiguration(); String getWFSVersion(); @Override void handleSyncChangeEvent(SyncChangeType type, Object source); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); boolean isAnimationSensitive(); @Override // from "Model" interface boolean isDisplayable(); boolean isLatBeforeLon(); @Override boolean isTimeColumnChangeable(); boolean isTimeColumnChosen(); boolean isTimeless(); void setActivationListener(ActivationListener activationListener); void setAnimationSensitive(boolean isAnimationSensitive); @Override // from "Model" interface void setDisplayable(boolean displayable, Object source); void setLatBeforeLon(boolean isLatBeforeLon); void setOutputFormat(OGCOutputFormat format); @Override void setParent(DataGroupInfo parent); boolean setPreferredTimeColumns(Object source); void setTimeColumns(TimeColumns columns, Object source); @Override void setTimeExtents(TimeExtents extents, boolean syncTime); @Override void setTypeSync(ServerDataTypeSync typeSync); @Override void setVisible(boolean visible, Object source); void setWFSVersion(String wfsVersion); void showConfig(Window parent); void showContent(Window parent); @Override String toString(); static final PropertyDescriptor<WFSDataType> WFS_PROPERTY_DESCRIPTOR; }### Answer: @Test @SuppressWarnings("PMD.StringInstantiation") public void testEqualsObject() { String type1 = TYPE1; String type2 = new String(TYPE1); String type3 = "type3"; Map<String, Class<?>> props = new HashMap<>(); props.put(ALTITUDE_KEY, Double.class); assertEquals(getNewType(type1, props), getNewType(type1, props)); assertEquals(getNewType(type1, props), getNewType(type2, props)); assertEquals(getNewType(type2, props), getNewType(type1, props)); assertFalse(getNewType(type1, props).equals(getNewType(type3, props))); assertFalse(getNewType(type3, props).equals(getNewType(type1, props))); }
### Question: WFSDataType extends AbstractServerDataTypeInfo { public Map<String, Class<?>> getProperties() { if (getMetaDataInfo() != null) { return getMetaDataInfo().getKeyClassTypeMap(); } return Collections.emptyMap(); } @SuppressWarnings("PMD.ConstructorCallsOverridableMethod") WFSDataType(Toolbox tb, String serverName, String layerKey, String name, String title, MetaDataInfo properties, LayerConfiguration stateConfiguration); protected WFSDataType(Toolbox pToolbox, String pServerName, String pLayerKey, String pLayerTypeName, String pDisplayTitle, LayerConfiguration pStateConfiguration, boolean pFiltersData); @Override void changeTimeColumns(); boolean chooseTimeColumns(Object source); @Override @SuppressWarnings("PMD.UselessOverridingMethod") boolean equals(Object obj); @Override Collection<String> getNamesForComparison(); @Override OrderParticipantKey getOrderKey(); OGCOutputFormat getOutputFormat(); Map<String, Class<?>> getProperties(); LayerConfiguration getStateConfiguration(); String getWFSVersion(); @Override void handleSyncChangeEvent(SyncChangeType type, Object source); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); boolean isAnimationSensitive(); @Override // from "Model" interface boolean isDisplayable(); boolean isLatBeforeLon(); @Override boolean isTimeColumnChangeable(); boolean isTimeColumnChosen(); boolean isTimeless(); void setActivationListener(ActivationListener activationListener); void setAnimationSensitive(boolean isAnimationSensitive); @Override // from "Model" interface void setDisplayable(boolean displayable, Object source); void setLatBeforeLon(boolean isLatBeforeLon); void setOutputFormat(OGCOutputFormat format); @Override void setParent(DataGroupInfo parent); boolean setPreferredTimeColumns(Object source); void setTimeColumns(TimeColumns columns, Object source); @Override void setTimeExtents(TimeExtents extents, boolean syncTime); @Override void setTypeSync(ServerDataTypeSync typeSync); @Override void setVisible(boolean visible, Object source); void setWFSVersion(String wfsVersion); void showConfig(Window parent); void showContent(Window parent); @Override String toString(); static final PropertyDescriptor<WFSDataType> WFS_PROPERTY_DESCRIPTOR; }### Answer: @Test public void testGetProperties() { Map<String, Class<?>> expected = new HashMap<>(); expected.put(ALTITUDE_KEY, Double.class); expected.put(ELEVATION_KEY, Double.class); Map<String, Class<?>> properties = getNewType("type", expected).getProperties(); assertEquals(expected, properties); }
### Question: WFSDataType extends AbstractServerDataTypeInfo { @Override @SuppressWarnings("PMD.UselessOverridingMethod") public int hashCode() { return super.hashCode(); } @SuppressWarnings("PMD.ConstructorCallsOverridableMethod") WFSDataType(Toolbox tb, String serverName, String layerKey, String name, String title, MetaDataInfo properties, LayerConfiguration stateConfiguration); protected WFSDataType(Toolbox pToolbox, String pServerName, String pLayerKey, String pLayerTypeName, String pDisplayTitle, LayerConfiguration pStateConfiguration, boolean pFiltersData); @Override void changeTimeColumns(); boolean chooseTimeColumns(Object source); @Override @SuppressWarnings("PMD.UselessOverridingMethod") boolean equals(Object obj); @Override Collection<String> getNamesForComparison(); @Override OrderParticipantKey getOrderKey(); OGCOutputFormat getOutputFormat(); Map<String, Class<?>> getProperties(); LayerConfiguration getStateConfiguration(); String getWFSVersion(); @Override void handleSyncChangeEvent(SyncChangeType type, Object source); @Override @SuppressWarnings("PMD.UselessOverridingMethod") int hashCode(); boolean isAnimationSensitive(); @Override // from "Model" interface boolean isDisplayable(); boolean isLatBeforeLon(); @Override boolean isTimeColumnChangeable(); boolean isTimeColumnChosen(); boolean isTimeless(); void setActivationListener(ActivationListener activationListener); void setAnimationSensitive(boolean isAnimationSensitive); @Override // from "Model" interface void setDisplayable(boolean displayable, Object source); void setLatBeforeLon(boolean isLatBeforeLon); void setOutputFormat(OGCOutputFormat format); @Override void setParent(DataGroupInfo parent); boolean setPreferredTimeColumns(Object source); void setTimeColumns(TimeColumns columns, Object source); @Override void setTimeExtents(TimeExtents extents, boolean syncTime); @Override void setTypeSync(ServerDataTypeSync typeSync); @Override void setVisible(boolean visible, Object source); void setWFSVersion(String wfsVersion); void showConfig(Window parent); void showContent(Window parent); @Override String toString(); static final PropertyDescriptor<WFSDataType> WFS_PROPERTY_DESCRIPTOR; }### Answer: @Test @SuppressWarnings("PMD.StringInstantiation") public void testHashCode() { String type1 = TYPE1; String type2 = new String(TYPE1); String type3 = "type3"; Map<String, Class<?>> props = new HashMap<>(); props.put(ALTITUDE_KEY, Double.class); assertEquals(getNewType(type1, props).hashCode(), getNewType(type1, props).hashCode()); assertEquals(getNewType(type1, props).hashCode(), getNewType(type2, props).hashCode()); assertEquals(getNewType(type2, props).hashCode(), getNewType(type1, props).hashCode()); assertFalse(getNewType(type1, props).hashCode() == getNewType(type3, props).hashCode()); assertFalse(getNewType(type3, props).hashCode() == getNewType(type1, props).hashCode()); }
### Question: XrayGogglesModel extends Observable implements Cloneable { public void setGeoPosition(GeographicPosition upperLeft, GeographicPosition upperRight, GeographicPosition lowerLeft, GeographicPosition lowerRight, GeographicPosition center) { myUpperLeftGeo = upperLeft; myUpperRightGeo = upperRight; myLowerLeftGeo = lowerLeft; myLowerRightGeo = lowerRight; myCenterGeo = center; setChanged(); notifyObservers(GEO_POSITION); } @Override XrayGogglesModel clone(); GeographicPosition getCenterGeo(); ScreenPosition getLowerLeft(); GeographicPosition getLowerLeftGeo(); ScreenPosition getLowerRight(); GeographicPosition getLowerRightGeo(); ScreenPosition getUpperLeft(); GeographicPosition getUpperLeftGeo(); ScreenPosition getUpperRight(); GeographicPosition getUpperRightGeo(); Geometry getWindowGeometry(); void setGeoPosition(GeographicPosition upperLeft, GeographicPosition upperRight, GeographicPosition lowerLeft, GeographicPosition lowerRight, GeographicPosition center); void setScreenPosition(ScreenPosition upperLeft, ScreenPosition upperRight, ScreenPosition lowerLeft, ScreenPosition lowerRight); void setValidator(XrayModelValidator validator); void setWindowGeometry(Geometry windowGeometry); static final String GEO_POSITION; static final String SCREEN_POSITION; static final String XRAY_GOGGLES; }### Answer: @Test public void testSetGeoPosition() { EasyMockSupport support = new EasyMockSupport(); Observer observer = createObserver(support, XrayGogglesModel.GEO_POSITION); support.replayAll(); GeographicPosition upperLeft = new GeographicPosition(LatLonAlt.createFromDegrees(11, 10)); GeographicPosition upperRight = new GeographicPosition(LatLonAlt.createFromDegrees(11, 11)); GeographicPosition lowerLeft = new GeographicPosition(LatLonAlt.createFromDegrees(10, 10)); GeographicPosition lowerRight = new GeographicPosition(LatLonAlt.createFromDegrees(10, 11)); GeographicPosition center = new GeographicPosition(LatLonAlt.createFromDegrees(10.5, 10.5)); XrayGogglesModel model = new XrayGogglesModel(); model.addObserver(observer); model.setGeoPosition(upperLeft, upperRight, lowerLeft, lowerRight, center); assertEquals(upperLeft, model.getUpperLeftGeo()); assertEquals(upperRight, model.getUpperRightGeo()); assertEquals(lowerLeft, model.getLowerLeftGeo()); assertEquals(lowerRight, model.getLowerRightGeo()); assertEquals(center, model.getCenterGeo()); support.verifyAll(); }
### Question: AbstractProjection implements Projection { public boolean isModelCenterLocked() { return myModelCenterLocked; } static boolean isTerrainLocked(); static void setTerrainLocked(boolean lock); static void toggleTerrainLocked(); @Override long getActivationTimestamp(); @Override long getCreationTimestamp(); @Override double getDistanceFromModelCenterM(GeographicPosition position); @Override double getElevationOnTerrainM(GeographicPosition position); @Override Vector3d getModelCenter(); @Override Matrix4d getModelViewAdjustment(); @Override Projection getSnapshot(); @Override Collection<GeographicBoundingBox> handleElevationChange(ElevationChangedEvent event); @Override Collection<GeographicBoundingBox> handleModelDensityChanged(int density); boolean isModelCenterLocked(); @Override boolean isOutsideModel(Vector3d modelCoordinates); @Override void setActivationTimestamp(); void setModelCenter(Vector3d modelCenter); void setModelCenterLocked(boolean modelCenterLocked); void setProjectionChangeListener(ProjectionChangeSupport.ProjectionChangeListener projectionChangeListener); void useElevationOrderManager(OrderManager elevationOrderManager); static final boolean HIGH_ACCURACY_ALLOWED; static final int HIGH_ACCURACY_MIN_MODEL_DISTANCE; static final int HIGH_ACCURACY_THRESHOLD; }### Answer: @Test public void testIsModelCenterLocked() { assertFalse(myTestObject.isModelCenterLocked()); myTestObject.setModelCenterLocked(true); assertTrue(myTestObject.isModelCenterLocked()); myTestObject.setModelCenterLocked(false); assertTrue(myTestObject.isModelCenterLocked()); }
### Question: XrayGogglesModel extends Observable implements Cloneable { @Override public XrayGogglesModel clone() { try { return (XrayGogglesModel)super.clone(); } catch (CloneNotSupportedException e) { throw new ExpectedCloneableException(e); } } @Override XrayGogglesModel clone(); GeographicPosition getCenterGeo(); ScreenPosition getLowerLeft(); GeographicPosition getLowerLeftGeo(); ScreenPosition getLowerRight(); GeographicPosition getLowerRightGeo(); ScreenPosition getUpperLeft(); GeographicPosition getUpperLeftGeo(); ScreenPosition getUpperRight(); GeographicPosition getUpperRightGeo(); Geometry getWindowGeometry(); void setGeoPosition(GeographicPosition upperLeft, GeographicPosition upperRight, GeographicPosition lowerLeft, GeographicPosition lowerRight, GeographicPosition center); void setScreenPosition(ScreenPosition upperLeft, ScreenPosition upperRight, ScreenPosition lowerLeft, ScreenPosition lowerRight); void setValidator(XrayModelValidator validator); void setWindowGeometry(Geometry windowGeometry); static final String GEO_POSITION; static final String SCREEN_POSITION; static final String XRAY_GOGGLES; }### Answer: @Test public void testClone() { GeographicPosition upperLeftGeo = new GeographicPosition(LatLonAlt.createFromDegrees(11, 10)); GeographicPosition upperRightGeo = new GeographicPosition(LatLonAlt.createFromDegrees(11, 11)); GeographicPosition lowerLeftGeo = new GeographicPosition(LatLonAlt.createFromDegrees(10, 10)); GeographicPosition lowerRightGeo = new GeographicPosition(LatLonAlt.createFromDegrees(10, 11)); GeographicPosition center = new GeographicPosition(LatLonAlt.createFromDegrees(10.5, 10.5)); ScreenPosition upperLeft = new ScreenPosition(10, 11); ScreenPosition upperRight = new ScreenPosition(11, 11); ScreenPosition lowerLeft = new ScreenPosition(10, 10); ScreenPosition lowerRight = new ScreenPosition(11, 10); XrayGogglesModel model = new XrayGogglesModel(); model.setGeoPosition(upperLeftGeo, upperRightGeo, lowerLeftGeo, lowerRightGeo, center); model.setScreenPosition(upperLeft, upperRight, lowerLeft, lowerRight); model = model.clone(); assertEquals(upperLeftGeo.asVector2d(), model.getUpperLeftGeo().asVector2d()); assertEquals(upperRightGeo.asVector2d(), model.getUpperRightGeo().asVector2d()); assertEquals(lowerLeftGeo.asVector2d(), model.getLowerLeftGeo().asVector2d()); assertEquals(lowerRightGeo.asVector2d(), model.getLowerRightGeo().asVector2d()); assertEquals(center.asVector2d(), model.getCenterGeo().asVector2d()); assertEquals(upperLeft.asVector2d(), model.getUpperLeft().asVector2d()); assertEquals(upperRight.asVector2d(), model.getUpperRight().asVector2d()); assertEquals(lowerLeft.asVector2d(), model.getLowerLeft().asVector2d()); assertEquals(lowerRight.asVector2d(), model.getLowerRight().asVector2d()); }
### Question: XrayGogglesModel extends Observable implements Cloneable { public void setScreenPosition(ScreenPosition upperLeft, ScreenPosition upperRight, ScreenPosition lowerLeft, ScreenPosition lowerRight) { if (myValidator == null || myValidator.isValid(upperLeft, upperRight, lowerLeft, lowerRight)) { myUpperLeft = upperLeft; myUpperRight = upperRight; myLowerLeft = lowerLeft; myLowerRight = lowerRight; setChanged(); notifyObservers(SCREEN_POSITION); } } @Override XrayGogglesModel clone(); GeographicPosition getCenterGeo(); ScreenPosition getLowerLeft(); GeographicPosition getLowerLeftGeo(); ScreenPosition getLowerRight(); GeographicPosition getLowerRightGeo(); ScreenPosition getUpperLeft(); GeographicPosition getUpperLeftGeo(); ScreenPosition getUpperRight(); GeographicPosition getUpperRightGeo(); Geometry getWindowGeometry(); void setGeoPosition(GeographicPosition upperLeft, GeographicPosition upperRight, GeographicPosition lowerLeft, GeographicPosition lowerRight, GeographicPosition center); void setScreenPosition(ScreenPosition upperLeft, ScreenPosition upperRight, ScreenPosition lowerLeft, ScreenPosition lowerRight); void setValidator(XrayModelValidator validator); void setWindowGeometry(Geometry windowGeometry); static final String GEO_POSITION; static final String SCREEN_POSITION; static final String XRAY_GOGGLES; }### Answer: @Test public void testSetScreenPosition() { EasyMockSupport support = new EasyMockSupport(); Observer observer = createObserver(support, XrayGogglesModel.SCREEN_POSITION); support.replayAll(); ScreenPosition upperLeft = new ScreenPosition(10, 11); ScreenPosition upperRight = new ScreenPosition(11, 11); ScreenPosition lowerLeft = new ScreenPosition(10, 10); ScreenPosition lowerRight = new ScreenPosition(11, 10); XrayGogglesModel model = new XrayGogglesModel(); model.addObserver(observer); model.setScreenPosition(upperLeft, upperRight, lowerLeft, lowerRight); assertEquals(upperLeft, model.getUpperLeft()); assertEquals(upperRight, model.getUpperRight()); assertEquals(lowerLeft, model.getLowerLeft()); assertEquals(lowerRight, model.getLowerRight()); support.verifyAll(); }
### Question: ScreenToGeo implements Observer, ViewChangeListener { public void close() { myExecutor.shutdownNow(); myModel.deleteObserver(this); myMapManager.getViewChangeSupport().removeViewChangeListener(this); } ScreenToGeo(MapManager mapManager, XrayGogglesModel model); void close(); @Override void update(Observable o, Object arg); @Override void viewChanged(Viewer viewer, ViewChangeType type); }### Answer: @Test public void testInitial() throws InterruptedException { EasyMockSupport support = new EasyMockSupport(); MapManager mapManager = createMapManager(support); support.replayAll(); XrayGogglesModel model = new XrayGogglesModel(); model.setScreenPosition(new ScreenPosition(0, 0), new ScreenPosition(2, 0), new ScreenPosition(0, 2), new ScreenPosition(2, 2)); myLatch = new CountDownLatch(1); model.addObserver(this); ScreenToGeo screenToGeo = new ScreenToGeo(mapManager, model); assertTrue(myLatch.await(1, TimeUnit.SECONDS)); assertEquals(new Vector2d(10, 10), model.getUpperLeftGeo().asVector2d()); assertEquals(new Vector2d(12, 10), model.getUpperRightGeo().asVector2d()); assertEquals(new Vector2d(10, 12), model.getLowerLeftGeo().asVector2d()); assertEquals(new Vector2d(12, 12), model.getLowerRightGeo().asVector2d()); assertEquals(new Vector2d(11, 11), model.getCenterGeo().asVector2d()); screenToGeo.close(); model.setScreenPosition(new ScreenPosition(20, 20), new ScreenPosition(21, 20), new ScreenPosition(20, 21), new ScreenPosition(21, 21)); Thread.sleep(500); support.verifyAll(); }
### Question: ScreenToGeo implements Observer, ViewChangeListener { @Override public void update(Observable o, Object arg) { if (XrayGogglesModel.SCREEN_POSITION.equals(arg)) { calculateGeosInBackground(); } } ScreenToGeo(MapManager mapManager, XrayGogglesModel model); void close(); @Override void update(Observable o, Object arg); @Override void viewChanged(Viewer viewer, ViewChangeType type); }### Answer: @Test public void testUpdate() throws InterruptedException { EasyMockSupport support = new EasyMockSupport(); MapManager mapManager = createMapManager(support); support.replayAll(); XrayGogglesModel model = new XrayGogglesModel(); ScreenToGeo screenToGeo = new ScreenToGeo(mapManager, model); myLatch = new CountDownLatch(1); model.addObserver(this); model.setScreenPosition(new ScreenPosition(0, 0), new ScreenPosition(2, 0), new ScreenPosition(0, 2), new ScreenPosition(2, 2)); assertTrue(myLatch.await(1, TimeUnit.SECONDS)); assertEquals(new Vector2d(10, 10), model.getUpperLeftGeo().asVector2d()); assertEquals(new Vector2d(12, 10), model.getUpperRightGeo().asVector2d()); assertEquals(new Vector2d(10, 12), model.getLowerLeftGeo().asVector2d()); assertEquals(new Vector2d(12, 12), model.getLowerRightGeo().asVector2d()); assertEquals(new Vector2d(11, 11), model.getCenterGeo().asVector2d()); screenToGeo.close(); model.setScreenPosition(new ScreenPosition(20, 20), new ScreenPosition(21, 20), new ScreenPosition(20, 21), new ScreenPosition(21, 21)); Thread.sleep(500); support.verifyAll(); }
### Question: ScreenToGeo implements Observer, ViewChangeListener { @Override public void viewChanged(Viewer viewer, ViewChangeType type) { if (ViewChangeType.WINDOW_RESIZE != type) { calculateGeosInBackground(); } } ScreenToGeo(MapManager mapManager, XrayGogglesModel model); void close(); @Override void update(Observable o, Object arg); @Override void viewChanged(Viewer viewer, ViewChangeType type); }### Answer: @Test public void testViewChanged() throws InterruptedException { EasyMockSupport support = new EasyMockSupport(); MapManager mapManager = createMapManager(support); EasyMock.expect(mapManager.convertToPosition(EasyMock.isA(Vector2i.class), EasyMock.eq(ReferenceLevel.TERRAIN))) .andAnswer(() -> { Vector2i screen = (Vector2i)EasyMock.getCurrentArguments()[0]; LatLonAlt latLon = LatLonAlt.createFromDegrees(20 + screen.getY(), 20 + screen.getX()); return new GeographicPosition(latLon); }).times(5); support.replayAll(); XrayGogglesModel model = new XrayGogglesModel(); model.setScreenPosition(new ScreenPosition(0, 0), new ScreenPosition(1, 0), new ScreenPosition(0, 1), new ScreenPosition(1, 1)); myLatch = new CountDownLatch(1); model.addObserver(this); ScreenToGeo screenToGeo = new ScreenToGeo(mapManager, model); assertTrue(myLatch.await(1, TimeUnit.SECONDS)); assertEquals(new Vector2d(10, 10), model.getUpperLeftGeo().asVector2d()); assertEquals(new Vector2d(11, 10), model.getUpperRightGeo().asVector2d()); assertEquals(new Vector2d(10, 11), model.getLowerLeftGeo().asVector2d()); assertEquals(new Vector2d(11, 11), model.getLowerRightGeo().asVector2d()); myLatch = new CountDownLatch(1); mapManager.getViewChangeSupport().notifyViewChangeListeners(null, (r) -> { r.run(); }, ViewChangeType.VIEW_CHANGE); assertTrue(myLatch.await(1, TimeUnit.SECONDS)); assertEquals(new Vector2d(20, 20), model.getUpperLeftGeo().asVector2d()); assertEquals(new Vector2d(21, 20), model.getUpperRightGeo().asVector2d()); assertEquals(new Vector2d(20, 21), model.getLowerLeftGeo().asVector2d()); assertEquals(new Vector2d(21, 21), model.getLowerRightGeo().asVector2d()); screenToGeo.close(); mapManager.getViewChangeSupport().notifyViewChangeListeners(null, (r) -> { r.run(); }, ViewChangeType.VIEW_CHANGE); Thread.sleep(500); support.verifyAll(); }
### Question: AbstractProjection implements Projection { @Override public boolean isOutsideModel(Vector3d modelCoordinates) { return false; } static boolean isTerrainLocked(); static void setTerrainLocked(boolean lock); static void toggleTerrainLocked(); @Override long getActivationTimestamp(); @Override long getCreationTimestamp(); @Override double getDistanceFromModelCenterM(GeographicPosition position); @Override double getElevationOnTerrainM(GeographicPosition position); @Override Vector3d getModelCenter(); @Override Matrix4d getModelViewAdjustment(); @Override Projection getSnapshot(); @Override Collection<GeographicBoundingBox> handleElevationChange(ElevationChangedEvent event); @Override Collection<GeographicBoundingBox> handleModelDensityChanged(int density); boolean isModelCenterLocked(); @Override boolean isOutsideModel(Vector3d modelCoordinates); @Override void setActivationTimestamp(); void setModelCenter(Vector3d modelCenter); void setModelCenterLocked(boolean modelCenterLocked); void setProjectionChangeListener(ProjectionChangeSupport.ProjectionChangeListener projectionChangeListener); void useElevationOrderManager(OrderManager elevationOrderManager); static final boolean HIGH_ACCURACY_ALLOWED; static final int HIGH_ACCURACY_MIN_MODEL_DISTANCE; static final int HIGH_ACCURACY_THRESHOLD; }### Answer: @Test public void testIsOutsideModel() { assertFalse(myTestObject.isOutsideModel(null)); }
### Question: XrayGogglesController { public void close() { myWindowValidator.close(); myXrayer.close(); myScreenPosManager.close(); myScreenToGeo.close(); myResizer.close(); } XrayGogglesController(MapManager mapManager, GeometryRegistry geometryRegistry, ControlRegistry controlRegistry, XrayGogglesModel model); void close(); }### Answer: @Test public void test() { EasyMockSupport support = new EasyMockSupport(); ScreenViewer viewer = createViewer(support); MapManager mapManager = createMapManager(support, viewer); GeometryRegistry geometryRegistry = createGeometryRegistry(support); XrayGogglesModel model = new XrayGogglesModel(); ControlRegistry controlRegistry = createControlRegistry(support); support.replayAll(); XrayGogglesController controller = new XrayGogglesController(mapManager, geometryRegistry, controlRegistry, model); assertNotNull(model.getUpperLeftGeo()); controller.close(); assertNull(model.getUpperLeft()); mapManager.getViewChangeSupport().notifyViewChangeListeners(viewer, (r) -> { r.run(); }, ViewChangeType.VIEW_CHANGE); assertNull(model.getUpperRight()); support.verifyAll(); }
### Question: ScreenPositionManager implements ViewChangeListener, DiscreteEventListener { public void close() { ControlContext globeContext = myControlRegistry.getControlContext(ControlRegistry.GLOBE_CONTROL_CONTEXT); globeContext.removeListener(this); myMapManager.getViewChangeSupport().removeViewChangeListener(this); myModel.setScreenPosition(null, null, null, null); myModel.setGeoPosition(null, null, null, null, null); } ScreenPositionManager(MapManager mapManager, ControlRegistry controlRegistry, XrayGogglesModel model); void close(); @Override void eventOccurred(InputEvent event); @Override String getCategory(); @Override String getDescription(); @Override int getTargetPriority(); @Override String getTitle(); @Override boolean isReassignable(); @Override boolean isTargeted(); @Override boolean mustBeTargeted(); @Override void viewChanged(Viewer viewer, ViewChangeSupport.ViewChangeType type); }### Answer: @Test public void test() throws InterruptedException { EasyMockSupport support = new EasyMockSupport(); ScreenViewer viewer = createViewer(support); DynamicViewer standardViewer = support.createMock(DynamicViewer.class); EasyMock.expect(Double.valueOf(standardViewer.getPitch())).andReturn(Double.valueOf(Math.toRadians(45))).atLeastOnce(); MapManager mapManager = createMapManager(support, viewer, standardViewer); ControlRegistry controlRegistry = createControlRegistry(support); support.replayAll(); XrayGogglesModel model = new XrayGogglesModel(); ScreenPositionManager manager = new ScreenPositionManager(mapManager, controlRegistry, model); assertEquals(480, model.getUpperLeft().getX(), 0d); assertEquals(720, model.getUpperLeft().getY(), 0d); assertEquals(1440, model.getUpperRight().getX(), 0d); assertEquals(720, model.getUpperRight().getY(), 0d); assertEquals(640, model.getLowerLeft().getX(), 0d); assertEquals(1080, model.getLowerLeft().getY(), 0d); assertEquals(1280, model.getLowerRight().getX(), 0d); assertEquals(1080, model.getLowerRight().getY(), 0d); model.addObserver((o, arg) -> { myLatch.countDown(); }); myLatch = new CountDownLatch(1); mapManager.getViewChangeSupport().notifyViewChangeListeners(viewer, (r) -> { r.run(); }, ViewChangeType.WINDOW_RESIZE); assertTrue(myLatch.await(1, TimeUnit.SECONDS)); assertEquals(240, model.getUpperLeft().getX(), 0d); assertEquals(360, model.getUpperLeft().getY(), 0d); assertEquals(720, model.getUpperRight().getX(), 0d); assertEquals(360, model.getUpperRight().getY(), 0d); assertEquals(320, model.getLowerLeft().getX(), 0d); assertEquals(540, model.getLowerLeft().getY(), 0d); assertEquals(640, model.getLowerRight().getX(), 0d); assertEquals(540, model.getLowerRight().getY(), 0d); mapManager.getViewChangeSupport().notifyViewChangeListeners(viewer, (r) -> { r.run(); }, ViewChangeType.NEW_VIEWER); mapManager.getViewChangeSupport().notifyViewChangeListeners(viewer, (r) -> { r.run(); }, ViewChangeType.VIEW_CHANGE); manager.close(); assertNull(model.getUpperLeft()); assertNull(model.getUpperRight()); assertNull(model.getLowerLeft()); assertNull(model.getLowerRight()); assertNull(model.getCenterGeo()); assertNull(model.getUpperLeftGeo()); assertNull(model.getUpperRightGeo()); assertNull(model.getLowerLeftGeo()); assertNull(model.getLowerRightGeo()); mapManager.getViewChangeSupport().notifyViewChangeListeners(viewer, (r) -> { r.run(); }, ViewChangeType.WINDOW_RESIZE); Thread.sleep(100); support.verifyAll(); }
### Question: XrayGogglesMenuProvider { public void close() { if (myCurrentController != null) { myCurrentController.close(); myCurrentController = null; } } XrayGogglesMenuProvider(Toolbox toolbox, XrayGogglesModel model); void close(); }### Answer: @Test public void test() { EasyMockSupport support = new EasyMockSupport(); JMenu viewMenu = new JMenu("View"); UIRegistry uiRegistry = createUIRegistry(support, viewMenu); ScreenViewer viewer = createViewer(support); MapManager mapManager = createMapManager(support, viewer); GeometryRegistry geomRegistry = support.createNiceMock(GeometryRegistry.class); Toolbox toolbox = createToolbox(support, uiRegistry, mapManager, geomRegistry); support.replayAll(); XrayGogglesModel model = new XrayGogglesModel(); XrayGogglesMenuProvider provider = new XrayGogglesMenuProvider(toolbox, model); EventQueueUtilities.runOnEDTAndWait(() -> { }); JCheckBoxMenuItem menuItem = (JCheckBoxMenuItem)viewMenu.getItem(0); assertEquals("Underground", menuItem.getText()); assertNull(model.getLowerLeft()); menuItem.doClick(); assertNotNull(model.getLowerLeft()); menuItem.doClick(); assertNull(model.getLowerLeft()); provider.close(); support.verifyAll(); }
### Question: AbstractProjection implements Projection { public void setModelCenter(Vector3d modelCenter) { myModelCenter = modelCenter; if (!Utilities.sameInstance(modelCenter, Vector3d.ORIGIN)) { myModelViewAdjustment = new Matrix4d(); myModelViewAdjustment.setTranslation(myModelCenter); } else { myModelViewAdjustment = null; } } static boolean isTerrainLocked(); static void setTerrainLocked(boolean lock); static void toggleTerrainLocked(); @Override long getActivationTimestamp(); @Override long getCreationTimestamp(); @Override double getDistanceFromModelCenterM(GeographicPosition position); @Override double getElevationOnTerrainM(GeographicPosition position); @Override Vector3d getModelCenter(); @Override Matrix4d getModelViewAdjustment(); @Override Projection getSnapshot(); @Override Collection<GeographicBoundingBox> handleElevationChange(ElevationChangedEvent event); @Override Collection<GeographicBoundingBox> handleModelDensityChanged(int density); boolean isModelCenterLocked(); @Override boolean isOutsideModel(Vector3d modelCoordinates); @Override void setActivationTimestamp(); void setModelCenter(Vector3d modelCenter); void setModelCenterLocked(boolean modelCenterLocked); void setProjectionChangeListener(ProjectionChangeSupport.ProjectionChangeListener projectionChangeListener); void useElevationOrderManager(OrderManager elevationOrderManager); static final boolean HIGH_ACCURACY_ALLOWED; static final int HIGH_ACCURACY_MIN_MODEL_DISTANCE; static final int HIGH_ACCURACY_THRESHOLD; }### Answer: @Test public void testSetModelCenter() { myTestObject.setModelCenter(Vector3d.UNIT_X); assertEquals(Vector3d.UNIT_X, myTestObject.getModelCenter()); assertNotNull(myTestObject.getModelViewAdjustment()); assertEquals(Vector3d.UNIT_X.getX(), myTestObject.getModelViewAdjustment().get(0, 3), 0); assertEquals(Vector3d.UNIT_X.getY(), myTestObject.getModelViewAdjustment().get(1, 3), 0); assertEquals(Vector3d.UNIT_X.getZ(), myTestObject.getModelViewAdjustment().get(2, 3), 0); }
### Question: XrayWindow extends DefaultTransformer implements Observer { @Override public void open() { super.open(); publishUnpublishWindow(); myModel.addObserver(this); } XrayWindow(DataRegistry dataRegistry, XrayGogglesModel model); @Override void close(); @Override void open(); @Override void update(Observable o, Object arg); }### Answer: @Test public void test() { EasyMockSupport support = new EasyMockSupport(); DataRegistry registry = support.createMock(DataRegistry.class); GenericSubscriber<Geometry> receiver = createSubscriber(support); support.replayAll(); XrayGogglesModel model = new XrayGogglesModel(); XrayWindow window = new XrayWindow(registry, model); model.setScreenPosition(new ScreenPosition(10, 11), new ScreenPosition(11, 11), new ScreenPosition(10, 10), new ScreenPosition(11, 10)); window.addSubscriber(receiver); window.open(); assertEquals(1, myGeometries.size()); assertEquals(model.getWindowGeometry(), myGeometries.iterator().next()); PolylineGeometry geometry = (PolylineGeometry)myGeometries.get(0); assertEquals(5, geometry.getVertices().size()); assertEquals(model.getUpperLeft().asVector2d(), geometry.getVertices().get(0).asVector2d()); assertEquals(model.getUpperRight().asVector2d(), geometry.getVertices().get(1).asVector2d()); assertEquals(model.getLowerRight().asVector2d(), geometry.getVertices().get(2).asVector2d()); assertEquals(model.getLowerLeft().asVector2d(), geometry.getVertices().get(3).asVector2d()); assertEquals(model.getUpperLeft().asVector2d(), geometry.getVertices().get(4).asVector2d()); model.setScreenPosition(new ScreenPosition(20, 21), new ScreenPosition(21, 21), new ScreenPosition(20, 20), new ScreenPosition(21, 20)); assertEquals(1, myGeometries.size()); assertEquals(model.getWindowGeometry(), myGeometries.iterator().next()); geometry = (PolylineGeometry)myGeometries.get(0); assertEquals(5, geometry.getVertices().size()); assertEquals(model.getUpperLeft().asVector2d(), geometry.getVertices().get(0).asVector2d()); assertEquals(model.getUpperRight().asVector2d(), geometry.getVertices().get(1).asVector2d()); assertEquals(model.getLowerRight().asVector2d(), geometry.getVertices().get(2).asVector2d()); assertEquals(model.getLowerLeft().asVector2d(), geometry.getVertices().get(3).asVector2d()); assertEquals(model.getUpperLeft().asVector2d(), geometry.getVertices().get(4).asVector2d()); model.setScreenPosition(null, null, null, null); assertTrue(myGeometries.isEmpty()); assertNull(model.getWindowGeometry()); support.verifyAll(); }
### Question: XrayGoggles { public XrayWindow getTransformer() { return myTransformer; } XrayGoggles(Toolbox toolbox); void close(); XrayWindow getTransformer(); }### Answer: @Test public void test() { EasyMockSupport support = new EasyMockSupport(); UIRegistry uiRegistry = createUIRegistry(support); Toolbox toolbox = createToolbox(support, uiRegistry); support.replayAll(); XrayGoggles goggles = new XrayGoggles(toolbox); assertNotNull(goggles.getTransformer()); EventQueueUtilities.runOnEDTAndWait(() -> { }); support.verifyAll(); }
### Question: OptionsAccessor { public Placemark getDefaultPlacemark() { PreferencesRegistry registry = myToolbox.getPreferencesRegistry(); Preferences preferences = registry.getPreferences(OptionsAccessor.class); Placemark placemark = new Placemark(); String kmlString = preferences.getString(DEFAULT_PLACES_PROP, null); if (kmlString != null) { Kml kml = KmlMarshaller.getInstance().unmarshal(kmlString); Feature feature = kml.getFeature(); if (feature instanceof Document) { Document document = (Document)feature; List<Feature> features = document.getFeature(); if (!features.isEmpty()) { Feature aFeature = features.get(0); if (aFeature instanceof Folder) { Folder folder = (Folder)aFeature; List<Feature> folderFeatures = folder.getFeature(); if (!folderFeatures.isEmpty()) { Feature firstFeature = folderFeatures.get(0); if (firstFeature instanceof Placemark) { placemark = (Placemark)firstFeature; } } } } } } Color color = PlacemarkUtils.getPlacemarkTextColor(placemark); if (color == null) { PlacemarkUtils.setPlacemarkTextColor(placemark, Color.white); } color = PlacemarkUtils.getPlacemarkColor(placemark, null); if (color == null) { PlacemarkUtils.setPlacemarkColor(placemark, Color.gray); } if (placemark.getExtendedData() == null) { ExtendedData extendedData = placemark.createAndSetExtendedData(); ExtendedDataUtils.putBoolean(extendedData, Constants.IS_TITLE, true); Font defaultFont = PlacemarkUtils.DEFAULT_FONT; PlacemarkUtils.setPlacemarkFont(placemark, defaultFont); } ensureExists(placemark.getExtendedData(), Constants.IS_BUBBLE_FILLED_ID); ExtendedDataUtils.putBoolean(placemark.getExtendedData(), Constants.IS_FEATURE_ON_ID, true); Placemark newPoint = new Placemark(); PlacemarkUtils.copyPlacemark(placemark, newPoint); newPoint.setId(UUID.randomUUID().toString()); return newPoint; } OptionsAccessor(Toolbox toolbox); Placemark getDefaultPlacemark(); void saveDefaultPlacemark(Placemark placemark); static final String DEFAULT_PLACES_PROP; }### Answer: @Test public void testDefault() { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = createToolbox(support, ""); support.replayAll(); OptionsAccessor accessor = new OptionsAccessor(toolbox); Placemark placemark = accessor.getDefaultPlacemark(); IconStyle iconStyle = null; for (StyleSelector selector : placemark.getStyleSelector()) { if (selector instanceof Style) { Style style = (Style)selector; iconStyle = style.getIconStyle(); break; } } assertNotNull(iconStyle); assertNotNull(ExtendedDataUtils.getString(placemark.getExtendedData(), Constants.IS_BUBBLE_FILLED_ID)); assertTrue(Boolean.parseBoolean(ExtendedDataUtils.getString(placemark.getExtendedData(), Constants.IS_FEATURE_ON_ID))); support.verifyAll(); } @Test public void testDotOff() { EasyMockSupport support = new EasyMockSupport(); Toolbox toolbox = createToolbox(support, "<Data name=\"isDotOn\"><value>false</value></Data>"); support.replayAll(); OptionsAccessor accessor = new OptionsAccessor(toolbox); Placemark placemark = accessor.getDefaultPlacemark(); IconStyle iconStyle = null; for (StyleSelector selector : placemark.getStyleSelector()) { if (selector instanceof Style) { Style style = (Style)selector; iconStyle = style.getIconStyle(); break; } } assertNotNull(iconStyle); assertNotNull(ExtendedDataUtils.getString(placemark.getExtendedData(), Constants.IS_BUBBLE_FILLED_ID)); assertTrue(Boolean.parseBoolean(ExtendedDataUtils.getString(placemark.getExtendedData(), Constants.IS_FEATURE_ON_ID))); support.verifyAll(); }
### Question: MyPlacesShapeFileExporter extends AbstractMyPlacesExporter { @Override public Collection<? extends File> getExportFiles(File file) { String path = file.getAbsolutePath().toLowerCase(); boolean found = false; String[] extensions = getMimeType().getFileExtensions(); for (String extension : extensions) { if (path.endsWith("." + extension)) { found = true; break; } } String base = found ? file.getAbsolutePath().substring(0, file.getAbsolutePath().length() - 4) : file.getAbsolutePath(); Collection<File> results = New.collection(4); results.add(found ? file : new File(base + ESRIShapefile.POSTFIX_SHP)); results.add(new File(base + ESRIShapefile.POSTFIX_DBF)); results.add(new File(base + ESRIShapefile.POSTFIX_PRJ)); results.add(new File(base + ESRIShapefile.POSTFIX_SHX)); return results; } @Override File export(File file); @Override Collection<? extends File> getExportFiles(File file); @Override MimeType getMimeType(); }### Answer: @Test public void testGetExportFiles1() { String path1 = "Path/To A/File"; Collection<? extends File> actual = new MyPlacesShapeFileExporter().getExportFiles(new File(path1)); Assert.assertEquals(4, actual.size()); for (String extension : new String[] { ".shp", ".prj", ".shx", ".dbf" }) { boolean found = false; for (File file : actual) { if (file.getAbsolutePath().endsWith(extension)) { found = true; break; } } Assert.assertTrue("Extension " + extension + " was not found.", found); } } @Test public void testGetExportFiles2() { String path1 = "Path/To A/File.SHP"; Collection<? extends File> actual = new MyPlacesShapeFileExporter().getExportFiles(new File(path1)); Assert.assertEquals(4, actual.size()); for (String extension : new String[] { ".SHP", ".prj", ".shx", ".dbf" }) { boolean found = false; for (File file : actual) { if (file.getAbsolutePath().endsWith(extension)) { found = true; break; } } Assert.assertTrue("Extension " + extension + " was not found.", found); } }
### Question: CSVDataSources implements IDataSourceConfig, Cloneable { @Override public CSVDataSources clone() { try { CSVDataSources result = (CSVDataSources)super.clone(); result.myDataSources = StreamUtilities.map(myDataSources, dataSource -> dataSource.clone()); return result; } catch (CloneNotSupportedException e) { throw new ExpectedCloneableException(e); } } List<CSVDataSource> getCSVSourceList(); @Override boolean addSource(IDataSource source); @Override List<IDataSource> getSourceList(); @Override boolean removeSource(IDataSource source); @Override void updateSource(IDataSource source); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override CSVDataSources clone(); }### Answer: @Test public void testClone() { CSVDataSources input = new CSVDataSources(); input.addSource(CSVDataSourceTest.getTestObject()); CSVDataSources clone = input.clone(); Assert.assertTrue(Utilities.notSameInstance(input, clone)); Assert.assertTrue(Utilities.sameInstance(input.getClass(), clone.getClass())); Assert.assertEquals(input, clone); }
### Question: CSVDataSource extends ImportDataSource { @Override public CSVDataSource clone() { CSVDataSource result = (CSVDataSource)super.clone(); result.myParseParameters = myParseParameters.clone(); return result; } CSVDataSource(); CSVDataSource(URI sourceUri); CSVParseParameters getParseParameters(); void setParseParameters(CSVParseParameters parseParameters); String getFileLocalPath(Toolbox toolbox); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override CSVDataSource clone(); @Override String generateTypeKey(); Set<String> getColumnFilter(); }### Answer: @Test public void testClone() { CSVDataSource input = getTestObject(); CSVDataSource clone = input.clone(); Assert.assertTrue(Utilities.notSameInstance(input, clone)); Assert.assertTrue(Utilities.sameInstance(input.getClass(), clone.getClass())); Assert.assertEquals(input, clone); }
### Question: CSVDataSource extends ImportDataSource { @Override public String generateTypeKey() { return StringUtilities.concat("CSV::", getName(), "::", toString(getSourceUri())); } CSVDataSource(); CSVDataSource(URI sourceUri); CSVParseParameters getParseParameters(); void setParseParameters(CSVParseParameters parseParameters); String getFileLocalPath(Toolbox toolbox); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override CSVDataSource clone(); @Override String generateTypeKey(); Set<String> getColumnFilter(); }### Answer: @Test public void testGenerateTypeKey() { CSVDataSource dataSource = getTestObject(); File file = new File("x:\\sample_files\\test.csv"); URI uri = file.toURI(); dataSource.setSourceUri(uri); String expectedTypeKey = "CSV::" + dataSource.getName() + "::" + file.getAbsolutePath(); Assert.assertEquals(expectedTypeKey, dataSource.generateTypeKey()); }
### Question: ColumnDefinitionController extends BaseSelectedColumnObserver { private void applyChanges() { ColumnDefinitionTableModel columnTable = myModel.getDefinitionTableModel(); CSVParseParameters parameters = myModel.getSelectedParameters(); List<String> columnNames = New.list(); List<SpecialColumn> specialColumns = New.list(); List<Integer> ignoreColumns = New.list(); for (int i = 0; i < columnTable.getRowCount(); i++) { ColumnDefinitionRow row = columnTable.getRow(i); columnNames.add(row.getColumnName()); String dataType = row.getDataType(); if (StringUtils.isNotEmpty(dataType)) { SpecialColumn specialColumn = new SpecialColumn(); specialColumn.setColumnIndex(row.getColumnId()); specialColumn.setColumnType(ColumnType.fromString(dataType)); specialColumn.setFormat(row.getFormat()); specialColumns.add(specialColumn); } if (!row.isImport()) { ignoreColumns.add(Integer.valueOf(row.getColumnId())); } } parameters.setColumnNames(columnNames); parameters.getSpecialColumns().clear(); parameters.getSpecialColumns().addAll(specialColumns); parameters.setColumnsToIgnore(ignoreColumns); } ColumnDefinitionController(PreferencesRegistry preferencesRegistry, ColumnDefinitionModel model, CellSampler sampler); @Override void close(); void setAllColumnsImport(boolean imp); @Override void update(Observable o, Object arg); }### Answer: @Test public void testApplyChanges() { EasyMockSupport support = new EasyMockSupport(); PreferencesRegistry registry = createPreferencesRegistry(support); CellSampler sampler = createSampler(support); ColumnDefinitionModel model = createModel(); support.replayAll(); @SuppressWarnings("unused") ColumnDefinitionController controller = new ColumnDefinitionController(registry, model, sampler); ColumnDefinitionTableModel definitionTable = model.getDefinitionTableModel(); CSVParseParameters parameters = model.getSelectedParameters(); ColumnDefinitionRow timeRow = definitionTable.getRow(0); model.setSelectedDefinition(timeRow); timeRow.setFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); SpecialColumn timeColumn = parameters.getSpecialColumn(ColumnType.TIMESTAMP); assertEquals(0, timeColumn.getColumnIndex()); assertEquals("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", timeColumn.getFormat()); ColumnDefinitionRow latRow = definitionTable.getRow(1); model.setSelectedDefinition(latRow); latRow.setDataType(null); assertEquals(2, parameters.getSpecialColumns().size()); ColumnDefinitionRow lonRow = definitionTable.getRow(2); model.setSelectedDefinition(lonRow); lonRow.setColumnName("Longitude"); List<? extends String> columnNames = parameters.getColumnNames(); assertEquals("Longitude", columnNames.get(2)); ColumnDefinitionRow name2 = definitionTable.getRow(4); model.setSelectedDefinition(name2); name2.setIsImport(true); columnNames = parameters.getColumnNames(); assertEquals(ColumnHeaders.TIME.toString(), columnNames.get(0)); assertEquals(ColumnHeaders.LAT.toString(), columnNames.get(1)); assertEquals("Longitude", columnNames.get(2)); assertEquals(ColumnHeaders.NAME.toString(), columnNames.get(3)); assertEquals(ColumnHeaders.NAME2.toString(), columnNames.get(4)); assertEquals(2, parameters.getSpecialColumns().size()); timeColumn = parameters.getSpecialColumn(ColumnType.TIMESTAMP); assertEquals(0, timeColumn.getColumnIndex()); assertEquals("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", timeColumn.getFormat()); SpecialColumn lonColumn = parameters.getSpecialColumn(ColumnType.LON); assertEquals(2, lonColumn.getColumnIndex()); assertEquals("Decimal", lonColumn.getFormat()); assertTrue(parameters.getColumnsToIgnore().isEmpty()); support.verifyAll(); }
### Question: AbstractProjection implements Projection { public void useElevationOrderManager(OrderManager elevationOrderManager) { } static boolean isTerrainLocked(); static void setTerrainLocked(boolean lock); static void toggleTerrainLocked(); @Override long getActivationTimestamp(); @Override long getCreationTimestamp(); @Override double getDistanceFromModelCenterM(GeographicPosition position); @Override double getElevationOnTerrainM(GeographicPosition position); @Override Vector3d getModelCenter(); @Override Matrix4d getModelViewAdjustment(); @Override Projection getSnapshot(); @Override Collection<GeographicBoundingBox> handleElevationChange(ElevationChangedEvent event); @Override Collection<GeographicBoundingBox> handleModelDensityChanged(int density); boolean isModelCenterLocked(); @Override boolean isOutsideModel(Vector3d modelCoordinates); @Override void setActivationTimestamp(); void setModelCenter(Vector3d modelCenter); void setModelCenterLocked(boolean modelCenterLocked); void setProjectionChangeListener(ProjectionChangeSupport.ProjectionChangeListener projectionChangeListener); void useElevationOrderManager(OrderManager elevationOrderManager); static final boolean HIGH_ACCURACY_ALLOWED; static final int HIGH_ACCURACY_MIN_MODEL_DISTANCE; static final int HIGH_ACCURACY_THRESHOLD; }### Answer: @Test public void testUseElevationOrderManager() { myTestObject.useElevationOrderManager(null); }
### Question: ShapeFileConfigurationManager { static ShapeFileDataSource convert1to2(final ShapeFileSource sourceV1) { ShapeFileDataSource sourceV2 = new ShapeFileDataSource(new File(sourceV1.getPath()).toURI()); sourceV2.setActive(sourceV1.isActive()); sourceV2.setVisible(sourceV1.isVisible()); sourceV2.setFromState(sourceV1.isFromStateSource()); sourceV2.getLayerSettings().setName(sourceV1.getName()); sourceV2.getLayerSettings().setLoadsTo(sourceV1.getLoadsTo()); sourceV2.getLayerSettings().setColor(sourceV1.getShapeColor()); sourceV2.getParseParameters().setColumnNames(New.list(sourceV1.getColumnNames())); sourceV2.getParseParameters() .setColumnsToIgnore(sourceV1.getColumnFilter().stream() .map(columnName -> Integer.valueOf(sourceV1.getColumnNames().indexOf(columnName))).sorted() .collect(Collectors.toList())); addSpecialColumns(sourceV2.getParseParameters().getSpecialColumns(), sourceV1); return sourceV2; } ShapeFileConfigurationManager(Preferences shapeFilePreferences); ShapeFileDataSources getConfig(); void saveConfig(ShapeFileDataSources config); }### Answer: @Test public void testConversion() { Assert.assertEquals(createDataSourceV2(), ShapeFileConfigurationManager.convert1to2(createDataSourceV1())); }
### Question: ShapeFileDataSource extends ImportDataSource { @Override public ShapeFileDataSource clone() { ShapeFileDataSource result = (ShapeFileDataSource)super.clone(); result.myParseParameters = myParseParameters.clone(); return result; } ShapeFileDataSource(); ShapeFileDataSource(URI sourceUri); ImportParseParameters getParseParameters(); void setParseParameters(ImportParseParameters parseParameters); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override ShapeFileDataSource clone(); @Override String generateTypeKey(); Set<String> getColumnFilter(); }### Answer: @Test public void testClone() { ShapeFileDataSource input = getTestObject(); ShapeFileDataSource clone = input.clone(); Assert.assertTrue(Utilities.notSameInstance(input, clone)); Assert.assertTrue(Utilities.sameInstance(input.getClass(), clone.getClass())); Assert.assertEquals(input, clone); }
### Question: ShapeFileDataSource extends ImportDataSource { @Override public String generateTypeKey() { return StringUtilities.concat("SHP::", getName(), "::", toString(getSourceUri())); } ShapeFileDataSource(); ShapeFileDataSource(URI sourceUri); ImportParseParameters getParseParameters(); void setParseParameters(ImportParseParameters parseParameters); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override ShapeFileDataSource clone(); @Override String generateTypeKey(); Set<String> getColumnFilter(); }### Answer: @Test public void testGenerateTypeKey() { ShapeFileDataSource dataSource = getTestObject(); File file = new File("x:\\sample_files\\test.shp"); URI uri = file.toURI(); dataSource.setSourceUri(uri); String expectedTypeKey = "SHP::" + dataSource.getName() + "::" + file.getAbsolutePath(); Assert.assertEquals(expectedTypeKey, dataSource.generateTypeKey()); }
### Question: ImportParseParameters extends Observable implements Cloneable { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + HashCodeHelper.getHashCode(myColumnNames); result = prime * result + HashCodeHelper.getHashCode(mySpecialColumns); result = prime * result + HashCodeHelper.getHashCode(myColumnsToIgnore); return result; } ImportParseParameters(); List<? extends String> getColumnNames(); Set<SpecialColumn> getSpecialColumns(); void setColumnNames(List<? extends String> columnNames); List<Integer> getColumnsToIgnore(); void setColumnsToIgnore(List<Integer> columnsToIgnore); boolean hasCategory(final Category category); boolean hasType(final ColumnType type); boolean hasType(final ColumnType... types); boolean isColumnIncluded(SpecialColumn specialColumn, final ColumnType... types); SpecialColumn getSpecialColumn(ColumnType columnType); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override ImportParseParameters clone(); }### Answer: @Test public void testHashCode() { SpecialColumn specialColumn = new SpecialColumn(0, ColumnType.DATE, DATE_FORMAT); myTestObject.getSpecialColumns().add(specialColumn); final int prime = 31; int result = 1; result = prime * result + HashCodeHelper.getHashCode(myTestObject.getColumnNames()); result = prime * result + HashCodeHelper.getHashCode(myTestObject.getSpecialColumns()); result = prime * result + HashCodeHelper.getHashCode(myTestObject.getColumnsToIgnore()); assertEquals(result, myTestObject.hashCode()); }
### Question: ImportParseParameters extends Observable implements Cloneable { public ImportParseParameters() { } ImportParseParameters(); List<? extends String> getColumnNames(); Set<SpecialColumn> getSpecialColumns(); void setColumnNames(List<? extends String> columnNames); List<Integer> getColumnsToIgnore(); void setColumnsToIgnore(List<Integer> columnsToIgnore); boolean hasCategory(final Category category); boolean hasType(final ColumnType type); boolean hasType(final ColumnType... types); boolean isColumnIncluded(SpecialColumn specialColumn, final ColumnType... types); SpecialColumn getSpecialColumn(ColumnType columnType); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override ImportParseParameters clone(); }### Answer: @Test public void testImportParseParameters() { assertNotNull(myTestObject); }
### Question: ImportParseParameters extends Observable implements Cloneable { public Set<SpecialColumn> getSpecialColumns() { return mySpecialColumns; } ImportParseParameters(); List<? extends String> getColumnNames(); Set<SpecialColumn> getSpecialColumns(); void setColumnNames(List<? extends String> columnNames); List<Integer> getColumnsToIgnore(); void setColumnsToIgnore(List<Integer> columnsToIgnore); boolean hasCategory(final Category category); boolean hasType(final ColumnType type); boolean hasType(final ColumnType... types); boolean isColumnIncluded(SpecialColumn specialColumn, final ColumnType... types); SpecialColumn getSpecialColumn(ColumnType columnType); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override ImportParseParameters clone(); }### Answer: @Test public void testGetSpecialColumns() { assertNotNull(myTestObject.getSpecialColumns()); assertTrue(myTestObject.getSpecialColumns().isEmpty()); }
### Question: ImportParseParameters extends Observable implements Cloneable { public boolean hasCategory(final Category category) { return mySpecialColumns.stream().anyMatch(specialColumn -> specialColumn.getColumnType().getCategory() == category); } ImportParseParameters(); List<? extends String> getColumnNames(); Set<SpecialColumn> getSpecialColumns(); void setColumnNames(List<? extends String> columnNames); List<Integer> getColumnsToIgnore(); void setColumnsToIgnore(List<Integer> columnsToIgnore); boolean hasCategory(final Category category); boolean hasType(final ColumnType type); boolean hasType(final ColumnType... types); boolean isColumnIncluded(SpecialColumn specialColumn, final ColumnType... types); SpecialColumn getSpecialColumn(ColumnType columnType); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override ImportParseParameters clone(); }### Answer: @Test public void testHasCategory() { SpecialColumn specialColumn = new SpecialColumn(0, ColumnType.DATE, DATE_FORMAT); myTestObject.getSpecialColumns().add(specialColumn); assertTrue(myTestObject.hasCategory(Category.TEMPORAL)); assertFalse(myTestObject.hasCategory(Category.SPATIAL)); }
### Question: ImportParseParameters extends Observable implements Cloneable { public boolean isColumnIncluded(SpecialColumn specialColumn, final ColumnType... types) { for (ColumnType type : types) { if (specialColumn.getColumnType() == type && !getColumnsToIgnore().contains(Integer.valueOf(specialColumn.getColumnIndex()))) { return true; } } return false; } ImportParseParameters(); List<? extends String> getColumnNames(); Set<SpecialColumn> getSpecialColumns(); void setColumnNames(List<? extends String> columnNames); List<Integer> getColumnsToIgnore(); void setColumnsToIgnore(List<Integer> columnsToIgnore); boolean hasCategory(final Category category); boolean hasType(final ColumnType type); boolean hasType(final ColumnType... types); boolean isColumnIncluded(SpecialColumn specialColumn, final ColumnType... types); SpecialColumn getSpecialColumn(ColumnType columnType); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override ImportParseParameters clone(); }### Answer: @Test public void testIsColumnIncluded() { SpecialColumn specialColumn = new SpecialColumn(0, ColumnType.DATE, DATE_FORMAT); assertTrue(myTestObject.isColumnIncluded(specialColumn, ColumnType.values())); assertFalse(myTestObject.isColumnIncluded(specialColumn)); assertFalse(myTestObject.isColumnIncluded(specialColumn, ColumnType.LAT, ColumnType.LON)); myTestObject.getColumnsToIgnore().add(0); assertFalse(myTestObject.isColumnIncluded(specialColumn, ColumnType.values())); }
### Question: ImportParseParameters extends Observable implements Cloneable { public SpecialColumn getSpecialColumn(ColumnType columnType) { SpecialColumn specialColumn = null; for (SpecialColumn column : mySpecialColumns) { if (column.getColumnType() == columnType) { specialColumn = column; break; } } return specialColumn; } ImportParseParameters(); List<? extends String> getColumnNames(); Set<SpecialColumn> getSpecialColumns(); void setColumnNames(List<? extends String> columnNames); List<Integer> getColumnsToIgnore(); void setColumnsToIgnore(List<Integer> columnsToIgnore); boolean hasCategory(final Category category); boolean hasType(final ColumnType type); boolean hasType(final ColumnType... types); boolean isColumnIncluded(SpecialColumn specialColumn, final ColumnType... types); SpecialColumn getSpecialColumn(ColumnType columnType); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override ImportParseParameters clone(); }### Answer: @Test public void testGetSpecialColumn() { SpecialColumn specialColumn = new SpecialColumn(0, ColumnType.DATE, DATE_FORMAT); myTestObject.getSpecialColumns().add(specialColumn); assertEquals(specialColumn, myTestObject.getSpecialColumn(ColumnType.DATE)); assertNull(myTestObject.getSpecialColumn(ColumnType.LAT)); }
### Question: ImportParseParameters extends Observable implements Cloneable { @Override public String toString() { StringBuilder builder = new StringBuilder(128); builder.append("ImportParseParameters [columnNames=").append(myColumnNames).append(", specialColumns=") .append(mySpecialColumns).append(", columnsToIgnore=").append(myColumnsToIgnore).append(']'); return builder.toString(); } ImportParseParameters(); List<? extends String> getColumnNames(); Set<SpecialColumn> getSpecialColumns(); void setColumnNames(List<? extends String> columnNames); List<Integer> getColumnsToIgnore(); void setColumnsToIgnore(List<Integer> columnsToIgnore); boolean hasCategory(final Category category); boolean hasType(final ColumnType type); boolean hasType(final ColumnType... types); boolean isColumnIncluded(SpecialColumn specialColumn, final ColumnType... types); SpecialColumn getSpecialColumn(ColumnType columnType); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override ImportParseParameters clone(); }### Answer: @Test public void testToString() { assertEquals("ImportParseParameters [columnNames=[], specialColumns=[], columnsToIgnore=[]]", myTestObject.toString()); }
### Question: AbstractGeographicProjection extends AbstractProjection { @Override public List<Vector3d> convertLinesToModel(List<? extends GeographicPosition> positions, int limit, LineType type, Vector3d modelCenter) { Utilities.checkNull(modelCenter, MODEL_CENTER_PARAMETER_NAME); List<Vector3d> positionList = New.list(); int vertexCount = positions.size(); Pair<Tessera<GeographicPosition>, ProjectionCursor> tessera = null; Vector3d previousModelPosition = null; for (int i = 1; i < limit; ++i) { int lineEndIndex = i % vertexCount; GeographicPosition lineEnd = positions.get(lineEndIndex); if (tessera == null) { tessera = convertLineToModel(positions.get(0), lineEnd, type, modelCenter); } else { tessera = convertLineToModel(tessera.getSecondObject(), lineEnd, type, modelCenter); } if (tessera.getFirstObject() != null) { List<? extends TesseraVertex<GeographicPosition>> modelVertices = tessera.getFirstObject().getTesseraVertices(); int modelVertexCount = modelVertices.size(); if (modelVertexCount > 0) { if (i == 1) { Vector3d modelPos = ((GeographicTesseraVertex)modelVertices.get(0)).getModelCoordinates(); if (previousModelPosition == null || !modelPos.equals(previousModelPosition)) { positionList.add(modelPos); previousModelPosition = modelPos; } } for (int j = 1; j < modelVertexCount; j++) { Vector3d modelPos = ((GeographicTesseraVertex)modelVertices.get(j)).getModelCoordinates(); if (previousModelPosition == null || !modelPos.equals(previousModelPosition)) { positionList.add(modelPos); previousModelPosition = modelPos; } } } } } return positionList; } @Override List<Vector3d> convertLinesToModel(List<? extends GeographicPosition> positions, int limit, LineType type, Vector3d modelCenter); @Override Pair<Tessera<GeographicPosition>, ProjectionCursor> convertLineToModel(GeographicPosition start, GeographicPosition end, LineType type, Vector3d modelCenter); @Override Pair<Tessera<GeographicPosition>, ProjectionCursor> convertLineToModel(ProjectionCursor start, GeographicPosition end, LineType type, Vector3d modelCenter); @Override TesseraList<? extends GeographicProjectedTesseraVertex> convertPolygonToModelMesh(Polygon polygon, Vector3d modelCenter); @Override Collection<Vector3d> convertPositionsToModel(Collection<? extends GeographicPosition> positions, Vector3d modelCenter); @Override TesseraList<? extends GeographicProjectedTesseraVertex> convertQuadToModel(GeographicPosition vert1, GeographicPosition vert2, GeographicPosition vert3, GeographicPosition vert4, Vector3d modelCenter); @Override TesseraList<? extends GeographicProjectedTesseraVertex> convertTriangleToModel(GeographicPosition vert1, GeographicPosition vert2, GeographicPosition vert3, Vector3d modelCenter); @Override Ellipsoid getBoundingEllipsoid(BoundingBox<GeographicPosition> bbox, Vector3d modelCenter, boolean forceGenerate); @Override Sphere getBoundingSphere(BoundingBox<GeographicPosition> bbox, Vector3d modelCenter, boolean forceGenerate); @Override double getMinimumTerrainDistance(Viewer view); @Override double getModelHeight(); @Override double getModelWidth(); @Override void resetProjection(boolean highAccuracy); }### Answer: @Test @Ignore public void testConvertLinesToModel() { fail(NOT_YET_IMPLEMENTED); }
### Question: ImportParseParameters extends Observable implements Cloneable { @Override public ImportParseParameters clone() { try { ImportParseParameters result = (ImportParseParameters)super.clone(); result.myColumnNames = New.list(myColumnNames); result.mySpecialColumns = New.set(StreamUtilities.map(mySpecialColumns, specialColumn -> specialColumn.clone())); result.myColumnsToIgnore = New.list(myColumnsToIgnore); return result; } catch (CloneNotSupportedException e) { throw new ExpectedCloneableException(e); } } ImportParseParameters(); List<? extends String> getColumnNames(); Set<SpecialColumn> getSpecialColumns(); void setColumnNames(List<? extends String> columnNames); List<Integer> getColumnsToIgnore(); void setColumnsToIgnore(List<Integer> columnsToIgnore); boolean hasCategory(final Category category); boolean hasType(final ColumnType type); boolean hasType(final ColumnType... types); boolean isColumnIncluded(SpecialColumn specialColumn, final ColumnType... types); SpecialColumn getSpecialColumn(ColumnType columnType); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override ImportParseParameters clone(); }### Answer: @Test public void testClone() { assertEquals(myTestObject, myTestObject.clone()); }
### Question: LayerSettings implements Cloneable { @Override public LayerSettings clone() { try { return (LayerSettings)super.clone(); } catch (CloneNotSupportedException e) { throw new ExpectedCloneableException(e); } } LayerSettings(); LayerSettings(String name); String getName(); void setName(String name); LoadsTo getLoadsTo(); void setLoadsTo(LoadsTo loadsTo); boolean isTimelineEnabled(); void setTimelineEnabled(boolean timelineEnabled); boolean isMetadataEnabled(); void setMetadataEnabled(boolean metadataEnabled); Color getColor(); void setColor(Color color); boolean isActive(); void setActive(boolean isActive); boolean isFieldSetByUser(String field); void setFieldSetByUser(String field); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override LayerSettings clone(); static String LOADS_TO; }### Answer: @Test public void testClone() { LayerSettings input = getTestObject(); LayerSettings clone = input.clone(); Assert.assertTrue(Utilities.notSameInstance(input, clone)); Assert.assertTrue(Utilities.sameInstance(input.getClass(), clone.getClass())); Assert.assertEquals(input, clone); }
### Question: TimeFormatter extends BaseDateTimeFormatter { @Override public String getSystemFormat() { String systemFormat = super.getSystemFormat(); int timeIndex = systemFormat.indexOf('H'); systemFormat = systemFormat.substring(timeIndex, systemFormat.length()); return systemFormat; } TimeFormatter(PreferencesRegistry preferencesRegistry); @Override String getSystemFormat(); @Override void saveNewFormat(String format); }### Answer: @Test public void testGetSystemFormat() { StringBuilder formatStringBuilder = new StringBuilder("HH:mm:ss"); for (int i = 0; i < 4; i++) { EasyMockSupport support = new EasyMockSupport(); PreferencesRegistry registry = TestDateTimeUtils.createPreferencesRegistry(support, i); support.replayAll(); TimeFormatter formatter = new TimeFormatter(registry); assertEquals(formatStringBuilder.toString(), formatter.getSystemFormat()); support.verifyAll(); if (i == 0) { formatStringBuilder.append('.'); } formatStringBuilder.append('S'); } }
### Question: TimeFormatter extends BaseDateTimeFormatter { @Override public void saveNewFormat(String format) { if (!format.contains("y") && !format.contains("M") && !format.contains("d")) { super.saveNewFormat(format); } } TimeFormatter(PreferencesRegistry preferencesRegistry); @Override String getSystemFormat(); @Override void saveNewFormat(String format); }### Answer: @Test public void testSaveFormat() { EasyMockSupport support = new EasyMockSupport(); String newFormat = "HHmmss"; String dateFormat = "yyyyMMdd"; String dateTimeFormat = "yyyyMMdd HHmmss"; PreferencesRegistry prefsRegistry = TestDateTimeUtils.createSaveRegistry(support, newFormat, Type.TIME); support.replayAll(); TimeFormatter formatter = new TimeFormatter(prefsRegistry); formatter.saveNewFormat(newFormat); formatter.saveNewFormat(newFormat); formatter.saveNewFormat(dateFormat); formatter.saveNewFormat(dateTimeFormat); support.verifyAll(); }
### Question: DateFormatter extends BaseDateTimeFormatter { @Override public String getSystemFormat() { String systemFormat = super.getSystemFormat(); int timeIndex = systemFormat.indexOf('H'); systemFormat = systemFormat.substring(0, timeIndex - 1); systemFormat = systemFormat.trim(); return systemFormat; } DateFormatter(PreferencesRegistry preferencesRegistry); @Override String getSystemFormat(); @Override void saveNewFormat(String format); }### Answer: @Test public void testGetSystemFormat() { for (int i = 0; i < 4; i++) { EasyMockSupport support = new EasyMockSupport(); PreferencesRegistry registry = TestDateTimeUtils.createPreferencesRegistry(support, i); support.replayAll(); DateFormatter formatter = new DateFormatter(registry); assertEquals(DateTimeFormats.DATE_FORMAT, formatter.getSystemFormat()); support.verifyAll(); } }
### Question: DateFormatter extends BaseDateTimeFormatter { @Override public void saveNewFormat(String format) { if (!format.contains("H") && !format.contains("m") && !format.contains("s") && !format.contains("S") && !format.contains("h")) { super.saveNewFormat(format); } } DateFormatter(PreferencesRegistry preferencesRegistry); @Override String getSystemFormat(); @Override void saveNewFormat(String format); }### Answer: @Test public void testSaveFormat() { EasyMockSupport support = new EasyMockSupport(); String newFormat = "yyyyMMdd"; String timeStampFormat = "yyyyHH"; String timeFormat = "HH"; PreferencesRegistry prefsRegistry = TestDateTimeUtils.createSaveRegistry(support, newFormat, Type.DATE); support.replayAll(); DateFormatter formatter = new DateFormatter(prefsRegistry); formatter.saveNewFormat(newFormat); formatter.saveNewFormat(newFormat); formatter.saveNewFormat(timeStampFormat); formatter.saveNewFormat(timeFormat); support.verifyAll(); }
### Question: DateTimeCellSampler extends BaseSingleCellSampler { @Override public List<? extends String> getHeaderCells() { return ourHeaderCells; } DateTimeCellSampler(List<String> data); @Override List<? extends String> getHeaderCells(); }### Answer: @Test public void testHeaderCells() { DateTimeCellSampler sampler = new DateTimeCellSampler(New.<String>list()); List<? extends String> headers = sampler.getHeaderCells(); assertEquals(1, headers.size()); assertEquals("Date", headers.get(0)); }
### Question: DateTimeFormatter extends BaseDateTimeFormatter { @Override public void saveNewFormat(String format) { boolean containsTime = format.contains("H") || format.contains("m") || format.contains("s") || format.contains("S") || format.contains("h"); boolean containsDate = format.contains("y") || format.contains("M") || format.contains("d"); if (containsTime && containsDate) { super.saveNewFormat(format); } } DateTimeFormatter(PreferencesRegistry preferencesRegistry); @Override void saveNewFormat(String format); }### Answer: @Test public void testSaveFormat() { EasyMockSupport support = new EasyMockSupport(); String newFormat = "yyyyMMdd HHmmss"; String dateFormat = "yyyyMMdd"; String timeFormat = "HHmmss"; PreferencesRegistry prefsRegistry = TestDateTimeUtils.createSaveRegistry(support, newFormat, Type.TIMESTAMP); support.replayAll(); DateTimeFormatter formatter = new DateTimeFormatter(prefsRegistry); formatter.saveNewFormat(newFormat); formatter.saveNewFormat(newFormat); formatter.saveNewFormat(dateFormat); formatter.saveNewFormat(timeFormat); support.verifyAll(); }
### Question: CellFormatterFactory { public CellFormatter getFormatter(ColumnType columnType, PreferencesRegistry preferencesRegistry) { CellFormatter formatter = myFormatterMap.get(columnType); if (formatter == null) { if (columnType == ColumnType.DOWN_TIMESTAMP || columnType == ColumnType.TIMESTAMP) { formatter = new DateTimeFormatter(preferencesRegistry); } else if (columnType == ColumnType.DATE || columnType == ColumnType.DOWN_DATE) { formatter = new DateFormatter(preferencesRegistry); } else if (columnType == ColumnType.TIME || columnType == ColumnType.DOWN_TIME) { formatter = new TimeFormatter(preferencesRegistry); } else if (columnType == ColumnType.LAT) { formatter = new LatitudeFormatter(preferencesRegistry); } else if (columnType == ColumnType.LON) { formatter = new LongitudeFormatter(preferencesRegistry); } else if (columnType == ColumnType.POSITION) { formatter = new PositionFormatter(preferencesRegistry); } else if (columnType == ColumnType.COLOR) { formatter = new ColorFormatter(); } if (formatter != null) { myFormatterMap.put(columnType, formatter); } } return formatter; } CellFormatter getFormatter(ColumnType columnType, PreferencesRegistry preferencesRegistry); String getSystemFormat(ColumnType columnType, PreferencesRegistry preferencesRegistry); }### Answer: @Test public void testCreateFormatterDateTime() { EasyMockSupport support = new EasyMockSupport(); PreferencesRegistry registry = TestDateTimeUtils.createPreferencesRegistry(support); support.replayAll(); CellFormatterFactory factory = new CellFormatterFactory(); CellFormatter formatter = factory.getFormatter(ColumnType.DATE, registry); assertTrue(formatter instanceof DateFormatter); formatter = factory.getFormatter(ColumnType.TIME, registry); assertTrue(formatter instanceof TimeFormatter); formatter = factory.getFormatter(ColumnType.TIMESTAMP, registry); assertTrue(formatter instanceof DateTimeFormatter); formatter = factory.getFormatter(ColumnType.LAT, registry); assertTrue(formatter instanceof LatitudeFormatter); formatter = factory.getFormatter(ColumnType.LON, registry); assertTrue(formatter instanceof LongitudeFormatter); formatter = factory.getFormatter(ColumnType.POSITION, registry); assertTrue(formatter instanceof PositionFormatter); support.verifyAll(); } @Test public void testCreateFormatterUnknown() { CellFormatterFactory factory = new CellFormatterFactory(); CellFormatter nullFormatter = factory.getFormatter(ColumnType.OTHER, null); assertNull(nullFormatter); }
### Question: AbstractGeographicProjection extends AbstractProjection { @Override public TesseraList<? extends GeographicProjectedTesseraVertex> convertPolygonToModelMesh(Polygon polygon, Vector3d modelCenter) { Utilities.checkNull(modelCenter, MODEL_CENTER_PARAMETER_NAME); SimpleTesseraBlockBuilder<GeographicTesseraVertex> triBuilder = new SimpleTesseraBlockBuilder<>(3, Vector3d.ORIGIN); VertexGenerator<GeographicTesseraVertex> vertexGenerator = new SimpleGeographicVertexGenerator(null, this, modelCenter); PolygonTriangulationUtil.triangulatePolygon(triBuilder, polygon, vertexGenerator); List<TesseraBlock<GeographicTesseraVertex>> tess = New.list(1); if (!triBuilder.getBlockVertices().isEmpty()) { tess.add(new TesseraBlock<>(triBuilder, false)); } return new TesseraList<>(tess); } @Override List<Vector3d> convertLinesToModel(List<? extends GeographicPosition> positions, int limit, LineType type, Vector3d modelCenter); @Override Pair<Tessera<GeographicPosition>, ProjectionCursor> convertLineToModel(GeographicPosition start, GeographicPosition end, LineType type, Vector3d modelCenter); @Override Pair<Tessera<GeographicPosition>, ProjectionCursor> convertLineToModel(ProjectionCursor start, GeographicPosition end, LineType type, Vector3d modelCenter); @Override TesseraList<? extends GeographicProjectedTesseraVertex> convertPolygonToModelMesh(Polygon polygon, Vector3d modelCenter); @Override Collection<Vector3d> convertPositionsToModel(Collection<? extends GeographicPosition> positions, Vector3d modelCenter); @Override TesseraList<? extends GeographicProjectedTesseraVertex> convertQuadToModel(GeographicPosition vert1, GeographicPosition vert2, GeographicPosition vert3, GeographicPosition vert4, Vector3d modelCenter); @Override TesseraList<? extends GeographicProjectedTesseraVertex> convertTriangleToModel(GeographicPosition vert1, GeographicPosition vert2, GeographicPosition vert3, Vector3d modelCenter); @Override Ellipsoid getBoundingEllipsoid(BoundingBox<GeographicPosition> bbox, Vector3d modelCenter, boolean forceGenerate); @Override Sphere getBoundingSphere(BoundingBox<GeographicPosition> bbox, Vector3d modelCenter, boolean forceGenerate); @Override double getMinimumTerrainDistance(Viewer view); @Override double getModelHeight(); @Override double getModelWidth(); @Override void resetProjection(boolean highAccuracy); }### Answer: @Test @Ignore public void testConvertPolygonToModelMesh() { fail(NOT_YET_IMPLEMENTED); }