Datasets:
Minata
/
1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files
xet
Community
1
method2testcases
stringlengths
118
6.63k
### Question: LongitudeFormatter extends BaseLocationFormatter { @Override public Object formatCell(String val, String fmtString) throws ParseException { if (val == null || val.isEmpty()) { return null; } CoordFormat fmt = CoordFormat.fromString(fmtString); double longitude = LatLonAltParser.parseLon(val, fmt); if (Double.isNaN(longitude)) { return Constants.ERROR_LABEL; } if (fmt == CoordFormat.DECIMAL) { return String.valueOf(longitude); } if (fmt == CoordFormat.DDM) { return LatLonAlt.lonToDdmString(longitude, 3); } return DegreesMinutesSeconds.getShortLabelString(longitude, 16, 3, 'E', 'W'); } LongitudeFormatter(PreferencesRegistry registry); @Override Object formatCell(String val, String fmtString); @Override String getFormat(List<String> values); }### Answer: @Test public void testFormatCell() throws ParseException { LongitudeFormatter formatter = new LongitudeFormatter(null); String decimalLongitude = "-105.39274694444445"; String longitude = (String)formatter.formatCell(decimalLongitude, "Decimal"); assertEquals(decimalLongitude, longitude); longitude = (String)formatter.formatCell("W1052333.889", CoordFormat.DMS.toString()); assertEquals(" 105°23'33.889\"W", longitude); assertNull(formatter.formatCell(null, CoordFormat.DMS.toString())); }
### Question: LongitudeFormatter extends BaseLocationFormatter { @Override public String getFormat(List<String> values) { LongitudeCellSampler sampler = new LongitudeCellSampler(values); LocationDetector detector = new LocationDetector(myRegistry); ValuesWithConfidence<LocationResults> valueWithConf = detector.detect(sampler); LocationResults results = valueWithConf.getBestValue(); LatLonColumnResults result = results == null ? null : results.getMostLikelyLatLonColumnPair(); PotentialLocationColumn column = result == null ? null : result.getLonColumn(); if (column == null) { return super.getFormat(values); } CoordFormat fmt = column.getLonFormat(); if (fmt != null) { return fmt.toString(); } return null; } LongitudeFormatter(PreferencesRegistry registry); @Override Object formatCell(String val, String fmtString); @Override String getFormat(List<String> values); }### Answer: @Test public void testGetFormat() { PreferencesRegistry registry = LocationTestUtils.getPrefsRegistry(); LongitudeFormatter formatter = new LongitudeFormatter(registry); String format = formatter.getFormat(New.list("-105.3927469444")); assertEquals(CoordFormat.DECIMAL.toString(), format); format = formatter.getFormat(New.list("105°23'33.889\"W")); assertEquals(CoordFormat.DMS.toString(), format); }
### Question: PositionFormatter extends BaseLocationFormatter { @Override public Object formatCell(String cellValue, String fmtString) throws ParseException { LatLonAlt value = LatLonAlt.parse(cellValue); if (value == null) { return null; } CoordFormat fmt = CoordFormat.fromString(fmtString); double latitude = value.getLatD(); double longitude = value.getLonD(); if (fmt == CoordFormat.DMS) { return degToDms(latitude, 'N', 'S') + " " + degToDms(longitude, 'E', 'W'); } else if (fmt == CoordFormat.DDM) { return LatLonAlt.latToDdmString(latitude, 3) + " " + LatLonAlt.lonToDdmString(longitude, 3); } else { return latitude + " " + longitude; } } PositionFormatter(PreferencesRegistry registry); @Override Object formatCell(String cellValue, String fmtString); @Override String getFormat(List<String> values); }### Answer: @Test public void testFormatCell() throws ParseException { PositionFormatter formatter = new PositionFormatter(null); String position = "N314046 E0302407"; String expectedPosition = "31.679444444444446 30.401944444444442"; String actualPosition = (String)formatter.formatCell(position, "Decimal"); assertEquals(expectedPosition, actualPosition); assertNull(formatter.formatCell(null, null)); actualPosition = (String)formatter.formatCell(position, CoordFormat.DMS.toString()); assertEquals(" 31°40'46.000\"N 30°24'07.000\"E", actualPosition); }
### Question: PositionFormatter extends BaseLocationFormatter { @Override public String getFormat(List<String> values) { PositionCellSampler sampler = new PositionCellSampler(values); LocationDetector detector = new LocationDetector(myRegistry); ValuesWithConfidence<LocationResults> valueWithConf = detector.detect(sampler); LocationResults results = valueWithConf.getBestValue(); PotentialLocationColumn column = results == null ? null : results.getMostLikelyLocationColumn(); CoordFormat fmt = column == null ? null : column.getLatFormat(); if (fmt != null) { return fmt.toString(); } return null; } PositionFormatter(PreferencesRegistry registry); @Override Object formatCell(String cellValue, String fmtString); @Override String getFormat(List<String> values); }### Answer: @Test public void testGetFormat() { PreferencesRegistry registry = LocationTestUtils.getPrefsRegistry(); PositionFormatter formatter = new PositionFormatter(registry); String format = formatter.getFormat(New.list("39.9358858333 -105.3927469444")); assertEquals("Decimal", format); format = formatter.getFormat(New.list("39°56'9.189\"N 105°23'33.889\"W")); assertEquals("DMS", format); }
### Question: LatitudeCellSampler extends BaseSingleCellSampler { @Override public List<? extends String> getHeaderCells() { return ourHeaderCells; } LatitudeCellSampler(List<String> data); @Override List<? extends String> getHeaderCells(); }### Answer: @Test public void testGetHeaderCells() { LatitudeCellSampler sampler = new LatitudeCellSampler(New.<String>list()); List<? extends String> headers = sampler.getHeaderCells(); assertEquals(2, headers.size()); assertEquals("LAT", headers.get(0)); assertEquals("LON", headers.get(1)); }
### Question: PositionCellSampler extends BaseSingleCellSampler { @Override public List<? extends String> getHeaderCells() { return ourHeaderCells; } PositionCellSampler(List<String> data); @Override List<? extends String> getHeaderCells(); }### Answer: @Test public void testGetHeaderCells() { PositionCellSampler sampler = new PositionCellSampler(New.<String>list()); List<? extends String> headers = sampler.getHeaderCells(); assertEquals(1, headers.size()); assertEquals("Location", headers.get(0)); }
### Question: LongitudeCellSampler extends BaseSingleCellSampler { @Override public List<? extends String> getHeaderCells() { return ourHeaders; } LongitudeCellSampler(List<String> data); @Override List<? extends String> getHeaderCells(); }### Answer: @Test public void testGetHeaderCells() { LongitudeCellSampler sampler = new LongitudeCellSampler(New.<String>list()); List<? extends String> headers = sampler.getHeaderCells(); assertEquals(2, headers.size()); assertEquals("LON", headers.get(0)); assertEquals("LAT", headers.get(1)); }
### Question: LatitudeFormatter extends BaseLocationFormatter { @Override public Object formatCell(String val, String fmtString) throws ParseException { if (val == null || val.isEmpty()) { return null; } CoordFormat fmt = CoordFormat.fromString(fmtString); double latitude = LatLonAltParser.parseLat(val, fmt); if (Double.isNaN(latitude)) { return Constants.ERROR_LABEL; } if (fmt == CoordFormat.DECIMAL) { return String.valueOf(latitude); } if (fmt == CoordFormat.DDM) { return LatLonAlt.latToDdmString(latitude, 3); } return DegreesMinutesSeconds.getShortLabelString(latitude, 16, 3, 'N', 'S'); } LatitudeFormatter(PreferencesRegistry registry); @Override Object formatCell(String val, String fmtString); @Override String getFormat(List<String> values); }### Answer: @Test public void testFormatCell() throws ParseException { LatitudeFormatter formatter = new LatitudeFormatter(null); String decimalLatitude = "39.93588583333333"; String latitude = (String)formatter.formatCell(decimalLatitude, "Decimal"); assertEquals(decimalLatitude, latitude); latitude = (String)formatter.formatCell("N395609.189", CoordFormat.DMS.toString()); assertEquals(" 39°56'09.189\"N", latitude); assertNull(formatter.formatCell(null, CoordFormat.DMS.toString())); }
### Question: LatitudeFormatter extends BaseLocationFormatter { @Override public String getFormat(List<String> values) { LatitudeCellSampler sampler = new LatitudeCellSampler(values); LocationDetector detector = new LocationDetector(myRegistry); ValuesWithConfidence<LocationResults> valueWithConf = detector.detect(sampler); LocationResults results = valueWithConf.getBestValue(); LatLonColumnResults result = results == null ? null : results.getMostLikelyLatLonColumnPair(); PotentialLocationColumn column = result == null ? null : result.getLatColumn(); if (column == null) { return super.getFormat(values); } CoordFormat fmt = column.getLatFormat(); if (fmt != null) { return fmt.toString(); } return null; } LatitudeFormatter(PreferencesRegistry registry); @Override Object formatCell(String val, String fmtString); @Override String getFormat(List<String> values); }### Answer: @Test public void testGetFormat() { PreferencesRegistry registry = LocationTestUtils.getPrefsRegistry(); LatitudeFormatter formatter = new LatitudeFormatter(registry); String format = formatter.getFormat(New.list("39.9358858333")); assertEquals(CoordFormat.DECIMAL.toString(), format); format = formatter.getFormat(New.list("39°56'9.189\"N")); assertEquals(CoordFormat.DMS.toString(), format); }
### Question: AbstractGeographicProjection extends AbstractProjection { @Override public Collection<Vector3d> convertPositionsToModel(Collection<? extends GeographicPosition> positions, Vector3d modelCenter) { Utilities.checkNull(modelCenter, MODEL_CENTER_PARAMETER_NAME); Collection<Vector3d> vertices = New.list(positions.size()); for (GeographicPosition geoPos : positions) { vertices.add(convertToModel(geoPos, modelCenter)); } return vertices; } @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 public void testConvertPositionsToModel() { Collection<GeographicPosition> positions = new ArrayList<>(); positions.add(new GeographicPosition(LatLonAlt.createFromDegrees(0, 0))); Collection<Vector3d> results = myTestObject.convertPositionsToModel(positions, Vector3d.ORIGIN); assertEquals(1, results.size()); assertEquals(Vector3d.ORIGIN, results.iterator().next()); }
### Question: CSVParseParameters extends Observable implements Cloneable { @Override public CSVParseParameters clone() { try { CSVParseParameters result = (CSVParseParameters)super.clone(); result.myColumnNames = New.list(myColumnNames); result.mySpecialColumns = New.set(StreamUtilities.map(mySpecialColumns, specialColumn -> specialColumn.clone())); result.myColumnsToIgnore = New.list(myColumnsToIgnore); result.myColumnInfo = StreamUtilities.map(myColumnInfo, columnInfo -> columnInfo.clone()); return result; } catch (CloneNotSupportedException e) { throw new ExpectedCloneableException(e); } } CSVParseParameters(); CSVParseParameters(CSVParseParameters parameters); CSVColumnFormat getColumnFormat(); List<? extends String> getColumnNames(); String getCommentIndicator(); Integer getDataStartLine(); Integer getHeaderLine(); Set<SpecialColumn> getSpecialColumns(); void setColumnFormat(CSVColumnFormat columnFormat); void setColumnNames(List<? extends String> columnNames); void setCommentIndicator(String commentIndicator); void setDataStartLine(Integer dataStartLine); void setHeaderLine(Integer headerLine); List<Integer> getColumnsToIgnore(); void setColumnsToIgnore(List<Integer> columnsToIgnore); List<CSVColumnInfo> getColumnClasses(); void setColumnClasses(List<CSVColumnInfo> columnClasses); void setFiresUpdates(boolean update); boolean hasCategory(final Category category); boolean hasType(final ColumnType type); boolean hasType(final ColumnType... types); SpecialColumn getSpecialColumn(ColumnType columnType); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @Override CSVParseParameters clone(); @XmlTransient static final String COLUMNFORMAT; @XmlTransient static final String COMMENTINDICATOR; @XmlTransient static final String DATASTARTLINE; @XmlTransient static final String HEADERLINE; }### Answer: @Test public void testClone() { CSVParseParameters input = getTestObject(); CSVParseParameters clone = input.clone(); Assert.assertTrue(Utilities.notSameInstance(input, clone)); Assert.assertTrue(Utilities.sameInstance(input.getClass(), clone.getClass())); Assert.assertEquals(input, clone); }
### Question: Migrator { public void migrate(ConfigurationProvider provider, PreferencesRegistry registry) { Preferences newPreferences = registry.getPreferences(MantleConstants.USER_DATE_FORMAT_CONFIG_FILE_TOPIC); boolean alreadyMigrated = newPreferences.getBoolean(ourMigratedKey, false); if (!alreadyMigrated) { Preferences preferences = registry.getPreferences("DateFormatConfiguration"); DateFormatsConfig oldConfig = preferences.getJAXBObject(DateFormatsConfig.class, MantleConstants.USER_DATE_FORMAT_CONFIG_FILE_KEY, null); DateFormatsConfig newConfig = provider.getDateFormats(); List<DateFormat> formatsToAdd = New.list(); if (oldConfig != null) { Map<String, DateFormat> formats = mapFormats(newConfig); for (DateFormat format : oldConfig.getFormats()) { if (!formats.containsKey(format.getSdf())) { boolean isValid = isFormatValid(format); if (isValid) { formatsToAdd.add(format); } } } if (!formatsToAdd.isEmpty()) { provider.saveFormats(formatsToAdd); } } newPreferences.putBoolean(ourMigratedKey, true, this); } } void migrate(ConfigurationProvider provider, PreferencesRegistry registry); }### Answer: @Test public void testMigrateNewInstall() { EasyMockSupport support = new EasyMockSupport(); ConfigurationProvider provider = createProvider(support, createNewFormats()); PreferencesRegistry registry = createRegistry(support, null, false); support.replayAll(); Migrator migrator = new Migrator(); migrator.migrate(provider, registry); support.verifyAll(); } @SuppressWarnings("unchecked") @Test public void testMigrate() { EasyMockSupport support = new EasyMockSupport(); ConfigurationProvider provider = createProvider(support, createNewFormats()); provider.saveFormats(EasyMock.isA(Collection.class)); EasyMock.expectLastCall().andAnswer(new IAnswer<Void>() { @Override public Void answer() { Collection<DateFormat> savedFormats = (Collection<DateFormat>)EasyMock.getCurrentArguments()[0]; assertSavedFormats(savedFormats); return null; } }); PreferencesRegistry registry = createRegistry(support, createOldFormats(), false); support.replayAll(); Migrator migrator = new Migrator(); migrator.migrate(provider, registry); support.verifyAll(); } @Test public void testAlreadyMigrated() { EasyMockSupport support = new EasyMockSupport(); ConfigurationProvider provider = support.createMock(ConfigurationProvider.class); PreferencesRegistry registry = createRegistry(support, null, true); support.replayAll(); Migrator migrator = new Migrator(); migrator.migrate(provider, registry); support.verifyAll(); }
### Question: ConfigurationProviderImpl implements ConfigurationProvider { @Override public synchronized DateFormatsConfig getDateFormats() { Preferences preferences = myPreferencesRegistry.getPreferences(MantleConstants.USER_DATE_FORMAT_CONFIG_FILE_TOPIC); return preferences.getJAXBObject(DateFormatsConfig.class, MantleConstants.USER_DATE_FORMAT_CONFIG_FILE_KEY, new DateFormatsConfig()); } ConfigurationProviderImpl(PreferencesRegistry prefsRegistry); @Override synchronized DateFormatsConfig getDateFormats(); @Override void saveFormat(DateFormat format); @Override List<String> getExcludeColumns(); @Override synchronized void saveFormats(Collection<DateFormat> formats); }### Answer: @Test public void testGetDateFormats() { EasyMockSupport support = new EasyMockSupport(); PreferencesRegistry prefsRegistry = createPreferencesRegistry(support); support.replayAll(); ConfigurationProviderImpl provider = new ConfigurationProviderImpl(prefsRegistry); DateFormatsConfig config = provider.getDateFormats(); assertEquals(ourConfig, config); support.verifyAll(); }
### Question: ConfigurationProviderImpl implements ConfigurationProvider { @Override public void saveFormat(DateFormat format) { saveFormats(New.list(format)); } ConfigurationProviderImpl(PreferencesRegistry prefsRegistry); @Override synchronized DateFormatsConfig getDateFormats(); @Override void saveFormat(DateFormat format); @Override List<String> getExcludeColumns(); @Override synchronized void saveFormats(Collection<DateFormat> formats); }### Answer: @Test public void testSaveDateFormat() { EasyMockSupport support = new EasyMockSupport(); DateFormat existingFormat = new DateFormat(); existingFormat.setSdf("existing"); ourConfig.addFormat(existingFormat); DateFormat format = new DateFormat(); PreferencesRegistry prefsRegistry = createSaveRegistry(support, format); support.replayAll(); ConfigurationProviderImpl provider = new ConfigurationProviderImpl(prefsRegistry); provider.saveFormat(format); format.setSdf("existing"); provider.saveFormat(format); format.setSdf("save"); provider.saveFormat(format); support.verifyAll(); }
### Question: ImportableColumnController { public void detectNonImportableColumns(CSVParseParameters parameters, PreferencesRegistry registry) { List<String> metaColumns = new ArrayList<String>(Arrays.asList(MetaColumn.COLOR, MetaColumn.HILIGHT, MetaColumn.INDEX, MetaColumn.LOB_VISIBLE, MetaColumn.MGRS_DERIVED, MetaColumn.SELECTED, MetaColumn.VISIBLE)); if (parameters.getColumnNames() != null) { Map<String, Integer> upperCasedColumnNames = New.map(); int index = 0; for (String columnName : parameters.getColumnNames()) { upperCasedColumnNames.put(columnName.toUpperCase(), Integer.valueOf(index)); index++; } for (String columnName : parameters.getColumnNames()) { String key = ourKeyPrefix + columnName.toLowerCase(); List<String> columnsToNotImport = CSVColumnPrefsUtil.getCustomKeys(registry, key); List<String> currentParams = new ArrayList<String>(parameters.getColumnNames()); List<String> newParams = new ArrayList<String>(); currentParams.forEach(e -> { if (metaColumns.contains(e)) { e = e + "_user"; } newParams.add(e); }); parameters.setColumnNames(newParams); if (columnsToNotImport != null) { for (String columns : columnsToNotImport) { String upperCaseColumn = columns.toUpperCase(); if (upperCasedColumnNames.containsKey(upperCaseColumn)) { parameters.getColumnsToIgnore().add(upperCasedColumnNames.get(upperCaseColumn)); } } } } } } void detectNonImportableColumns(CSVParseParameters parameters, PreferencesRegistry registry); }### Answer: @Test public void testDetectNonImportableColumns() { EasyMockSupport support = new EasyMockSupport(); PreferencesRegistry registry = createRegistry(support); CSVParseParameters parameters = new CSVParseParameters(); parameters.setColumnNames(New.list("Column1", "Column2", "Column3", "Column4", "Column5")); support.replayAll(); ImportableColumnController controller = new ImportableColumnController(); controller.detectNonImportableColumns(parameters, registry); assertTrue(parameters.getColumnsToIgnore().contains(1)); assertTrue(parameters.getColumnsToIgnore().contains(2)); support.verifyAll(); }
### Question: ColumnDefinitionRow extends Observable { public void setDataType(String dataType) { myDataType = dataType; setChanged(); notifyObservers(DATA_TYPE_PROPERTY); } int getColumnId(); String getColumnName(); String getDataType(); String getFormat(); boolean isImport(); void setColumnId(int columnId); void setColumnName(String columnName); void setDataType(String dataType); void setFormat(String format); void setIsImport(boolean isImport); static final String COLUMN_NAME_PROPERTY; static final String DATA_TYPE_PROPERTY; static final String FORMAT_PROPERTY; static final String IMPORT_PROPERTY; }### Answer: @Test public void testSetDataType() { EasyMockSupport support = new EasyMockSupport(); Observer observer = ModelTestUtil.createObserver(support, ColumnDefinitionRow.DATA_TYPE_PROPERTY); support.replayAll(); ColumnDefinitionRow row = new ColumnDefinitionRow(); row.addObserver(observer); String dataType = "Date"; row.setDataType(dataType); assertEquals(dataType, row.getDataType()); support.verifyAll(); }
### Question: ColumnDefinitionRow extends Observable { public void setFormat(String format) { myFormat = format; setChanged(); notifyObservers(FORMAT_PROPERTY); } int getColumnId(); String getColumnName(); String getDataType(); String getFormat(); boolean isImport(); void setColumnId(int columnId); void setColumnName(String columnName); void setDataType(String dataType); void setFormat(String format); void setIsImport(boolean isImport); static final String COLUMN_NAME_PROPERTY; static final String DATA_TYPE_PROPERTY; static final String FORMAT_PROPERTY; static final String IMPORT_PROPERTY; }### Answer: @Test public void testSetFormat() { EasyMockSupport support = new EasyMockSupport(); Observer observer = ModelTestUtil.createObserver(support, ColumnDefinitionRow.FORMAT_PROPERTY); support.replayAll(); ColumnDefinitionRow row = new ColumnDefinitionRow(); row.addObserver(observer); String format = "yyyymmdd"; row.setFormat(format); assertEquals(format, row.getFormat()); support.verifyAll(); }
### Question: AbstractGeographicProjection extends AbstractProjection { @Override public TesseraList<? extends GeographicProjectedTesseraVertex> convertQuadToModel(GeographicPosition vert1, GeographicPosition vert2, GeographicPosition vert3, GeographicPosition vert4, Vector3d modelCenter) { Utilities.checkNull(modelCenter, MODEL_CENTER_PARAMETER_NAME); List<GeographicTesseraVertex> vertices = New.list(); vertices.add(new GeographicTesseraVertex(vert1, convertToModel(vert1, modelCenter))); vertices.add(new GeographicTesseraVertex(vert2, convertToModel(vert2, modelCenter))); vertices.add(new GeographicTesseraVertex(vert3, convertToModel(vert3, modelCenter))); vertices.add(new GeographicTesseraVertex(vert4, convertToModel(vert4, modelCenter))); return new TesseraList<GeographicProjectedTesseraVertex>(vertices, 4, false); } @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 public void testConvertQuadToModel() { GeographicPosition pos1 = new GeographicPosition(LatLonAlt.createFromDegrees(0, 0)); GeographicPosition pos2 = new GeographicPosition(LatLonAlt.createFromDegrees(1, 1)); GeographicPosition pos3 = new GeographicPosition(LatLonAlt.createFromDegrees(2, 2)); GeographicPosition pos4 = new GeographicPosition(LatLonAlt.createFromDegrees(3, 3)); TesseraList<? extends GeographicProjectedTesseraVertex> results = myTestObject.convertQuadToModel(pos1, pos2, pos3, pos4, Vector3d.ORIGIN); assertEquals(1, results.getTesseraBlocks().size()); assertEquals(4, results.getTesseraBlocks().get(0).getTesseraVertexCount()); }
### Question: ColumnDefinitionTableModel extends AbstractTableModel { public void addRows(List<ColumnDefinitionRow> rows) { myRows.addAll(rows); if (!myRows.isEmpty()) { fireTableRowsInserted(0, myRows.size() - 1); } } void addRows(List<ColumnDefinitionRow> rows); void clear(); @Override Class<?> getColumnClass(int columnIndex); @Override int getColumnCount(); @Override String getColumnName(int column); ColumnDefinitionRow getRow(int rowIndex); @Override int getRowCount(); @Override Object getValueAt(int rowIndex, int columnIndex); @Override boolean isCellEditable(int rowIndex, int columnIndex); boolean isImportAllColumns(); void setFormatEditable(boolean isEditable); @Override void setValueAt(Object aValue, int rowIndex, int columnIndex); }### Answer: @Test public void testAddRows() { EasyMockSupport support = new EasyMockSupport(); final List<ColumnDefinitionRow> rows = createTestRows(); TableModelListener listener = support.createMock(TableModelListener.class); listener.tableChanged(EasyMock.isA(TableModelEvent.class)); EasyMock.expectLastCall().andAnswer(new IAnswer<Void>() { @Override public Void answer() { TableModelEvent event = (TableModelEvent)EasyMock.getCurrentArguments()[0]; assertEquals(0, event.getFirstRow()); assertEquals(rows.size() - 1, event.getLastRow()); assertEquals(TableModelEvent.INSERT, event.getType()); return null; } }); support.replayAll(); ColumnDefinitionTableModel model = new ColumnDefinitionTableModel(); model.addTableModelListener(listener); model.addRows(New.<ColumnDefinitionRow>list()); model.addRows(rows); assertEquals(rows.size(), model.getRowCount()); for (int i = 0; i < rows.size(); i++) { assertEquals(rows.get(i).isImport(), model.getValueAt(i, 0)); assertEquals(rows.get(i).getColumnName(), model.getValueAt(i, 1)); assertEquals(rows.get(i).getDataType(), model.getValueAt(i, 2)); assertEquals(rows.get(i).getFormat(), model.getValueAt(i, 3)); } support.verifyAll(); }
### Question: ColumnDefinitionTableModel extends AbstractTableModel { public void clear() { int lastIndex = myRows.size() - 1; myRows.clear(); if (lastIndex >= 0) { fireTableRowsDeleted(0, lastIndex); } } void addRows(List<ColumnDefinitionRow> rows); void clear(); @Override Class<?> getColumnClass(int columnIndex); @Override int getColumnCount(); @Override String getColumnName(int column); ColumnDefinitionRow getRow(int rowIndex); @Override int getRowCount(); @Override Object getValueAt(int rowIndex, int columnIndex); @Override boolean isCellEditable(int rowIndex, int columnIndex); boolean isImportAllColumns(); void setFormatEditable(boolean isEditable); @Override void setValueAt(Object aValue, int rowIndex, int columnIndex); }### Answer: @Test public void testClear() { EasyMockSupport support = new EasyMockSupport(); final List<ColumnDefinitionRow> rows = createTestRows(); TableModelListener listener = support.createMock(TableModelListener.class); listener.tableChanged(EasyMock.isA(TableModelEvent.class)); EasyMock.expectLastCall().andAnswer(new IAnswer<Void>() { @Override public Void answer() { TableModelEvent event = (TableModelEvent)EasyMock.getCurrentArguments()[0]; assertEquals(0, event.getFirstRow()); assertEquals(rows.size() - 1, event.getLastRow()); assertEquals(TableModelEvent.DELETE, event.getType()); return null; } }); support.replayAll(); ColumnDefinitionTableModel model = new ColumnDefinitionTableModel(); model.addTableModelListener(listener); model.clear(); model.removeTableModelListener(listener); model.addRows(rows); model.addTableModelListener(listener); model.clear(); assertEquals(0, model.getRowCount()); support.verifyAll(); }
### Question: ColumnDefinitionTableModel extends AbstractTableModel { @Override public Class<?> getColumnClass(int columnIndex) { return ourColumnClasses[columnIndex]; } void addRows(List<ColumnDefinitionRow> rows); void clear(); @Override Class<?> getColumnClass(int columnIndex); @Override int getColumnCount(); @Override String getColumnName(int column); ColumnDefinitionRow getRow(int rowIndex); @Override int getRowCount(); @Override Object getValueAt(int rowIndex, int columnIndex); @Override boolean isCellEditable(int rowIndex, int columnIndex); boolean isImportAllColumns(); void setFormatEditable(boolean isEditable); @Override void setValueAt(Object aValue, int rowIndex, int columnIndex); }### Answer: @Test public void testGetColumnClassInt() { ColumnDefinitionTableModel model = new ColumnDefinitionTableModel(); assertEquals(Boolean.class, model.getColumnClass(0)); assertEquals(String.class, model.getColumnClass(1)); assertEquals(String.class, model.getColumnClass(2)); assertEquals(String.class, model.getColumnClass(3)); }
### Question: ColumnDefinitionTableModel extends AbstractTableModel { @Override public int getColumnCount() { return ourColumnNames.length; } void addRows(List<ColumnDefinitionRow> rows); void clear(); @Override Class<?> getColumnClass(int columnIndex); @Override int getColumnCount(); @Override String getColumnName(int column); ColumnDefinitionRow getRow(int rowIndex); @Override int getRowCount(); @Override Object getValueAt(int rowIndex, int columnIndex); @Override boolean isCellEditable(int rowIndex, int columnIndex); boolean isImportAllColumns(); void setFormatEditable(boolean isEditable); @Override void setValueAt(Object aValue, int rowIndex, int columnIndex); }### Answer: @Test public void testGetColumnCount() { ColumnDefinitionTableModel model = new ColumnDefinitionTableModel(); assertEquals(4, model.getColumnCount()); }
### Question: ColumnDefinitionTableModel extends AbstractTableModel { @Override public String getColumnName(int column) { return ourColumnNames[column]; } void addRows(List<ColumnDefinitionRow> rows); void clear(); @Override Class<?> getColumnClass(int columnIndex); @Override int getColumnCount(); @Override String getColumnName(int column); ColumnDefinitionRow getRow(int rowIndex); @Override int getRowCount(); @Override Object getValueAt(int rowIndex, int columnIndex); @Override boolean isCellEditable(int rowIndex, int columnIndex); boolean isImportAllColumns(); void setFormatEditable(boolean isEditable); @Override void setValueAt(Object aValue, int rowIndex, int columnIndex); }### Answer: @Test public void testGetColumnNameInt() { ColumnDefinitionTableModel model = new ColumnDefinitionTableModel(); assertEquals("Import", model.getColumnName(0)); assertEquals("Column Name", model.getColumnName(1)); assertEquals("Type", model.getColumnName(2)); assertEquals("Format", model.getColumnName(3)); }
### Question: ColumnDefinitionTableModel extends AbstractTableModel { @Override public boolean isCellEditable(int rowIndex, int columnIndex) { boolean isEditable = true; if (columnIndex == 3) { isEditable = myIsFormatEditable; if (isEditable) { ColumnDefinitionRow row = myRows.get(rowIndex); isEditable = StringUtils.isNotEmpty(row.getDataType()); } } return isEditable; } void addRows(List<ColumnDefinitionRow> rows); void clear(); @Override Class<?> getColumnClass(int columnIndex); @Override int getColumnCount(); @Override String getColumnName(int column); ColumnDefinitionRow getRow(int rowIndex); @Override int getRowCount(); @Override Object getValueAt(int rowIndex, int columnIndex); @Override boolean isCellEditable(int rowIndex, int columnIndex); boolean isImportAllColumns(); void setFormatEditable(boolean isEditable); @Override void setValueAt(Object aValue, int rowIndex, int columnIndex); }### Answer: @Test public void testIsCellEditable() { ColumnDefinitionTableModel model = new ColumnDefinitionTableModel(); ColumnDefinitionRow row = new ColumnDefinitionRow(); model.addRows(New.list(row)); assertTrue(model.isCellEditable(0, 0)); assertTrue(model.isCellEditable(0, 1)); assertTrue(model.isCellEditable(0, 2)); assertFalse(model.isCellEditable(0, 3)); row.setDataType("Date"); assertTrue(model.isCellEditable(0, 3)); }
### Question: ColumnDefinitionTableModel extends AbstractTableModel { public void setFormatEditable(boolean isEditable) { myIsFormatEditable = isEditable; } void addRows(List<ColumnDefinitionRow> rows); void clear(); @Override Class<?> getColumnClass(int columnIndex); @Override int getColumnCount(); @Override String getColumnName(int column); ColumnDefinitionRow getRow(int rowIndex); @Override int getRowCount(); @Override Object getValueAt(int rowIndex, int columnIndex); @Override boolean isCellEditable(int rowIndex, int columnIndex); boolean isImportAllColumns(); void setFormatEditable(boolean isEditable); @Override void setValueAt(Object aValue, int rowIndex, int columnIndex); }### Answer: @Test public void testSetFormatEditable() { ColumnDefinitionTableModel model = new ColumnDefinitionTableModel(); ColumnDefinitionRow row = new ColumnDefinitionRow(); row.setDataType("Date"); model.addRows(New.list(row)); assertTrue(model.isCellEditable(0, 3)); model.setFormatEditable(false); assertFalse(model.isCellEditable(0, 3)); }
### Question: ColumnDefinitionModel extends Observable { public void setAvailableDataTypes(List<String> availableDataTypes) { myAvailableDataTypes = availableDataTypes; setChanged(); notifyObservers(AVAILABLE_DATA_TYPES_PROPERTY); } List<String> getAvailableDataTypes(); List<String> getAvailableFormats(); BeforeAfterTableModel getBeforeAfterTableModel(); ColumnDefinitionTableModel getDefinitionTableModel(); String getErrorMessage(); ColumnDefinitionRow getSelectedDefinition(); String getWarningMessage(); void setAvailableDataTypes(List<String> availableDataTypes); void setAvailableFormats(List<String> availableFormats); void setErrorMessage(String errorMessage); void setSelectedDefinition(ColumnDefinitionRow selectedDefinition); void setWarningMessage(String warningMessage); List<? extends List<? extends String>> getSampleData(); void setSampleData(List<? extends List<? extends String>> sampleData); CSVParseParameters getSelectedParameters(); void setSelectedParameters(CSVParseParameters selectedParameters); boolean canAddFormats(); void setCanAddFormats(boolean canAddFormats); void setDetectedParameters(DetectedParameters detectedParameters); ValuesWithConfidence<LocationResults> getLocationParameter(); static final String AVAILABLE_DATA_TYPES_PROPERTY; static final String AVAILABLE_FORMATS_PROPERTY; static final String ERROR_MESSAGE_PROPERTY; static final String SELECTED_DEFINITION_PROPERTY; static final String WARNING_MESSAGE_PROPERTY; static final String CAN_ADD_FORMATS_PROPERTY; }### Answer: @Test public void testSetAvailableDataTypes() { EasyMockSupport support = new EasyMockSupport(); Observer observer = ModelTestUtil.createObserver(support, ColumnDefinitionModel.AVAILABLE_DATA_TYPES_PROPERTY); support.replayAll(); ColumnDefinitionModel model = new ColumnDefinitionModel(); model.addObserver(observer); List<String> availableTypes = New.list(); model.setAvailableDataTypes(availableTypes); assertEquals(availableTypes, model.getAvailableDataTypes()); support.verifyAll(); }
### Question: ColumnDefinitionModel extends Observable { public void setAvailableFormats(List<String> availableFormats) { myAvailableFormats = availableFormats; setChanged(); notifyObservers(AVAILABLE_FORMATS_PROPERTY); } List<String> getAvailableDataTypes(); List<String> getAvailableFormats(); BeforeAfterTableModel getBeforeAfterTableModel(); ColumnDefinitionTableModel getDefinitionTableModel(); String getErrorMessage(); ColumnDefinitionRow getSelectedDefinition(); String getWarningMessage(); void setAvailableDataTypes(List<String> availableDataTypes); void setAvailableFormats(List<String> availableFormats); void setErrorMessage(String errorMessage); void setSelectedDefinition(ColumnDefinitionRow selectedDefinition); void setWarningMessage(String warningMessage); List<? extends List<? extends String>> getSampleData(); void setSampleData(List<? extends List<? extends String>> sampleData); CSVParseParameters getSelectedParameters(); void setSelectedParameters(CSVParseParameters selectedParameters); boolean canAddFormats(); void setCanAddFormats(boolean canAddFormats); void setDetectedParameters(DetectedParameters detectedParameters); ValuesWithConfidence<LocationResults> getLocationParameter(); static final String AVAILABLE_DATA_TYPES_PROPERTY; static final String AVAILABLE_FORMATS_PROPERTY; static final String ERROR_MESSAGE_PROPERTY; static final String SELECTED_DEFINITION_PROPERTY; static final String WARNING_MESSAGE_PROPERTY; static final String CAN_ADD_FORMATS_PROPERTY; }### Answer: @Test public void testSetAvailableFormats() { EasyMockSupport support = new EasyMockSupport(); Observer observer = ModelTestUtil.createObserver(support, ColumnDefinitionModel.AVAILABLE_FORMATS_PROPERTY); support.replayAll(); ColumnDefinitionModel model = new ColumnDefinitionModel(); model.addObserver(observer); List<String> availableFormats = New.list(); model.setAvailableFormats(availableFormats); assertEquals(availableFormats, model.getAvailableFormats()); support.verifyAll(); }
### Question: ColumnDefinitionModel extends Observable { public void setErrorMessage(String errorMessage) { myErrorMessage = errorMessage; setChanged(); notifyObservers(ERROR_MESSAGE_PROPERTY); } List<String> getAvailableDataTypes(); List<String> getAvailableFormats(); BeforeAfterTableModel getBeforeAfterTableModel(); ColumnDefinitionTableModel getDefinitionTableModel(); String getErrorMessage(); ColumnDefinitionRow getSelectedDefinition(); String getWarningMessage(); void setAvailableDataTypes(List<String> availableDataTypes); void setAvailableFormats(List<String> availableFormats); void setErrorMessage(String errorMessage); void setSelectedDefinition(ColumnDefinitionRow selectedDefinition); void setWarningMessage(String warningMessage); List<? extends List<? extends String>> getSampleData(); void setSampleData(List<? extends List<? extends String>> sampleData); CSVParseParameters getSelectedParameters(); void setSelectedParameters(CSVParseParameters selectedParameters); boolean canAddFormats(); void setCanAddFormats(boolean canAddFormats); void setDetectedParameters(DetectedParameters detectedParameters); ValuesWithConfidence<LocationResults> getLocationParameter(); static final String AVAILABLE_DATA_TYPES_PROPERTY; static final String AVAILABLE_FORMATS_PROPERTY; static final String ERROR_MESSAGE_PROPERTY; static final String SELECTED_DEFINITION_PROPERTY; static final String WARNING_MESSAGE_PROPERTY; static final String CAN_ADD_FORMATS_PROPERTY; }### Answer: @Test public void testSetErrorMessage() { EasyMockSupport support = new EasyMockSupport(); Observer observer = ModelTestUtil.createObserver(support, ColumnDefinitionModel.ERROR_MESSAGE_PROPERTY); support.replayAll(); ColumnDefinitionModel model = new ColumnDefinitionModel(); model.addObserver(observer); String errorMessage = "error message"; model.setErrorMessage(errorMessage); assertEquals(errorMessage, model.getErrorMessage()); support.verifyAll(); }
### Question: AbstractGeographicProjection extends AbstractProjection { @Override public TesseraList<? extends GeographicProjectedTesseraVertex> convertTriangleToModel(GeographicPosition vert1, GeographicPosition vert2, GeographicPosition vert3, Vector3d modelCenter) { Utilities.checkNull(modelCenter, MODEL_CENTER_PARAMETER_NAME); List<GeographicTesseraVertex> vertices = New.list(); vertices.add(new GeographicTesseraVertex(vert1, convertToModel(vert1, modelCenter))); vertices.add(new GeographicTesseraVertex(vert2, convertToModel(vert2, modelCenter))); vertices.add(new GeographicTesseraVertex(vert3, convertToModel(vert3, modelCenter))); return new TesseraList<GeographicProjectedTesseraVertex>(vertices, 3, false); } @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 public void testConvertTriangleToModel() { GeographicPosition pos1 = new GeographicPosition(LatLonAlt.createFromDegrees(0, 0)); GeographicPosition pos2 = new GeographicPosition(LatLonAlt.createFromDegrees(1, 1)); GeographicPosition pos3 = new GeographicPosition(LatLonAlt.createFromDegrees(2, 2)); TesseraList<? extends GeographicProjectedTesseraVertex> results = myTestObject.convertTriangleToModel(pos1, pos2, pos3, Vector3d.ORIGIN); assertEquals(1, results.getTesseraBlocks().size()); assertEquals(3, results.getTesseraBlocks().get(0).getTesseraVertexCount()); }
### Question: ColumnDefinitionModel extends Observable { public void setSelectedDefinition(ColumnDefinitionRow selectedDefinition) { mySelectedDefinition = selectedDefinition; setChanged(); notifyObservers(SELECTED_DEFINITION_PROPERTY); } List<String> getAvailableDataTypes(); List<String> getAvailableFormats(); BeforeAfterTableModel getBeforeAfterTableModel(); ColumnDefinitionTableModel getDefinitionTableModel(); String getErrorMessage(); ColumnDefinitionRow getSelectedDefinition(); String getWarningMessage(); void setAvailableDataTypes(List<String> availableDataTypes); void setAvailableFormats(List<String> availableFormats); void setErrorMessage(String errorMessage); void setSelectedDefinition(ColumnDefinitionRow selectedDefinition); void setWarningMessage(String warningMessage); List<? extends List<? extends String>> getSampleData(); void setSampleData(List<? extends List<? extends String>> sampleData); CSVParseParameters getSelectedParameters(); void setSelectedParameters(CSVParseParameters selectedParameters); boolean canAddFormats(); void setCanAddFormats(boolean canAddFormats); void setDetectedParameters(DetectedParameters detectedParameters); ValuesWithConfidence<LocationResults> getLocationParameter(); static final String AVAILABLE_DATA_TYPES_PROPERTY; static final String AVAILABLE_FORMATS_PROPERTY; static final String ERROR_MESSAGE_PROPERTY; static final String SELECTED_DEFINITION_PROPERTY; static final String WARNING_MESSAGE_PROPERTY; static final String CAN_ADD_FORMATS_PROPERTY; }### Answer: @Test public void testSetSelectedDefinition() { EasyMockSupport support = new EasyMockSupport(); Observer observer = ModelTestUtil.createObserver(support, ColumnDefinitionModel.SELECTED_DEFINITION_PROPERTY); support.replayAll(); ColumnDefinitionModel model = new ColumnDefinitionModel(); model.addObserver(observer); ColumnDefinitionRow definition = new ColumnDefinitionRow(); model.setSelectedDefinition(definition); assertEquals(definition, model.getSelectedDefinition()); support.verifyAll(); }
### Question: ColumnDefinitionModel extends Observable { public void setWarningMessage(String warningMessage) { myWarningMessage = warningMessage; setChanged(); notifyObservers(WARNING_MESSAGE_PROPERTY); } List<String> getAvailableDataTypes(); List<String> getAvailableFormats(); BeforeAfterTableModel getBeforeAfterTableModel(); ColumnDefinitionTableModel getDefinitionTableModel(); String getErrorMessage(); ColumnDefinitionRow getSelectedDefinition(); String getWarningMessage(); void setAvailableDataTypes(List<String> availableDataTypes); void setAvailableFormats(List<String> availableFormats); void setErrorMessage(String errorMessage); void setSelectedDefinition(ColumnDefinitionRow selectedDefinition); void setWarningMessage(String warningMessage); List<? extends List<? extends String>> getSampleData(); void setSampleData(List<? extends List<? extends String>> sampleData); CSVParseParameters getSelectedParameters(); void setSelectedParameters(CSVParseParameters selectedParameters); boolean canAddFormats(); void setCanAddFormats(boolean canAddFormats); void setDetectedParameters(DetectedParameters detectedParameters); ValuesWithConfidence<LocationResults> getLocationParameter(); static final String AVAILABLE_DATA_TYPES_PROPERTY; static final String AVAILABLE_FORMATS_PROPERTY; static final String ERROR_MESSAGE_PROPERTY; static final String SELECTED_DEFINITION_PROPERTY; static final String WARNING_MESSAGE_PROPERTY; static final String CAN_ADD_FORMATS_PROPERTY; }### Answer: @Test public void testSetWarningMessage() { EasyMockSupport support = new EasyMockSupport(); Observer observer = ModelTestUtil.createObserver(support, ColumnDefinitionModel.WARNING_MESSAGE_PROPERTY); support.replayAll(); ColumnDefinitionModel model = new ColumnDefinitionModel(); model.addObserver(observer); String warningMessage = "warning"; model.setWarningMessage(warningMessage); assertEquals(warningMessage, model.getWarningMessage()); support.verifyAll(); }
### Question: ColumnDefinitionModel extends Observable { public void setCanAddFormats(boolean canAddFormats) { myCanAddFormats = canAddFormats; setChanged(); notifyObservers(CAN_ADD_FORMATS_PROPERTY); } List<String> getAvailableDataTypes(); List<String> getAvailableFormats(); BeforeAfterTableModel getBeforeAfterTableModel(); ColumnDefinitionTableModel getDefinitionTableModel(); String getErrorMessage(); ColumnDefinitionRow getSelectedDefinition(); String getWarningMessage(); void setAvailableDataTypes(List<String> availableDataTypes); void setAvailableFormats(List<String> availableFormats); void setErrorMessage(String errorMessage); void setSelectedDefinition(ColumnDefinitionRow selectedDefinition); void setWarningMessage(String warningMessage); List<? extends List<? extends String>> getSampleData(); void setSampleData(List<? extends List<? extends String>> sampleData); CSVParseParameters getSelectedParameters(); void setSelectedParameters(CSVParseParameters selectedParameters); boolean canAddFormats(); void setCanAddFormats(boolean canAddFormats); void setDetectedParameters(DetectedParameters detectedParameters); ValuesWithConfidence<LocationResults> getLocationParameter(); static final String AVAILABLE_DATA_TYPES_PROPERTY; static final String AVAILABLE_FORMATS_PROPERTY; static final String ERROR_MESSAGE_PROPERTY; static final String SELECTED_DEFINITION_PROPERTY; static final String WARNING_MESSAGE_PROPERTY; static final String CAN_ADD_FORMATS_PROPERTY; }### Answer: @Test public void testSetCanAddFormats() { EasyMockSupport support = new EasyMockSupport(); Observer observer = ModelTestUtil.createObserver(support, ColumnDefinitionModel.CAN_ADD_FORMATS_PROPERTY); support.replayAll(); ColumnDefinitionModel model = new ColumnDefinitionModel(); model.addObserver(observer); model.setCanAddFormats(true); assertTrue(model.canAddFormats()); support.verifyAll(); }
### Question: BeforeAfterTableModel extends AbstractTableModel { public void addRows(List<BeforeAfterRow> newRows) { myRows.addAll(newRows); if (!myRows.isEmpty()) { fireTableRowsInserted(0, myRows.size() - 1); } } void addRows(List<BeforeAfterRow> newRows); void clear(); @Override int getColumnCount(); @Override String getColumnName(int column); BeforeAfterRow getRow(int rowIndex); @Override int getRowCount(); @Override Object getValueAt(int rowIndex, int columnIndex); void setColumnNamePrefix(String columnNamePrefix); static final String ourBeforeSuffix; static final String ourAfterSuffix; }### Answer: @Test public void testAddRows() { EasyMockSupport support = new EasyMockSupport(); final List<BeforeAfterRow> rows = createTestRows(); TableModelListener listener = support.createMock(TableModelListener.class); listener.tableChanged(EasyMock.isA(TableModelEvent.class)); EasyMock.expectLastCall().andAnswer(new IAnswer<Void>() { @Override public Void answer() { TableModelEvent event = (TableModelEvent)EasyMock.getCurrentArguments()[0]; assertEquals(0, event.getFirstRow()); assertEquals(rows.size() - 1, event.getLastRow()); assertEquals(TableModelEvent.INSERT, event.getType()); return null; } }); support.replayAll(); BeforeAfterTableModel model = new BeforeAfterTableModel(); model.addTableModelListener(listener); model.addRows(New.<BeforeAfterRow>list()); model.addRows(rows); assertEquals(rows.size(), model.getRowCount()); for (int i = 0; i < rows.size(); i++) { assertEquals(rows.get(i).getBeforeValue(), model.getValueAt(i, 0)); assertEquals(rows.get(i).getAfterValue(), model.getValueAt(i, 1)); } support.verifyAll(); }
### Question: ColumnTypeLocationComparator implements Comparator<ColumnType>, Serializable { @Override public int compare(ColumnType o1, ColumnType o2) { Integer order1 = getOrder(o1); Integer order2 = getOrder(o2); return order1.compareTo(order2); } ColumnTypeLocationComparator(); @Override int compare(ColumnType o1, ColumnType o2); }### Answer: @Test public void testCompare() { List<ColumnType> dataTypes = New.list(); dataTypes.add(ColumnType.TIMESTAMP); dataTypes.add(ColumnType.DATE); dataTypes.add(ColumnType.TIME); dataTypes.add(ColumnType.DOWN_DATE); dataTypes.add(ColumnType.DOWN_TIME); dataTypes.add(ColumnType.DOWN_TIMESTAMP); dataTypes.add(ColumnType.LAT); dataTypes.add(ColumnType.LON); dataTypes.add(ColumnType.MGRS); dataTypes.add(ColumnType.POSITION); dataTypes.add(ColumnType.WKT_GEOMETRY); dataTypes.add(ColumnType.SEMIMAJOR); dataTypes.add(ColumnType.SEMIMINOR); dataTypes.add(ColumnType.ORIENTATION); dataTypes.add(ColumnType.RADIUS); dataTypes.add(ColumnType.LOB); ColumnTypeLocationComparator comparator = new ColumnTypeLocationComparator(); Collections.sort(dataTypes, comparator); assertEquals(ColumnType.LAT, dataTypes.get(0)); assertEquals(ColumnType.LON, dataTypes.get(1)); assertEquals(ColumnType.MGRS, dataTypes.get(2)); assertEquals(ColumnType.POSITION, dataTypes.get(3)); assertEquals(ColumnType.WKT_GEOMETRY, dataTypes.get(4)); }
### Question: FormatController extends BaseSelectedColumnObserver implements TableModelListener { private void saveCurrentFormat() { ColumnDefinitionRow selCol = getSelectedColumn(); if (selCol == null) { return; } String type = selCol.getDataType(); String fmt = selCol.getFormat(); if (type == null || type.isEmpty() || fmt == null || fmt.isEmpty()) { return; } CellFormatter formatter = new CellFormatterFactory().getFormatter(ColumnType.fromString(type), myPreferencesRegistry); if (formatter instanceof CellFormatSaver) { ((CellFormatSaver)formatter).saveNewFormat(fmt); } } FormatController(PreferencesRegistry preferencesRegistry, ColumnDefinitionModel model); @Override void close(); @Override void tableChanged(TableModelEvent e); @Override void update(Observable o, Object arg); }### Answer: @Test public void testSaveCurrentFormat() { String newFormat = "y"; DateFormatsConfig config = getDateFormats(); EasyMockSupport support = new EasyMockSupport(); PreferencesRegistry preferencesRegistry = createPreferencesRegistry(support, config, "yyyy"); support.replayAll(); BeforeAfterRow successRow = new BeforeAfterRow(); successRow.setAfterValue("05/20/2014"); BeforeAfterRow failRow1 = new BeforeAfterRow(); failRow1.setAfterValue("N/A"); BeforeAfterRow failRow2 = new BeforeAfterRow(); failRow2.setAfterValue(Constants.ERROR_LABEL); ColumnDefinitionModel model = new ColumnDefinitionModel(); ColumnDefinitionRow selectedColumn = new ColumnDefinitionRow(); selectedColumn.setDataType(ColumnType.DATE.toString()); selectedColumn.setFormat(newFormat); @SuppressWarnings("unused") FormatController controller = new FormatController(preferencesRegistry, model); model.setSelectedDefinition(selectedColumn); model.getBeforeAfterTableModel().addRows(New.list(failRow1)); model.getBeforeAfterTableModel().clear(); newFormat = "yy"; selectedColumn.setFormat(newFormat); model.getBeforeAfterTableModel().addRows(New.list(failRow2)); model.getBeforeAfterTableModel().clear(); newFormat = "yyy"; selectedColumn.setFormat(newFormat); model.getAvailableFormats().add(newFormat); model.getBeforeAfterTableModel().addRows(New.list(successRow)); model.getAvailableFormats().clear(); newFormat = "yyyy"; selectedColumn.setFormat(newFormat); model.getBeforeAfterTableModel().addRows(New.list(successRow)); support.verifyAll(); }
### Question: FormatController extends BaseSelectedColumnObserver implements TableModelListener { @Override public void update(Observable o, Object arg) { super.update(o, arg); if (ColumnDefinitionModel.SELECTED_DEFINITION_PROPERTY.equals(arg)) { setPreviousDataType(); myModel.setAvailableFormats(populateFormats()); } else if (ColumnDefinitionRow.DATA_TYPE_PROPERTY.equals(arg)) { resetFormatIfNeeded(); setPreviousDataType(); myModel.setAvailableFormats(populateFormats()); } } FormatController(PreferencesRegistry preferencesRegistry, ColumnDefinitionModel model); @Override void close(); @Override void tableChanged(TableModelEvent e); @Override void update(Observable o, Object arg); }### Answer: @Test public void testUpdate() { DateFormatsConfig config = getDateFormats(); EasyMockSupport support = new EasyMockSupport(); PreferencesRegistry preferencesRegistry = createPreferencesRegistry(support, config, null); support.replayAll(); ColumnDefinitionModel model = new ColumnDefinitionModel(); model.setSampleData(New.<List<String>>list()); ColumnDefinitionRow selectedColumn = new ColumnDefinitionRow(); selectedColumn.setDataType(ColumnType.DATE.toString()); model.getDefinitionTableModel().addRows(New.list(selectedColumn)); @SuppressWarnings("unused") FormatController controller = new FormatController(preferencesRegistry, model); model.setSelectedDefinition(selectedColumn); List<String> actualAvailableFormats = model.getAvailableFormats(); Set<String> actuals = New.set(actualAvailableFormats); assertEquals(actuals.size(), actualAvailableFormats.size()); assertTrue(model.getDefinitionTableModel().isCellEditable(0, 3)); Set<String> expected = New.set(); for (DateFormat format : config.getFormats()) { if (format.getType() == Type.DATE) { expected.add(format.getSdf()); } } assertEquals(expected.size(), actuals.size()); for (String anExpected : expected) { assertTrue(actuals.contains(anExpected)); } selectedColumn.setDataType(ColumnType.TIMESTAMP.toString()); actualAvailableFormats = model.getAvailableFormats(); actuals = New.set(actualAvailableFormats); assertEquals(actuals.size(), actualAvailableFormats.size()); expected = New.set(); for (DateFormat format : config.getFormats()) { if (format.getType() == Type.TIMESTAMP) { expected.add(format.getSdf()); } } assertEquals(expected.size(), actuals.size()); for (String anExpected : expected) { assertTrue(actuals.contains(anExpected)); } support.verifyAll(); }
### Question: ColumnDefinitionTableBinder implements Observer, ListSelectionListener { @Override public void update(Observable o, Object arg) { if (ColumnDefinitionModel.SELECTED_DEFINITION_PROPERTY.equals(arg)) { int currentSelection = myTable.getSelectionModel().getAnchorSelectionIndex(); ColumnDefinitionRow selectedRow = myModel.getSelectedDefinition(); if (selectedRow != null && (currentSelection < 0 || selectedRow.getColumnId() != currentSelection)) { myTable.getSelectionModel().setSelectionInterval(selectedRow.getColumnId(), selectedRow.getColumnId()); } else if (selectedRow == null && currentSelection >= 0) { myTable.getSelectionModel().clearSelection(); myTable.getSelectionModel().setAnchorSelectionIndex(-1); } } } ColumnDefinitionTableBinder(JTable definitionTable, ColumnDefinitionModel model); void close(); @Override void update(Observable o, Object arg); @Override void valueChanged(ListSelectionEvent e); }### Answer: @SuppressWarnings("unused") @Test public void testUpdate() { ColumnDefinitionModel model = createModel(); JTable table = createTestTable(model.getDefinitionTableModel()); ColumnDefinitionTableBinder binder = new ColumnDefinitionTableBinder(table, model); model.setSelectedDefinition(model.getDefinitionTableModel().getRow(0)); assertEquals(0, table.getSelectionModel().getMinSelectionIndex()); model.setSelectedDefinition(model.getDefinitionTableModel().getRow(0)); assertEquals(0, table.getSelectionModel().getMinSelectionIndex()); }
### Question: ColumnDefinitionTableBinder implements Observer, ListSelectionListener { @Override public void valueChanged(ListSelectionEvent e) { int selectedIndex = myTable.getSelectionModel().getMinSelectionIndex(); ColumnDefinitionRow selectedRow = null; if (selectedIndex >= 0) { selectedRow = myModel.getDefinitionTableModel().getRow(selectedIndex); } if (myModel.getSelectedDefinition() != selectedRow) { myModel.setSelectedDefinition(selectedRow); } int column = myTable.getSelectedColumn(); myTable.editCellAt(selectedIndex, column); } ColumnDefinitionTableBinder(JTable definitionTable, ColumnDefinitionModel model); void close(); @Override void update(Observable o, Object arg); @Override void valueChanged(ListSelectionEvent e); }### Answer: @SuppressWarnings("unused") @Test public void testValueChanged() { ColumnDefinitionModel model = createModel(); JTable table = createTestTable(model.getDefinitionTableModel()); ColumnDefinitionTableBinder binder = new ColumnDefinitionTableBinder(table, model); table.getSelectionModel().setSelectionInterval(0, 0); assertEquals(0, model.getSelectedDefinition().getColumnId()); table.getSelectionModel().setSelectionInterval(0, 0); assertEquals(0, model.getSelectedDefinition().getColumnId()); }
### Question: AvailableDataTypesBinder extends BaseComboBoxBinder { @Override public void update(Observable o, Object arg) { if (ColumnDefinitionModel.AVAILABLE_DATA_TYPES_PROPERTY.equals(arg)) { String selectedItem = null; if (myModel.getSelectedDefinition() != null) { selectedItem = myModel.getSelectedDefinition().getDataType(); } super.updateComboBox(myModel.getAvailableDataTypes(), selectedItem); } } AvailableDataTypesBinder(JComboBox<String> comboBox, ColumnDefinitionModel model); @Override void update(Observable o, Object arg); }### Answer: @SuppressWarnings("unused") @Test public void testUpdate() { ColumnDefinitionModel model = new ColumnDefinitionModel(); JComboBox<String> comboBox = new JComboBox<>(); List<String> availableDataTypes = New.list("dataType1", "dataType2", "dataType3"); AvailableDataTypesBinder binder = new AvailableDataTypesBinder(comboBox, model); model.setAvailableDataTypes(availableDataTypes); assertEquals(availableDataTypes.size(), comboBox.getItemCount()); int index = 0; for (String format : availableDataTypes) { assertEquals(format, comboBox.getItemAt(index).toString()); index++; } model.setAvailableDataTypes(New.<String>list()); assertEquals(0, comboBox.getItemCount()); }
### Question: AvailableFormatsBinder extends BaseComboBoxBinder { @Override public void update(Observable o, Object arg) { if (ColumnDefinitionModel.AVAILABLE_FORMATS_PROPERTY.equals(arg)) { String selectedItem = null; if (myModel.getSelectedDefinition() != null) { selectedItem = myModel.getSelectedDefinition().getFormat(); } super.updateComboBox(myModel.getAvailableFormats(), selectedItem); } else if (ColumnDefinitionModel.CAN_ADD_FORMATS_PROPERTY.equals(arg)) { myComboBox.setEditable(myModel.canAddFormats()); } } AvailableFormatsBinder(JComboBox<String> comboBox, ColumnDefinitionModel model); @Override void update(Observable o, Object arg); }### Answer: @SuppressWarnings("unused") @Test public void testUpdate() { ColumnDefinitionModel model = new ColumnDefinitionModel(); JComboBox<String> comboBox = new JComboBox<>(); List<String> formats = New.list("format1", "format2", "format3"); AvailableFormatsBinder binder = new AvailableFormatsBinder(comboBox, model); model.setAvailableFormats(formats); assertEquals(formats.size(), comboBox.getItemCount()); int index = 0; for (String format : formats) { assertEquals(format, comboBox.getItemAt(index).toString()); index++; } model.setAvailableFormats(New.<String>list()); assertEquals(0, comboBox.getItemCount()); }
### Question: ImportValidator { public String validate() { String message = null; ColumnDefinitionTableModel tableModel = myModel.getDefinitionTableModel(); boolean hasImport = false; for (int i = 0; i < tableModel.getRowCount(); i++) { ColumnDefinitionRow column = tableModel.getRow(i); if (column.isImport()) { hasImport = true; break; } } if (!hasImport) { message = "Must have at least one column selected for import."; } return message; } ImportValidator(ColumnDefinitionModel model); String validate(); }### Answer: @Test public void testValidate() { ColumnDefinitionModel model = new ColumnDefinitionModel(); ColumnDefinitionRow row1 = new ColumnDefinitionRow(); row1.setIsImport(true); ColumnDefinitionRow row2 = new ColumnDefinitionRow(); row2.setIsImport(true); model.getDefinitionTableModel().addRows(New.list(row1, row2)); ImportValidator validator = new ImportValidator(model); assertNull(validator.validate()); row2.setIsImport(false); assertNull(validator.validate()); row1.setIsImport(false); assertNotNull(validator.validate()); }
### Question: DateValidator extends BaseValidator { @Override public String validate() { String message = null; Map<ColumnType, ColumnDefinitionRow> columnTypes = mapTypesToColumns(); if (columnTypes.containsKey(ColumnType.TIME) && !columnTypes.containsKey(ColumnType.DATE)) { message = "Need a " + ColumnType.DATE + " column identified for the identified " + ColumnType.TIME + " column."; } else if (columnTypes.containsKey(ColumnType.DOWN_TIME) && !columnTypes.containsKey(ColumnType.DATE) && !columnTypes.containsKey(ColumnType.DOWN_DATE) && !columnTypes.containsKey(ColumnType.TIMESTAMP)) { message = "Need a " + ColumnType.DOWN_DATE + " column identified for the identified " + ColumnType.DOWN_TIME + "."; } else { for (ColumnType columType : ourDateColumnTypes) { ColumnDefinitionRow row = columnTypes.get(columType); if (row != null && StringUtils.isEmpty(row.getFormat())) { message = "Need a format for column " + row.getColumnName(); break; } } } return message; } DateValidator(ColumnDefinitionModel model); @Override String validate(); }### Answer: @Test public void testValidateTimeNoDate() { ColumnDefinitionModel model = new ColumnDefinitionModel(); ColumnDefinitionRow row1 = new ColumnDefinitionRow(); row1.setIsImport(true); row1.setFormat(ourFormat); ColumnDefinitionRow row2 = new ColumnDefinitionRow(); row2.setIsImport(true); row2.setFormat(ourFormat); ColumnDefinitionRow row3 = new ColumnDefinitionRow(); row3.setIsImport(true); row3.setFormat(ourFormat); model.getDefinitionTableModel().addRows(New.list(row1, row2, row3)); DateValidator validator = new DateValidator(model); row1.setDataType(null); row2.setDataType(ColumnType.TIME.toString()); row3.setDataType(null); assertNotNull(validator.validate()); row1.setDataType(ColumnType.DATE.toString()); row2.setDataType(ColumnType.TIME.toString()); row3.setDataType(null); assertNull(validator.validate()); row1.setDataType(ColumnType.DATE.toString()); row2.setDataType(ColumnType.TIME.toString()); row3.setDataType(ColumnType.DOWN_TIME.toString()); assertNull(validator.validate()); row1.setDataType(ourDateTime); row2.setDataType(null); row3.setDataType(ColumnType.DOWN_TIME.toString()); assertNull(validator.validate()); row1.setDataType(ourDateTime); row2.setDataType(ColumnType.DOWN_DATE.toString()); row3.setDataType(ColumnType.DOWN_TIME.toString()); assertNull(validator.validate()); } @Test public void testValidateNoFormat() { ColumnDefinitionModel model = new ColumnDefinitionModel(); ColumnDefinitionRow row = new ColumnDefinitionRow(); row.setIsImport(true); ColumnDefinitionRow supportRow = new ColumnDefinitionRow(); supportRow.setFormat(ourFormat); supportRow.setIsImport(true); model.getDefinitionTableModel().addRows(New.list(row, supportRow)); String[] dataTypes = new String[] { ourDateTime, ColumnType.DATE.toString(), ColumnType.TIME.toString(), ColumnType.DOWN_TIMESTAMP.toString(), ColumnType.DOWN_DATE.toString(), ColumnType.DOWN_TIME.toString(), }; String[] supportTypes = new String[] { "", "", ColumnType.DATE.toString(), ourDateTime, ourDateTime, ColumnType.DATE.toString(), }; DateValidator validator = new DateValidator(model); int index = 0; for (String dataType : dataTypes) { supportRow.setDataType(supportTypes[index]); row.setDataType(dataType); assertNotNull(validator.validate()); row.setFormat(ourFormat); assertNull(validator.validate()); row.setFormat(null); index++; } }
### Question: PositionValidator extends BaseValidator { @Override public String validate() { String message = null; Map<ColumnType, ColumnDefinitionRow> typesToColumns = mapTypesToColumns(); if (typesToColumns.containsKey(ColumnType.LAT) || typesToColumns.containsKey(ColumnType.LON)) { ColumnDefinitionRow latColumn = typesToColumns.get(ColumnType.LAT); ColumnDefinitionRow lonColumn = typesToColumns.get(ColumnType.LON); if (latColumn == null) { message = ColumnType.LAT + " column is not identified."; } else if (lonColumn == null) { message = ColumnType.LON + " column is not identified."; } } else if (!typesToColumns.containsKey(ColumnType.POSITION) && !typesToColumns.containsKey(ColumnType.WKT_GEOMETRY) && !typesToColumns.containsKey(ColumnType.MGRS)) { message = "Selecting location columns is recommended."; } return message; } PositionValidator(ColumnDefinitionModel model); @Override String validate(); }### Answer: @Test public void testValidate() { ColumnDefinitionModel model = new ColumnDefinitionModel(); ColumnDefinitionRow row1 = new ColumnDefinitionRow(); row1.setFormat("format"); row1.setIsImport(true); ColumnDefinitionRow row2 = new ColumnDefinitionRow(); row2.setFormat("format"); row2.setIsImport(true); model.getDefinitionTableModel().addRows(New.list(row1, row2)); row1.setDataType(ColumnType.LAT.toString()); row2.setDataType(ColumnType.LON.toString()); PositionValidator validator = new PositionValidator(model); assertNull(validator.validate()); row1.setDataType(ColumnType.POSITION.toString()); row2.setDataType(null); assertNull(validator.validate()); row1.setDataType(ColumnType.MGRS.toString()); assertNull(validator.validate()); row1.setDataType(ColumnType.WKT_GEOMETRY.toString()); assertNull(validator.validate()); } @Test public void testValidateMissingColumns() { ColumnDefinitionModel model = new ColumnDefinitionModel(); ColumnDefinitionRow row1 = new ColumnDefinitionRow(); row1.setIsImport(true); ColumnDefinitionRow row2 = new ColumnDefinitionRow(); row2.setIsImport(true); model.getDefinitionTableModel().addRows(New.list(row1, row2)); PositionValidator validator = new PositionValidator(model); assertNotNull(validator.validate()); } @Test public void testValidateMissingFormats() { ColumnDefinitionModel model = new ColumnDefinitionModel(); ColumnDefinitionRow row1 = new ColumnDefinitionRow(); row1.setIsImport(true); ColumnDefinitionRow row2 = new ColumnDefinitionRow(); row2.setIsImport(true); model.getDefinitionTableModel().addRows(New.list(row1, row2)); row1.setDataType(ColumnType.LAT.toString()); row2.setDataType(ColumnType.LON.toString()); PositionValidator validator = new PositionValidator(model); assertNull(validator.validate()); row1.setDataType(ColumnType.POSITION.toString()); row2.setDataType(null); assertNull(validator.validate()); row1.setDataType(ColumnType.MGRS.toString()); assertNull(validator.validate()); row1.setDataType(ColumnType.WKT_GEOMETRY.toString()); assertNull(validator.validate()); } @Test public void testValidateMissingLatOrLon() { ColumnDefinitionModel model = new ColumnDefinitionModel(); ColumnDefinitionRow row1 = new ColumnDefinitionRow(); row1.setFormat("format"); row1.setIsImport(true); ColumnDefinitionRow row2 = new ColumnDefinitionRow(); row2.setFormat("format"); row2.setIsImport(true); model.getDefinitionTableModel().addRows(New.list(row1, row2)); row1.setDataType(ColumnType.LAT.toString()); PositionValidator validator = new PositionValidator(model); assertTrue(validator.validate().contains(ColumnType.LON.toString())); row1.setDataType(null); row2.setDataType(ColumnType.LON.toString()); assertTrue(validator.validate().contains(ColumnType.LAT.toString())); }
### Question: WktRemover { public String removeWktData(String line) { String modifiedLine = line; List<String> wktTypes = New.list(WktType.POLYGON.toString().toUpperCase(), WktType.LINESTRING.toString().toUpperCase(), WktType.LINEARRING.toString().toUpperCase(), WktType.MULTIPOINT.toString().toUpperCase(), WktType.MULTILINESTRING.toString().toUpperCase(), WktType.MULTIPOLYGON.toString().toUpperCase(), WktType.GEOMETRYCOLLECTION.toString().toUpperCase()); for (String wktType : wktTypes) { if (modifiedLine.toUpperCase().contains(wktType)) { modifiedLine = modifiedLine.toUpperCase(); StringBuilder regex = new StringBuilder(); regex.append(wktType); regex.append("\\s*+\\(.*\\)"); modifiedLine = modifiedLine.replaceAll(regex.toString(), wktType); } } return modifiedLine; } String removeWktData(String line); }### Answer: @Test public void testRemoveWktData() { String line = "column1, column2, POINT (( 1 )), column4"; String expected = "column1, column2, POINT (( 1 )), column4"; WktRemover remover = new WktRemover(); String actual = remover.removeWktData(line); assertEquals(expected, actual); line = "column1,column2,Polygon(( 1, 3, 5, 6, )),column4"; expected = "COLUMN1,COLUMN2,POLYGON,COLUMN4"; actual = remover.removeWktData(line); assertEquals(expected, actual); line = "column1,column2,\"LINESTRING( 1, 3, 5, 6, )\",column4"; expected = "COLUMN1,COLUMN2,\"LINESTRING\",COLUMN4"; actual = remover.removeWktData(line); assertEquals(expected, actual); line = "column1,column2,LINESTRING,column4"; expected = "COLUMN1,COLUMN2,LINESTRING,COLUMN4"; actual = remover.removeWktData(line); assertEquals(expected, actual); line = "column1,column2,column3,column4"; expected = "column1,column2,column3,column4"; actual = remover.removeWktData(line); assertEquals(expected, actual); line = "column1, column2, \"MULTILINESTRING ((22 26, 25 27, 24 28),(12 10, 13 14, 15 16),(50 51, 52 53, 54 55))\", column4"; expected = "COLUMN1, COLUMN2, \"MULTILINESTRING\", COLUMN4"; actual = remover.removeWktData(line); assertEquals(expected, actual); }
### Question: AbstractGeographicProjection extends AbstractProjection { @Override public Sphere getBoundingSphere(BoundingBox<GeographicPosition> bbox, Vector3d modelCenter, boolean forceGenerate) { GeographicBoundingBox geoBox = (GeographicBoundingBox)bbox; Vector3d[] modelCorners = new Vector3d[4]; modelCorners[0] = convertToModel(geoBox.getLowerLeft(), modelCenter); modelCorners[1] = convertToModel(geoBox.getUpperRight(), modelCenter); modelCorners[2] = convertToModel(geoBox.getLowerRight(), modelCenter); modelCorners[3] = convertToModel(geoBox.getUpperLeft(), modelCenter); double x0 = Double.MAX_VALUE; double x1 = -Double.MAX_VALUE; double y0 = Double.MAX_VALUE; double y1 = -Double.MAX_VALUE; double z0 = Double.MAX_VALUE; double z1 = -Double.MAX_VALUE; for (Vector3d corner : modelCorners) { x0 = Math.min(x0, corner.getX()); x1 = Math.max(x1, corner.getX()); y0 = Math.min(y0, corner.getY()); y1 = Math.max(y1, corner.getY()); z0 = Math.min(z0, corner.getZ()); z1 = Math.max(z1, corner.getZ()); } double x = (x0 + x1) * .5f; double y = (y0 + y1) * .5f; double z = (z0 + z1) * .5f; Vector3d center = new Vector3d(x, y, z); double radius = 0; for (Vector3d corner : modelCorners) { radius = Math.max(radius, center.distance(corner)); } return new DefaultSphere(center, radius); } @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 testGetBoundingSphere() { fail(NOT_YET_IMPLEMENTED); }
### Question: DateColumnValueProvider { public Date getDate(List<? extends String> row, DateColumn column) throws ParseException { StringBuilder dateStringBuilder = new StringBuilder(); dateStringBuilder.append(row.get(column.getPrimaryColumnIndex())); StringBuilder formatStringBuilder = new StringBuilder(); formatStringBuilder.append(column.getPrimaryColumnFormat()); if (column.getSecondaryColumnIndex() >= 0) { dateStringBuilder.append(' '); dateStringBuilder.append(row.get(column.getSecondaryColumnIndex())); formatStringBuilder.append(' '); formatStringBuilder.append(column.getSecondaryColumnFormat()); } String formatString = formatStringBuilder.toString(); String dateString = dateStringBuilder.toString(); if (formatString.contains("S")) { dateString = DateTimeUtilities.fixMillis(dateString); } SimpleDateFormat format = new SimpleDateFormat(formatString); return format.parse(dateString); } Date getDate(List<? extends String> row, DateColumn column); }### Answer: @Test public void testGetDate() throws ParseException { List<List<String>> data = CsvTestUtils.createMultipleTimesData(); List<String> testRow = data.get(1); DateColumn column = new DateColumn(); column.setPrimaryColumnIndex(0); String format = "yyyy-MM-dd'T'HH:mm:ss'Z'"; column.setPrimaryColumnFormat(format); DateColumnValueProvider provider = new DateColumnValueProvider(); Date actualDate = provider.getDate(testRow, column); Date expectedDate = new SimpleDateFormat(format).parse(testRow.get(0)); assertEquals(expectedDate, actualDate); } @Test public void testGetDateCompositeDate() throws ParseException { List<List<String>> data = CsvTestUtils.createMultipleTimesData(); List<String> testRow = data.get(1); DateColumn column = new DateColumn(); column.setPrimaryColumnIndex(8); String dateFormat = "MM-dd-yyyy"; column.setPrimaryColumnFormat(dateFormat); column.setSecondaryColumnIndex(9); String timeFormat = "HH:mm:ss"; column.setSecondaryColumnFormat(timeFormat); DateColumnValueProvider provider = new DateColumnValueProvider(); Date actualDate = provider.getDate(testRow, column); SimpleDateFormat expectedFormat = new SimpleDateFormat("MM-dd-yyyy HH:mm:ss"); Date expectedDate = expectedFormat.parse(testRow.get(8) + " " + testRow.get(9)); assertEquals(expectedDate, actualDate); }
### Question: DateTimeDetector implements CellDetector<DateColumnResults> { @Override public ValuesWithConfidence<DateColumnResults> detect(CellSampler sampler) { DateTimeFinder finder = new DateTimeFinder(myConfigurationProvider); finder.setIsJustDetectFormats(myIsJustDetectFormats); return new ValuesWithConfidence<DateColumnResults>(finder.findDates(sampler)); } DateTimeDetector(PreferencesRegistry prefsRegistry); @Override ValuesWithConfidence<DateColumnResults> detect(CellSampler sampler); void setIsJustDetectFormats(boolean isJustFormats); }### Answer: @Test public void testDetect() { DateFormatsConfig configuration = getDateFormats(); for (DateFormat format : configuration.getFormats()) { EasyMockSupport support = new EasyMockSupport(); PreferencesRegistry preferencesRegistry = createPreferencesRegistry(support, configuration); List<List<String>> data = DateDataGenerator.generateSingleDate(format); CellSampler cellSampler = createCellSampler(support, data); support.replayAll(); DateTimeDetector detector = new DateTimeDetector(preferencesRegistry); ValuesWithConfidence<DateColumnResults> value = detector.detect(cellSampler); if (format.getSdf().contains("y") && format.getType() == Type.TIMESTAMP || format.getType() == Type.DATE) { assertNotNull("Failed on format " + format.getSdf(), value.getBestValue().getUpTimeColumn()); assertEquals(format.getType(), value.getBestValue().getUpTimeColumn().getDateColumnType()); assertEquals(1, value.getBestValue().getUpTimeColumn().getPrimaryColumnIndex()); assertEquals(-1, value.getBestValue().getUpTimeColumn().getSecondaryColumnIndex()); assertNull(value.getBestValue().getDownTimeColumn()); } else { assertNull(value.getBestValue().getUpTimeColumn()); } support.verifyAll(); } }
### Question: AbstractGeographicProjection extends AbstractProjection { @Override public double getMinimumTerrainDistance(Viewer view) { Vector3d viewLoc = view.getPosition().getLocation(); return getTerrainIntersection(new Ray3d(viewLoc, viewLoc.multiply(-1).getNormalized()), view).subtract(viewLoc) .getLength(); } @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 public void testGetMinimumTerrainDistance() { Viewer mockViewer = createStrictMock(Viewer.class); ViewerPosition mockViewerPosition = createStrictMock(ViewerPosition.class); expect(mockViewer.getPosition()).andReturn(mockViewerPosition); expect(mockViewerPosition.getLocation()).andReturn(Vector3d.ORIGIN); replay(mockViewer, mockViewerPosition); assertEquals(0, myTestObject.getMinimumTerrainDistance(mockViewer), 0); verify(mockViewer, mockViewerPosition); }
### Question: DeciderFactory { public List<Decider> buildDeciders() { return New.list(new OneDayMultipleTimesDecider(), new CompositeDateTimeDecider(), new DateTimeDecider(), new DateDecider(), new TimeDecider()); } private DeciderFactory(); static DeciderFactory getInstance(); List<Decider> buildDeciders(); }### Answer: @Test public void testBuildDeciders() { List<Decider> deciders = DeciderFactory.getInstance().buildDeciders(); assertEquals(5, deciders.size()); assertTrue(deciders.get(0) instanceof OneDayMultipleTimesDecider); assertTrue(deciders.get(1) instanceof CompositeDateTimeDecider); assertTrue(deciders.get(2) instanceof DateTimeDecider); assertTrue(deciders.get(3) instanceof DateDecider); assertTrue(deciders.get(4) instanceof TimeDecider); }
### Question: CompositeDateTimeDecider implements Decider { @Override public List<Pair<PotentialColumn, Integer>> calculateConfidence(List<PotentialColumn> potentials, List<? extends List<? extends String>> sampleData) { List<Pair<PotentialColumn, Integer>> dateScores = myDateDecider.calculateConfidence(potentials, sampleData); Set<Integer> dateColumns = New.set(); for (Pair<PotentialColumn, Integer> pair : dateScores) { dateColumns.add(Integer.valueOf(pair.getFirstObject().getColumnIndex())); } List<PotentialColumn> timePotentials = New.list(); for (PotentialColumn column : potentials) { if (!dateColumns.contains(Integer.valueOf(column.getColumnIndex()))) { timePotentials.add(column); } } List<Pair<PotentialColumn, Integer>> timeScores = myTimeDecider.calculateConfidence(timePotentials, sampleData); Pair<PotentialColumn, Integer> bestDate = getBestPassingColumn(dateScores); List<Pair<PotentialColumn, Integer>> bestColumns = New.list(); if (bestDate != null) { Pair<PotentialColumn, Integer> bestTime = getBestPassingColumn(timeScores); if (bestTime != null && bestTime.getFirstObject().getColumnIndex() > bestDate.getFirstObject().getColumnIndex()) { bestColumns.add(bestDate); bestColumns.add(bestTime); } } return bestColumns; } @Override List<Pair<PotentialColumn, Integer>> calculateConfidence(List<PotentialColumn> potentials, List<? extends List<? extends String>> sampleData); @SuppressWarnings("null") @Override List<Pair<DateColumn, Integer>> compileResults(List<Pair<PotentialColumn, Integer>> potentials); @Override void setConfidence(int passingScore); }### Answer: @Test public void testCalculateConfidence() { List<List<String>> testData = CsvTestUtils.createMultipleTimesData(); List<PotentialColumn> potential = createPotentialColumn(); CompositeDateTimeDecider decider = new CompositeDateTimeDecider(); List<Pair<PotentialColumn, Integer>> score = decider.calculateConfidence(potential, testData); assertEquals((Integer)(testData.size() - testData.size() / 10), score.get(0).getSecondObject()); assertEquals(8, score.get(0).getFirstObject().getColumnIndex()); assertEquals((Integer)(testData.size() - testData.size() / 5), score.get(1).getSecondObject()); assertEquals(9, score.get(1).getFirstObject().getColumnIndex()); }
### Question: CompositeDateTimeDecider implements Decider { @SuppressWarnings("null") @Override public List<Pair<DateColumn, Integer>> compileResults(List<Pair<PotentialColumn, Integer>> potentials) { PotentialColumn datePart = null; SuccessfulFormat dateFormat = null; Integer datePartScore = null; PotentialColumn timePart = null; SuccessfulFormat timeFormat = null; Integer timePartScore = null; for (Pair<PotentialColumn, Integer> potential : potentials) { PotentialColumn column = potential.getFirstObject(); SuccessfulFormat successfulFormat = column.getMostSuccessfulFormat(); if (successfulFormat != null && successfulFormat.getFormat() != null && successfulFormat.getFormat().getType() == Type.DATE && datePart == null) { datePart = column; dateFormat = successfulFormat; datePartScore = potential.getSecondObject(); } if (successfulFormat != null && successfulFormat.getFormat() != null && successfulFormat.getFormat().getType() == Type.TIME && timePart == null) { timePart = column; timeFormat = successfulFormat; timePartScore = potential.getSecondObject(); } if (datePart != null && timePart != null) { break; } } List<Pair<DateColumn, Integer>> result = New.list(); if (dateFormat != null && timeFormat != null) { DateColumn column = new DateColumn(); column.setDateColumnType(Type.TIMESTAMP); column.setPrimaryColumnFormat(dateFormat.getFormat().getSdf()); column.setPrimaryColumnIndex(datePart.getColumnIndex()); column.setSecondaryColumnFormat(timeFormat.getFormat().getSdf()); column.setSecondaryColumnIndex(timePart.getColumnIndex()); int score = (datePartScore.intValue() + timePartScore.intValue()) / 2; result.add(new Pair<DateColumn, Integer>(column, Integer.valueOf(score))); } return result; } @Override List<Pair<PotentialColumn, Integer>> calculateConfidence(List<PotentialColumn> potentials, List<? extends List<? extends String>> sampleData); @SuppressWarnings("null") @Override List<Pair<DateColumn, Integer>> compileResults(List<Pair<PotentialColumn, Integer>> potentials); @Override void setConfidence(int passingScore); }### Answer: @Test public void testCompileResults() { List<PotentialColumn> potential = createPotentialColumn(); CompositeDateTimeDecider decider = new CompositeDateTimeDecider(); Pair<PotentialColumn, Integer> potentialAndScoreDate = new Pair<>(potential.get(0), 90); Pair<PotentialColumn, Integer> potentialAndScoreTime = new Pair<>(potential.get(1), 90); List<Pair<DateColumn, Integer>> results = decider.compileResults(New.list(potentialAndScoreDate, potentialAndScoreTime)); Pair<DateColumn, Integer> result = results.get(0); DateColumn column = result.getFirstObject(); assertEquals((Integer)90, result.getSecondObject()); assertEquals(8, column.getPrimaryColumnIndex()); assertEquals(9, column.getSecondaryColumnIndex()); assertEquals(Type.TIMESTAMP, column.getDateColumnType()); assertEquals("MM-dd-yyyy", column.getPrimaryColumnFormat()); assertEquals("HH:mm:ss", column.getSecondaryColumnFormat()); }
### Question: PotentialColumnComparator implements Comparator<PotentialColumn>, Serializable { @Override public int compare(PotentialColumn o1, PotentialColumn o2) { int o1MaxSuccesses = getMaxSuccesses(o1); int o2MaxSuccesses = getMaxSuccesses(o2); int compareValue = 0; if (o1MaxSuccesses > o2MaxSuccesses) { compareValue = -1; } else if (o2MaxSuccesses > o1MaxSuccesses) { compareValue = 1; } return compareValue; } @Override int compare(PotentialColumn o1, PotentialColumn o2); }### Answer: @Test public void testCompare() { List<PotentialColumn> testData = New.list(); for (int i = 0; i < 3; i++) { PotentialColumn column = new PotentialColumn(); column.setColumnIndex(i); for (int j = 0; j < 3; j++) { SuccessfulFormat format = new SuccessfulFormat(); format.setNumberOfSuccesses(j * i); column.getFormats().put("format" + j, format); } testData.add(column); } Collections.sort(testData, new PotentialColumnComparator()); int index = testData.size() - 1; for (PotentialColumn column : testData) { assertEquals(index, column.getColumnIndex()); index--; } }
### Question: AbstractGeographicProjection extends AbstractProjection { @Override public double getModelHeight() { final double northernmostLatitude = 90.; return convertToModel( new GeographicPosition(LatLonAlt.createFromDegrees(northernmostLatitude, 0., ReferenceLevel.ELLIPSOID)), Vector3d.ORIGIN).getY() * 2.; } @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 public void testGetModelHeight() { assertEquals(0.0, myTestObject.getModelHeight(), 0); }
### Question: AbstractGeographicProjection extends AbstractProjection { @Override public double getModelWidth() { final double easternmostLongitude = 180.; return convertToModel( new GeographicPosition(LatLonAlt.createFromDegrees(0., easternmostLongitude, ReferenceLevel.ELLIPSOID)), Vector3d.ORIGIN).getX() * 2.; } @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 public void testGetModelWidth() { assertEquals(0.0, myTestObject.getModelWidth(), 0); }
### Question: AbstractGeographicProjection extends AbstractProjection { @Override public void resetProjection(boolean highAccuracy) { } @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 public void testResetProjection() { myTestObject.resetProjection(false); }
### Question: DataDetector implements CellDetector<IntegerRange> { @Override public ValuesWithConfidence<IntegerRange> detect(CellSampler sampler) { int expectedCellCount = getExpectedCount(sampler); NonEmptyPredicate nonEmptyPredicate = new NonEmptyPredicate(); int firstDataRow = -1; for (int r = 0, n = sampler.getBeginningSampleCells().size(); r < n; r++) { List<? extends String> row = sampler.getBeginningSampleCells().get(r); boolean isDataRow = row.size() == expectedCellCount && row.stream().anyMatch(nonEmptyPredicate); if (isDataRow) { firstDataRow = r; break; } } int lastDataRow = -1; for (int r = sampler.getEndingSampleCells().size() - 1; r >= 0; --r) { List<? extends String> row = sampler.getEndingSampleCells().get(r); boolean isDataRow = row.size() == expectedCellCount && row.stream().anyMatch(nonEmptyPredicate); if (isDataRow) { lastDataRow = r + sampler.getEndingSampleLinesIndexOffset(); break; } } float confidence = firstDataRow == -1 ? 0f : 1f; return new ValuesWithConfidence<IntegerRange>(new IntegerRange(firstDataRow, lastDataRow), confidence); } @Override ValuesWithConfidence<IntegerRange> detect(CellSampler sampler); }### Answer: @Test public void testNoHeader() { List<String> rows = CsvTestUtils.createSparseRowData(); CellSampler sampler = new ListCellSampler(rows, rows, Character.valueOf(','), null, true); ValuesWithConfidence<IntegerRange> result = new DataDetector().detect(sampler); Assert.assertEquals(1f, result.getBestConfidence(), 0f); Assert.assertEquals(0, result.getBestValue().getMin().intValue()); Assert.assertEquals(23, result.getBestValue().getMax().intValue()); } @Test public void testWithHeader() { List<String> rows = CsvTestUtils.createSparseRowData(); CellSampler sampler = new ListCellSampler(rows, rows, Character.valueOf(','), null); ValuesWithConfidence<IntegerRange> result = new DataDetector().detect(sampler); Assert.assertEquals(1f, result.getBestConfidence(), 0f); Assert.assertEquals(2, result.getBestValue().getMin().intValue()); Assert.assertEquals(22, result.getBestValue().getMax().intValue()); }
### Question: HeaderDetector implements CellDetector<Integer> { @Override public ValuesWithConfidence<Integer> detect(CellSampler sampler) { ValuesWithConfidence<Integer> returnValue; if (myColumnCount > 1) { returnValue = detectFromMultipleColumns(sampler); } else { returnValue = detectFromSingleColumn(sampler); } return returnValue; } HeaderDetector(int columnCount); @Override ValuesWithConfidence<Integer> detect(CellSampler sampler); }### Answer: @Test public void testBasic() { List<List<String>> cells = CsvTestUtils.createBasicData(); CellSampler sampler = createMockCellSampler(cells); ValuesWithConfidence<Integer> result = new HeaderDetector(5).detect(sampler); Assert.assertEquals(1f, result.getBestConfidence(), 0f); Assert.assertEquals(0, result.getBestValue().intValue()); } @Test public void testCrap() { List<List<String>> cells = New.list(); List<String> rows = CsvTestUtils.createCrap(); for (String row : rows) { cells.add(Collections.singletonList(row)); } cells.addAll(CsvTestUtils.createBasicData()); CellSampler sampler = createMockCellSampler(cells); ValuesWithConfidence<Integer> result = new HeaderDetector(5).detect(sampler); Assert.assertEquals(1f, result.getBestConfidence(), 0f); Assert.assertEquals(rows.size(), result.getBestValue().intValue()); } @Test public void testNoHeader() { List<List<String>> cells = New.list(); List<String> rows = CsvTestUtils.createHardData(); for (String row : rows) { cells.add(Arrays.asList(row.split(","))); } CellSampler sampler = createMockCellSampler(cells); ValuesWithConfidence<Integer> result = new HeaderDetector(3).detect(sampler); Assert.assertEquals(0f, result.getBestConfidence(), 0f); } @Test public void testSpacesAndUnderscoresAndQuotes() { final List<List<String>> cells = New.list(); cells.add(Arrays.asList("There", " is a 'house'", " in_\"New_Orleans\"")); cells.add(Arrays.asList("5", "8", "12")); cells.add(Arrays.asList("a", "", "")); CellSampler sampler = createMockCellSampler(cells); ValuesWithConfidence<Integer> result = new HeaderDetector(3).detect(sampler); Assert.assertEquals(1f, result.getBestConfidence(), 0f); Assert.assertEquals(0, result.getBestValue().intValue()); }
### Question: CommentDetector implements LineDetector<Character> { @Override public ValuesWithConfidence<Character> detect(LineSampler sampler) { ValueWithConfidence<Character> result = new ValueWithConfidence<>(); TCharIntHashMap firstChars = new TCharIntHashMap(); for (String line : sampler.getBeginningSampleLines()) { if (!line.isEmpty()) { char firstChar = line.charAt(0); if (isComment(firstChar)) { if (!firstChars.containsKey(firstChar)) { firstChars.put(firstChar, 0); } firstChars.put(firstChar, firstChars.get(firstChar) + 1); } } } for (char ch : firstChars.keys()) { float confidence = getConfidenceMultiplier(ch); float firstCharLinePercentage = (sampler.getBeginningSampleLines().size() - firstChars.get(ch)) / (float)sampler.getBeginningSampleLines().size(); if (confidence > result.getConfidence() && firstCharLinePercentage > ourCommentThreshold) { result.setValue(Character.valueOf(ch)); result.setConfidence(confidence); } } return new ValuesWithConfidence<Character>(result); } CommentDetector(); CommentDetector(Character delimiter, Character quoteChar); @Override ValuesWithConfidence<Character> detect(LineSampler sampler); }### Answer: @Test public void testBasic() { ValuesWithConfidence<Character> result = new CommentDetector() .detect(new ListLineSampler(CsvTestUtils.createBasicDelimitedData(","))); Assert.assertNull(result.getBestValue()); } @Test public void testBasicWithEmptyLine() { List<String> data = CsvTestUtils.createBasicDelimitedData(",", Character.valueOf('"'), false); data.add(StringUtilities.join(",", new String[] { "", "", "", "", "" })); ValuesWithConfidence<Character> result = new CommentDetector().detect(new ListLineSampler(data)); Assert.assertNull(result.getBestValue()); } @Test public void testBasicWithQuotes() { ValuesWithConfidence<Character> result = new CommentDetector() .detect(new ListLineSampler(CsvTestUtils.createBasicDelimitedData(",", Character.valueOf('"'), false))); Assert.assertNull(result.getBestValue()); } @Test public void testHard() { ValuesWithConfidence<Character> result = new CommentDetector().detect(new ListLineSampler(CsvTestUtils.createHardData())); Assert.assertEquals(Character.valueOf('='), result.getBestValue()); } @Test public void testHashDelimiter() { List<String> data = CsvTestUtils.createBasicDelimitedData("#"); data.add(StringUtilities.join("#", new String[] { "", "", "", "", "" })); ValuesWithConfidence<Character> result = new CommentDetector(Character.valueOf('#'), null) .detect(new ListLineSampler(data)); Assert.assertNull(result.getBestValue()); }
### Question: AbstractGeographicProjection extends AbstractProjection { protected void cacheEllipsoid(BoundingBox<GeographicPosition> bbox, Ellipsoid ellipsoid) { myEllipsoidCache.put(bbox, ellipsoid); } @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 public void testCacheEllipsoid() { @SuppressWarnings("unchecked") BoundingBox<GeographicPosition> mockBox = createStrictMock(BoundingBox.class); Ellipsoid mockEllipsoid = createStrictMock(Ellipsoid.class); myTestObject.cacheEllipsoid(mockBox, mockEllipsoid); assertEquals(mockEllipsoid, myTestObject.getEllipsoidFromCache(mockBox)); }
### Question: LineOfBearingDetector implements CellDetector<LobColumnResults> { @Override public ValuesWithConfidence<LobColumnResults> detect(CellSampler sampler) { LobColumnResults ecr = new LobColumnResults(); for (int headerIndex = 0; headerIndex < sampler.getHeaderCells().size(); headerIndex++) { String colName = sampler.getHeaderCells().get(headerIndex); for (String lob : myLOBColumnNames) { if (lob.equalsIgnoreCase(colName.toLowerCase())) { LineOfBearingColumn lobCol = new LineOfBearingColumn(colName, headerIndex); ecr.setLineOfBearingColumn(lobCol); break; } } } return new ValuesWithConfidence<LobColumnResults>(ecr, Math.max(0f, ecr.getConfidence())); } LineOfBearingDetector(PreferencesRegistry prefsRegistry); @Override ValuesWithConfidence<LobColumnResults> detect(CellSampler sampler); List<String> getLineOfBearingColumnNames(); }### Answer: @Test public void testInValidLobColumnms() { LineOfBearingDetector lobDetector = new LineOfBearingDetector(LocationTestUtils.getPrefsRegistry()); Character delimiter = Character.valueOf(','); Character quote = Character.valueOf(' '); List<String> rows = CsvTestUtils.createBasicDelimitedData(String.valueOf(delimiter)); ListCellSampler lcs = new ListCellSampler(rows, delimiter, quote); ValuesWithConfidence<LobColumnResults> result = lobDetector.detect(lcs); Assert.assertTrue(result.getBestConfidence() < 1f); Assert.assertEquals(null, result.getBestValue().getLineOfBearingColumn()); }
### Question: LocationDetector implements CellDetector<LocationResults> { @Override public ValuesWithConfidence<LocationResults> detect(CellSampler sampler) { LocationResults aggregateResults = new LocationResults(); List<LocationDecider> deciders = LocationDeciderFactory.getInstance().buildDeciders(myPrefsRegistry); for (LocationDecider decider : deciders) { LocationResults results = decider.determineLocationColumns(sampler); List<LatLonColumnResults> latLonResults = results.getLatLonResults(); if (latLonResults != null && !latLonResults.isEmpty()) { for (LatLonColumnResults latLonResult : latLonResults) { if (latLonResult.getConfidence() > 0) { aggregateResults.addResult(latLonResult); } } } List<PotentialLocationColumn> locResults = results.getLocationResults(); if (locResults != null && !locResults.isEmpty()) { for (PotentialLocationColumn locResult : locResults) { if (locResult.getConfidence() > 0) { aggregateResults.addResult(locResult); } } } } LocationFormatDetector lfd = new LocationFormatDetector(); lfd.detectLocationColumnFormats(aggregateResults, sampler.getBeginningSampleCells()); return new ValuesWithConfidence<LocationResults>(aggregateResults, Math.max(0f, aggregateResults.getConfidence())); } LocationDetector(PreferencesRegistry prefsRegistry); @Override ValuesWithConfidence<LocationResults> detect(CellSampler sampler); }### Answer: @Test public void testAdvancedLocationData() { LocationDetector latlonDetector = new LocationDetector(LocationTestUtils.getPrefsRegistry()); Character delimiter = Character.valueOf(','); Character quote = Character.valueOf('"'); List<String> rows = CsvTestUtils.createMultipleDelimitedLatLonData(String.valueOf(delimiter)); ListCellSampler lcs = new ListCellSampler(rows, delimiter, quote); ValuesWithConfidence<LocationResults> result = latlonDetector.detect(lcs); Assert.assertEquals(1f, result.getBestValue().getConfidence(), 0f); } @Test public void testMultipleDelimitedLocationData() { LocationDetector latlonDetector = new LocationDetector(LocationTestUtils.getPrefsRegistry()); Character delimiter = Character.valueOf(','); Character quote = Character.valueOf('"'); List<String> rows = CsvTestUtils.createMultipleDelimitedLocationData(String.valueOf(delimiter), quote); ListCellSampler lcs = new ListCellSampler(rows, delimiter, quote); ValuesWithConfidence<LocationResults> result = latlonDetector.detect(lcs); Assert.assertEquals(1f, result.getBestValue().getConfidence(), 0f); } @Test public void testNoLocationData() { LocationDetector latlonDetector = new LocationDetector(LocationTestUtils.getPrefsRegistry()); Character delimiter = Character.valueOf(','); Character quote = Character.valueOf('"'); List<String> rows = CsvTestUtils.createNoLocationData(String.valueOf(delimiter)); ListCellSampler lcs = new ListCellSampler(rows, delimiter, quote); ValuesWithConfidence<LocationResults> result = latlonDetector.detect(lcs); Assert.assertEquals(0f, result.getBestValue().getConfidence(), 0f); }
### Question: ByteUtilities { public static int readNBytes(InputStream in, OutputStream out, int byteCount) throws IOException { int totalBytesRead = 0; int bytesRead; byte[] bytes = new byte[BUFFER_SIZE]; while (totalBytesRead < byteCount) { bytesRead = in.read(bytes, 0, Math.min(bytes.length, byteCount - totalBytesRead)); if (bytesRead > 0) { out.write(bytes, 0, bytesRead); totalBytesRead += bytesRead; } else if (bytesRead == -1) { break; } } return totalBytesRead; } private ByteUtilities(); static int readNBytes(InputStream in, OutputStream out, int byteCount); static boolean readUntilInclusive(PushbackInputStream in, OutputStream out, byte[] marker); }### Answer: @Test public void testReadNBytes() throws IOException { ByteArrayInputStream in = new ByteArrayInputStream(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }); ByteArrayOutputStream out = new ByteArrayOutputStream(); int bytesRead = ByteUtilities.readNBytes(in, out, 5); Assert.assertEquals(5, bytesRead); Assert.assertTrue(Arrays.equals(new byte[] { 1, 2, 3, 4, 5 }, out.toByteArray())); Assert.assertEquals(6, in.read()); out.reset(); bytesRead = ByteUtilities.readNBytes(in, out, 5); Assert.assertEquals(2, bytesRead); Assert.assertTrue(Arrays.equals(new byte[] { 7, 8 }, out.toByteArray())); Assert.assertEquals(-1, in.read()); }
### Question: ByteUtilities { public static boolean readUntilInclusive(PushbackInputStream in, OutputStream out, byte[] marker) throws IOException { int bytesRead; byte[] bytes = new byte[BUFFER_SIZE]; byte[] mostRecentBytes = new byte[marker.length - 1]; while ((bytesRead = in.read(bytes)) != -1) { if (bytesRead > 0) { int index = indexOf(bytes, bytesRead, marker); if (index != -1) { int writeLength = index + marker.length; out.write(bytes, 0, writeLength); in.unread(bytes, writeLength, bytesRead - writeLength); break; } else { byte[] combinedBytes = concat(mostRecentBytes, bytes, Math.min(bytesRead, marker.length - 1)); index = indexOf(combinedBytes, combinedBytes.length, marker); if (index != -1) { out.write(bytes, 0, index + 1); break; } else { out.write(bytes, 0, bytesRead); } } shift(mostRecentBytes, bytes, bytesRead); } } return bytesRead == -1; } private ByteUtilities(); static int readNBytes(InputStream in, OutputStream out, int byteCount); static boolean readUntilInclusive(PushbackInputStream in, OutputStream out, byte[] marker); }### Answer: @Test public void testReadUntilInclusive() throws IOException { PushbackInputStream in = new PushbackInputStream(new ByteArrayInputStream(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }), 10); ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteUtilities.readUntilInclusive(in, out, new byte[] { 4, 5, 6 }); Assert.assertTrue(Arrays.equals(new byte[] { 1, 2, 3, 4, 5, 6 }, out.toByteArray())); Assert.assertEquals(7, in.read()); Assert.assertEquals(8, in.read()); Assert.assertEquals(-1, in.read()); }
### Question: ByteUtilities { static int indexOf(byte[] bytes, int byteLength, byte[] marker) { int index = -1; int length = byteLength - (marker.length - 1); for (int b = 0; b < length; b++) { boolean equals = true; for (int m = 0; m < marker.length; m++) { if (bytes[b + m] != marker[m]) { equals = false; break; } } if (equals) { return b; } } return index; } private ByteUtilities(); static int readNBytes(InputStream in, OutputStream out, int byteCount); static boolean readUntilInclusive(PushbackInputStream in, OutputStream out, byte[] marker); }### Answer: @Test public void testIndexOf() { Assert.assertEquals(2, ByteUtilities.indexOf(new byte[] { 1, 2, 3, 4, 5 }, 5, new byte[] { 3, 4 })); Assert.assertEquals(3, ByteUtilities.indexOf(new byte[] { 1, 2, 3, 4, 5 }, 5, new byte[] { 4, 5 })); Assert.assertEquals(4, ByteUtilities.indexOf(new byte[] { 1, 2, 3, 4, 5 }, 5, new byte[] { 5 })); Assert.assertEquals(-1, ByteUtilities.indexOf(new byte[] { 1, 2, 3, 4, 5 }, 5, new byte[] { 5, 6 })); }
### Question: ByteUtilities { static void shift(byte[] bytes, byte[] newBytes, int newByteLength) { if (newBytes.length >= bytes.length) { System.arraycopy(newBytes, newByteLength - bytes.length, bytes, 0, bytes.length); } else { System.arraycopy(bytes, newByteLength, bytes, 0, bytes.length - newByteLength); System.arraycopy(newBytes, 0, bytes, bytes.length - newByteLength, newByteLength); } } private ByteUtilities(); static int readNBytes(InputStream in, OutputStream out, int byteCount); static boolean readUntilInclusive(PushbackInputStream in, OutputStream out, byte[] marker); }### Answer: @Test public void testShift() { byte[] bytes = new byte[] { 0, 0, 0 }; ByteUtilities.shift(bytes, new byte[] { 1, 2, 3, 4, 5 }, 5); Assert.assertTrue(Arrays.equals(new byte[] { 3, 4, 5 }, bytes)); ByteUtilities.shift(bytes, new byte[] { 1, 2, 3 }, 3); Assert.assertTrue(Arrays.equals(new byte[] { 1, 2, 3 }, bytes)); bytes = new byte[] { 0, 1, 2, 3, 4, 5 }; ByteUtilities.shift(bytes, new byte[] { 6, 7 }, 2); Assert.assertTrue(Arrays.equals(new byte[] { 2, 3, 4, 5, 6, 7 }, bytes)); ByteUtilities.shift(bytes, new byte[] { 8, 9, 10 }, 2); Assert.assertTrue(Arrays.equals(new byte[] { 4, 5, 6, 7, 8, 9 }, bytes)); }
### Question: ByteUtilities { static byte[] concat(byte[] b1, byte[] b2, int b2Length) { byte[] concat = new byte[b1.length + b2Length]; System.arraycopy(b1, 0, concat, 0, b1.length); System.arraycopy(b2, 0, concat, b1.length, b2Length); return concat; } private ByteUtilities(); static int readNBytes(InputStream in, OutputStream out, int byteCount); static boolean readUntilInclusive(PushbackInputStream in, OutputStream out, byte[] marker); }### Answer: @Test public void testConcat() { Assert.assertTrue(Arrays.equals(new byte[] { 1, 2, 3, 4, 5, 6 }, ByteUtilities.concat(new byte[] { 1, 2 }, new byte[] { 3, 4, 5, 6 }, 4))); }
### Question: OSHGetResultEnvoy extends AbstractOSHEnvoy { static String getTimeString(TimeSpan timeSpan) { String timeString; if (timeSpan.isZero() || timeSpan.isTimeless()) { timeString = "now"; } else if (timeSpan.isUnboundedStart()) { timeString = "now/" + DateTimeUtilities.generateISO8601DateString(timeSpan.getEndDate()); } else if (timeSpan.isUnboundedEnd()) { timeString = DateTimeUtilities.generateISO8601DateString(timeSpan.getStartDate()) + "/now"; } else if (timeSpan.isInstantaneous()) { timeString = DateTimeUtilities.generateISO8601DateString(timeSpan.getStartDate()); } else { timeString = timeSpan.toISO8601String(); } return timeString; } OSHGetResultEnvoy(Toolbox toolbox); @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 testGetTimeString() { SimpleDateFormat format = new SimpleDateFormat(DateTimeFormats.DATE_FORMAT); try { Assert.assertEquals("2013-04-09T00:00:00Z", OSHGetResultEnvoy.getTimeString(TimeSpan.get(DateTimeUtilities.parse(format, "2013-04-09")))); Assert.assertEquals("now", OSHGetResultEnvoy.getTimeString(TimeSpan.ZERO)); Assert.assertEquals("now", OSHGetResultEnvoy.getTimeString(TimeSpan.TIMELESS)); Assert.assertEquals("2013-04-09T00:00:00Z/2013-04-10T00:00:00Z", OSHGetResultEnvoy.getTimeString( TimeSpan.get(DateTimeUtilities.parse(format, "2013-04-09"), DateTimeUtilities.parse(format, "2013-04-10")))); Assert.assertEquals("2013-04-09T00:00:00Z/now", OSHGetResultEnvoy .getTimeString(TimeSpan.newUnboundedEndTimeSpan(DateTimeUtilities.parse(format, "2013-04-09")))); Assert.assertEquals("now/2013-04-09T00:00:00Z", OSHGetResultEnvoy .getTimeString(TimeSpan.newUnboundedStartTimeSpan(DateTimeUtilities.parse(format, "2013-04-09")))); } catch (ParseException e) { Assert.fail(e.getMessage()); } }
### Question: AerialImageryTransformer extends DefaultTransformer implements RefreshListener, EventListener<DataTypeInfoColorChangeEvent> { @Override public void close() { myEventManager.unsubscribe(DataTypeInfoColorChangeEvent.class, this); myTimeNotifier.close(); List<Geometry> toRemove = New.list(); for (List<Geometry> geometries : myPublishedGeometries.values()) { toRemove.addAll(geometries); } toRemove.addAll(myBuilderFactory.close()); publishGeometries(New.list(), toRemove); myPublishedGeometries.clear(); super.close(); } AerialImageryTransformer(Toolbox toolbox, OSHImageQuerier querier, DataTypeInfo uavLayer, List<DataTypeInfo> linkedLayer); @Override void close(); List<DataTypeInfo> getLinkedLayer(); @Override synchronized void notify(DataTypeInfoColorChangeEvent event); @Override void open(); @Override synchronized void refresh(boolean forceIt); @Override void refreshNow(); }### Answer: @SuppressWarnings("unchecked") @Test public void testClose() throws QueryException, IOException { EasyMockSupport support = new EasyMockSupport(); EventManager eventManager = createEventManager(support); eventManager.unsubscribe(EasyMock.eq(DataTypeInfoColorChangeEvent.class), EasyMock.isA(AerialImageryTransformer.class)); TimeManager timeManager = createTimeManager(support); timeManager.removeActiveTimeSpanChangeListener(EasyMock.isA(TimeRefreshNotifier.class)); AnimationManager animationManager = createAnimationManager(support); animationManager.removeAnimationChangeListener(EasyMock.isA(TimeRefreshNotifier.class)); List<PlatformMetadata> testData = New.list(createMetadata()); OrderParticipantKey expectedUAVKey = support.createMock(OrderParticipantKey.class); OrderParticipantKey expectedVideoKey = support.createMock(OrderParticipantKey.class); OrderManagerRegistry orderRegistry = createOrderRegistry(support, expectedUAVKey, expectedVideoKey, 1); Toolbox toolbox = createToolbox(support, eventManager, timeManager, animationManager, testData, orderRegistry, 1); DataTypeInfo videoLayer = createVideoLayer(support, expectedVideoKey); OSHImageQuerier querier = createQuerier(support, videoLayer, 1); List<DataTypeInfo> linkedLayer = New.list(videoLayer); DataTypeInfo uavLayer = createUAVDataType(support, expectedUAVKey, 1); GenericSubscriber<Geometry> receiver = createReceiver(support); receiver.receiveObjects(EasyMock.isA(AerialImageryTransformer.class), EasyMock.isA(List.class), EasyMock.isA(List.class)); EasyMock.expectLastCall().andAnswer(this::removeGeometriesAnswer); support.replayAll(); AerialImageryTransformer transformer = new AerialImageryTransformer(toolbox, querier, uavLayer, linkedLayer); transformer.addSubscriber(receiver); transformer.open(); myListener.activeTimeSpansChanged(null); transformer.close(); support.verifyAll(); }
### Question: PlatformMetadataProvider implements ModelProvider { @Override public PlatformMetadata getModel(DataTypeInfo dataType, DataTypeInfo videoLayer, long time, PlatformMetadata previousMetadata) { DataModelCategory category = new DataModelCategory(dataType.getUrl(), Constants.PLATFORM_METADATA_FAMILY, dataType.getTypeKey()); PropertyMatcher<Long> lte = new NumberPropertyMatcher<Long>(Constants.METADATA_TIMESTAMP_PROPERTY_DESCRIPTOR, OperatorType.LTE, Long.valueOf(time)); PropertyMatcher<Long> gte = new NumberPropertyMatcher<Long>(Constants.METADATA_TIMESTAMP_PROPERTY_DESCRIPTOR, OperatorType.GTE, Long.valueOf(time - 1000)); SimpleQuery<PlatformMetadata> query = new SimpleQuery<>(category, Constants.PLATFORM_METADATA_DESCRIPTOR, New.list(lte, gte)); myDataRegistry.performQuery(query); PlatformMetadata metadata = null; if (query.getResults() != null && !query.getResults().isEmpty()) { for (PlatformMetadata aMetadata : query.getResults()) { if (aMetadata.getTime().getTime() <= time && (metadata == null || metadata.getTime().getTime() < aMetadata.getTime().getTime())) { metadata = aMetadata; } } } return metadata; } PlatformMetadataProvider(DataRegistry dataRegistry); @Override PlatformMetadata getModel(DataTypeInfo dataType, DataTypeInfo videoLayer, long time, PlatformMetadata previousMetadata); }### Answer: @Test public void testGetModel() { EasyMockSupport support = new EasyMockSupport(); List<PlatformMetadata> testData = createTestData(); DataRegistry dataRegistry = createRegistry(support, testData); DataTypeInfo dataType = createDataType(support); DataTypeInfo videoLayer = support.createMock(DataTypeInfo.class); support.replayAll(); PlatformMetadataProvider provider = new PlatformMetadataProvider(dataRegistry); PlatformMetadata metadata = provider.getModel(dataType, videoLayer, ourQueryTime, null); assertEquals(testData.get(testData.size() - 1), metadata); support.verifyAll(); }
### Question: Earth3D extends GeographicBody3D { @Override public Vector3d convertToModel(GeographicPosition inPos, Vector3d modelCenter) { LatLonAlt lla = inPos.getLatLonAlt(); double φ = Math.toRadians(lla.getLatD()); double λ = Math.toRadians(lla.getLonD()); double altM = lla.getAltM(); double cosλ = Math.cos(λ); double sinλ = Math.sin(λ); double cosφ = Math.cos(φ); double sinφ = Math.sin(φ); Vector3d vec; if (inPos.getLatLonAlt().getAltitudeReference() == Altitude.ReferenceLevel.ELLIPSOID) { double denom = Math.sqrt(cosφ * cosφ + WGS84EarthConstants.ONE_MINUS_FLATTENING_SQ * sinφ * sinφ); double semiMajOverDenom = WGS84EarthConstants.SEMI_MAJOR_AXIS_M / denom; double r = (semiMajOverDenom + altM) * cosφ; double s = (semiMajOverDenom * WGS84EarthConstants.ONE_MINUS_FLATTENING_SQ + altM) * sinφ; vec = new Vector3d(r * cosλ - modelCenter.getX(), r * sinλ - modelCenter.getY(), s - modelCenter.getZ()); } else if (inPos.getLatLonAlt().getAltitudeReference() == Altitude.ReferenceLevel.ORIGIN) { vec = new Vector3d(altM * cosφ * cosλ - modelCenter.getX(), altM * cosφ * sinλ - modelCenter.getY(), altM * sinφ - modelCenter.getZ()); } else { throw new UnexpectedEnumException(inPos.getLatLonAlt().getAltitudeReference()); } return vec; } Earth3D(); @Override Vector3d convertToModel(GeographicPosition inPos, Vector3d modelCenter); @Override GeographicPosition convertToPosition(Vector3d inPos, ReferenceLevel altReference); @Override Vector3d getNormalAtPosition(GeographicPosition inPos); }### Answer: @Test public void testConvertToModel() { final double latD = 22.5; final double lonD = 67.5; final double elevationM = 4557.75; Earth3D earth = new Earth3D(); GeographicPosition origGeo = new GeographicPosition( LatLonAlt.createFromDegreesMeters(latD, lonD, elevationM, Altitude.ReferenceLevel.ELLIPSOID)); Vector3d model = earth.convertToModel(origGeo, Vector3d.ORIGIN); GeographicPosition reGeo = earth.convertToPosition(model, ReferenceLevel.ELLIPSOID); Assert.assertTrue(MathUtil.isZero(latD - reGeo.getLatLonAlt().getLatD(), 0.00001)); Assert.assertTrue(MathUtil.isZero(lonD - reGeo.getLatLonAlt().getLonD(), 0.00001)); Assert.assertTrue(MathUtil.isZero(elevationM - reGeo.getLatLonAlt().getAltM(), 0.00001)); }
### Question: ModelProviderFactory { public List<ModelProvider> createProviders() { return New.list(new PlatformMetadataProvider(myDataRegistry), new AerialImageProvider(myQuerier)); } ModelProviderFactory(DataRegistry dataRegistry, OSHImageQuerier querier); List<ModelProvider> createProviders(); }### Answer: @Test public void testCreateProviders() { EasyMockSupport support = new EasyMockSupport(); DataRegistry dataRegistry = support.createMock(DataRegistry.class); OSHImageQuerier querier = support.createMock(OSHImageQuerier.class); support.replayAll(); ModelProviderFactory factory = new ModelProviderFactory(dataRegistry, querier); List<ModelProvider> providers = factory.createProviders(); assertEquals(2, providers.size()); assertTrue(providers.get(0) instanceof PlatformMetadataProvider); assertTrue(providers.get(1) instanceof AerialImageProvider); support.verifyAll(); }
### Question: FootprintGeometryBuilder implements GeometryBuilder { @Override public Pair<List<Geometry>, List<Geometry>> buildGeometries(PlatformMetadata model, DataTypeInfo uavDataType, DataTypeInfo videoLayer) { PolygonGeometry.Builder<GeographicPosition> builder = new PolygonGeometry.Builder<>(); builder.setVertices(model.getFootprint().getVertices()); OrderParticipantKey orderKey = uavDataType.getOrderKey(); int zorder = myOrderManager.getOrderManager(orderKey).getOrder(orderKey); Constraints constraints = new MutableConstraints( TimeConstraint.getMostRecentTimeConstraint(uavDataType.getTypeKey(), model.getTime().getTime())); PolygonRenderProperties renderProperties = new DefaultPolygonRenderProperties(zorder, true, true); renderProperties.setColor(uavDataType.getBasicVisualizationInfo().getTypeColor()); renderProperties.setHidden(!uavDataType.isVisible()); setOpacity(renderProperties, uavDataType.getBasicVisualizationInfo().getTypeOpacity()); return new Pair<>(New.list(new PolygonGeometry(builder, renderProperties, constraints)), New.list()); } FootprintGeometryBuilder(OrderManagerRegistry orderRegistry); @Override Pair<List<Geometry>, List<Geometry>> buildGeometries(PlatformMetadata model, DataTypeInfo uavDataType, DataTypeInfo videoLayer); @Override boolean cachePublishedGeometries(); }### Answer: @Test public void test() { EasyMockSupport support = new EasyMockSupport(); OrderParticipantKey key = createKey(support); OrderManagerRegistry orderRegistry = createOrderRegistry(support, key); DataTypeInfo dataType = createDataType(support, key, true); PlatformMetadata metadata = createMetadata(); support.replayAll(); FootprintGeometryBuilder builder = new FootprintGeometryBuilder(orderRegistry); List<Geometry> geometries = builder.buildGeometries(metadata, dataType, null).getFirstObject(); assertEquals(1, geometries.size()); PolygonGeometry geometry = (PolygonGeometry)geometries.get(0); assertEquals(metadata.getFootprint().getVertices(), geometry.getVertices()); PolygonRenderProperties renderProps = geometry.getRenderProperties(); assertEquals(ourZOrder, renderProps.getZOrder()); assertTrue(renderProps.isPickable()); assertTrue(renderProps.isDrawable()); assertEquals(ColorUtilities.opacitizeColor(ourColor, ourOpacity / 255f), renderProps.getColor()); assertFalse(renderProps.isHidden()); TimeConstraint constraint = geometry.getConstraints().getTimeConstraint(); assertEquals(ourTypeKey, constraint.getKey()); assertEquals(TimeSpan.get(metadata.getTime()), constraint.getTimeSpan()); support.verifyAll(); }
### Question: BuilderFactory { public List<GeometryBuilder> createBuilders(PlatformMetadata model) { List<GeometryBuilder> builders = New.list(); if (model instanceof PlatformMetadataAndImage) { builders.add(myImageBuilder); } else { builders.add(myFootprintBuilder); builders.add(myVehicleBuilder); } return builders; } BuilderFactory(OrderManagerRegistry orderRegistry, MapContext<? extends Viewer> mapManager); List<Geometry> close(); List<GeometryBuilder> createBuilders(PlatformMetadata model); }### Answer: @Test public void testMetadata() { EasyMockSupport support = new EasyMockSupport(); OrderManagerRegistry orderRegistry = support.createMock(OrderManagerRegistry.class); @SuppressWarnings("unchecked") MapContext<? extends Viewer> mapManager = support.createMock(MapContext.class); PlatformMetadata metadata = new PlatformMetadata(); support.replayAll(); BuilderFactory factory = new BuilderFactory(orderRegistry, mapManager); List<GeometryBuilder> builders = factory.createBuilders(metadata); assertEquals(2, builders.size()); assertTrue(builders.get(0) instanceof FootprintGeometryBuilder); assertTrue(builders.get(1) instanceof PlatformGeometryBuilder); support.verifyAll(); } @Test public void testMetadataImage() { EasyMockSupport support = new EasyMockSupport(); OrderManagerRegistry orderRegistry = support.createMock(OrderManagerRegistry.class); @SuppressWarnings("unchecked") MapContext<? extends Viewer> mapManager = support.createMock(MapContext.class); PlatformMetadata justMetadata = new PlatformMetadata(); PlatformMetadataAndImage metadata = new PlatformMetadataAndImage(justMetadata, ByteBuffer.wrap(new byte[] { 1, 2, 3 })); support.replayAll(); BuilderFactory factory = new BuilderFactory(orderRegistry, mapManager); List<GeometryBuilder> builders = factory.createBuilders(metadata); assertEquals(1, builders.size()); assertTrue(builders.get(0) instanceof ImageGeometryBuilder); support.verifyAll(); }
### Question: PlatformGeometryBuilder implements GeometryBuilder { @Override public boolean cachePublishedGeometries() { return false; } PlatformGeometryBuilder(MapContext<? extends Viewer> mapManager); @Override Pair<List<Geometry>, List<Geometry>> buildGeometries(PlatformMetadata model, DataTypeInfo uavDataType, DataTypeInfo videoLayer); @Override boolean cachePublishedGeometries(); List<Geometry> close(); }### Answer: @SuppressWarnings("unchecked") @Test public void testCachePublishedGeometries() { EasyMockSupport support = new EasyMockSupport(); MapContext<? extends Viewer> mapManager = support.createMock(MapContext.class); support.replayAll(); PlatformGeometryBuilder builder = new PlatformGeometryBuilder(mapManager); assertFalse(builder.cachePublishedGeometries()); support.verifyAll(); }
### Question: PlatformGeometryBuilder implements GeometryBuilder { public List<Geometry> close() { List<Geometry> toRemove = New.list(); for (List<Geometry> geoms : myPublished.values()) { toRemove.addAll(geoms); } return toRemove; } PlatformGeometryBuilder(MapContext<? extends Viewer> mapManager); @Override Pair<List<Geometry>, List<Geometry>> buildGeometries(PlatformMetadata model, DataTypeInfo uavDataType, DataTypeInfo videoLayer); @Override boolean cachePublishedGeometries(); List<Geometry> close(); }### Answer: @Test public void testClose() { EasyMockSupport support = new EasyMockSupport(); MapContext<? extends Viewer> mapManager = createMapManager(support); DataTypeInfo dataType = createDataType(support); DataTypeInfo videoLayer = support.createMock(DataTypeInfo.class); PlatformMetadata metadata = createMetadata(); support.replayAll(); PlatformGeometryBuilder builder = new PlatformGeometryBuilder(mapManager); Pair<List<Geometry>, List<Geometry>> addsAndRemoves = builder.buildGeometries(metadata, dataType, videoLayer); assertTrue(addsAndRemoves.getSecondObject().isEmpty()); List<Geometry> geometries = addsAndRemoves.getFirstObject(); List<PolygonMeshGeometry> meshes = getMeshes(geometries); List<PolylineGeometry> lines = getLines(geometries); Matrix4d expected = new Matrix4d(new double[] { -.0008035867145991338, -0.002768272986857213, -0.009575537220561378, 0, -0.0037781292850447104, -0.00880517522006317, 0.0028626261456000334, 0, -0.009223881368361542, 0.003847798593250691, -0.0003383171414083064, 0, -86.5819168, 34.6905037, 0, 1 }); assertMeshes(meshes, expected); assertLines(lines); List<Geometry> toRemove = builder.close(); assertEquals(geometries, toRemove); support.verifyAll(); }
### Question: ImageGeometryBuilder implements GeometryBuilder { @Override public boolean cachePublishedGeometries() { return false; } ImageGeometryBuilder(OrderManagerRegistry orderRegistry); @Override Pair<List<Geometry>, List<Geometry>> buildGeometries(PlatformMetadata model, DataTypeInfo uavDataType, DataTypeInfo videoLayer); @Override boolean cachePublishedGeometries(); List<Geometry> close(); }### Answer: @Test public void testCachePublishedGeometries() { EasyMockSupport support = new EasyMockSupport(); OrderManagerRegistry orderRegistry = support.createMock(OrderManagerRegistry.class); support.replayAll(); ImageGeometryBuilder builder = new ImageGeometryBuilder(orderRegistry); assertFalse(builder.cachePublishedGeometries()); support.verifyAll(); }
### Question: ImageGeometryBuilder implements GeometryBuilder { public List<Geometry> close() { return New.list(myGeometries.values()); } ImageGeometryBuilder(OrderManagerRegistry orderRegistry); @Override Pair<List<Geometry>, List<Geometry>> buildGeometries(PlatformMetadata model, DataTypeInfo uavDataType, DataTypeInfo videoLayer); @Override boolean cachePublishedGeometries(); List<Geometry> close(); }### Answer: @Test public void testClose() throws IOException { EasyMockSupport support = new EasyMockSupport(); DataTypeInfo uavDataType = support.createMock(DataTypeInfo.class); OrderParticipantKey key = support.createMock(OrderParticipantKey.class); OrderManagerRegistry orderRegistry = createOrderRegistry(support, key); DataTypeInfo videoLayer = createVideoLayer(support, key); PlatformMetadata model = createTestData(1).get(0); support.replayAll(); ImageGeometryBuilder builder = new ImageGeometryBuilder(orderRegistry); Pair<List<Geometry>, List<Geometry>> addsAndRemoves = builder.buildGeometries(model, uavDataType, videoLayer); assertTrue(addsAndRemoves.getSecondObject().isEmpty()); List<Geometry> adds = addsAndRemoves.getFirstObject(); assertEquals(1, adds.size()); TileGeometry geometry = (TileGeometry)adds.get(0); assertNull(geometry.getSplitJoinRequestProvider()); assertNull(geometry.getParent()); assertTrue(geometry.isRapidUpdate()); assertEquals(model.getFootprint(), geometry.getBounds()); TileRenderProperties props = geometry.getRenderProperties(); assertEquals(ourZOrder, props.getZOrder()); assertTrue(props.isDrawable()); assertFalse(props.isPickable()); assertEquals(ourOpacity, props.getOpacity(), 0f); ImageManager imageManager = geometry.getImageManager(); assertDirtyRegion(imageManager); assertNotNull(((ImageIOImage)imageManager.getCachedImageData().getImageMap().values().iterator().next()).getAWTImage()); List<Geometry> geoms = builder.close(); assertEquals(1, geoms.size()); assertEquals(geometry, geoms.get(0)); support.verifyAll(); }
### Question: LinkedLayers { public List<LinkedLayer> getLinkedLayers() { return myLinkedLayers; } List<LinkedLayer> getLinkedLayers(); }### Answer: @Test public void testDeserialize() throws JAXBException { String xml = "<LinkedLayers><LinkedLayer><linkedLayersTypeKey>linkedTypeKey1</linkedLayersTypeKey>" + "<otherLinkedLayersTypeKey>otherLinkedTypeKey1</otherLinkedLayersTypeKey></LinkedLayer>" + "<LinkedLayer><linkedLayersTypeKey>linkedTypeKey2</linkedLayersTypeKey>" + "<otherLinkedLayersTypeKey>otherLinkedTypeKey2</otherLinkedLayersTypeKey></LinkedLayer></LinkedLayers>"; ByteArrayInputStream stream = new ByteArrayInputStream(xml.getBytes(StringUtilities.DEFAULT_CHARSET)); LinkedLayers linkedLayers = XMLUtilities.readXMLObject(stream, LinkedLayers.class); assertEquals(2, linkedLayers.getLinkedLayers().size()); int index = 1; for (LinkedLayer linkedLayer : linkedLayers.getLinkedLayers()) { assertEquals("linkedTypeKey" + index, linkedLayer.getLinkedLayersTypeKey()); assertEquals("otherLinkedTypeKey" + index, linkedLayer.getOtherLinkedLayersTypeKey()); index++; } } @Test public void testSerialize() throws JAXBException { String xml = String.format("<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + "<LinkedLayers>%n" + " <LinkedLayer>%n <linkedLayersTypeKey>linkedTypeKey1</linkedLayersTypeKey>%n" + " <otherLinkedLayersTypeKey>otherLinkedTypeKey1</otherLinkedLayersTypeKey>%n </LinkedLayer>%n" + " <LinkedLayer>%n <linkedLayersTypeKey>linkedTypeKey2</linkedLayersTypeKey>%n" + " <otherLinkedLayersTypeKey>otherLinkedTypeKey2</otherLinkedLayersTypeKey>%n </LinkedLayer>%n" + "</LinkedLayers>%n"); LinkedLayers linkedLayers = new LinkedLayers(); LinkedLayer linkedLayer = new LinkedLayer(); linkedLayer.setLinkedLayersTypeKey("linkedTypeKey1"); linkedLayer.setOtherLinkedLayersTypeKey("otherLinkedTypeKey1"); linkedLayers.getLinkedLayers().add(linkedLayer); linkedLayer = new LinkedLayer(); linkedLayer.setLinkedLayersTypeKey("linkedTypeKey2"); linkedLayer.setOtherLinkedLayersTypeKey("otherLinkedTypeKey2"); linkedLayers.getLinkedLayers().add(linkedLayer); String actualXml = XMLUtilities.writeXMLObjectToString(linkedLayers); assertEquals(xml, actualXml); }
### Question: AerialPlatformResultHandler implements ResultHandler, EventListener<ActiveDataGroupsChangedEvent> { @Override public List<Output> canHandle(List<Output> outputs) { List<Output> canHandles = New.list(); for (Output output : outputs) { if (ourPlatformLocationName.equals(output.getName()) || ourPlatformAttitudeName.equals(output.getName()) || ourGimbalAttitudeName.equals(output.getName())) { canHandles.add(output); } } return canHandles; } AerialPlatformResultHandler(Toolbox toolbox, OSHImageQuerier querier); @Override List<Output> canHandle(List<Output> outputs); @Override String getQueryProperty(Offering offering, Output output); @Override void handleGroupActivation(DataTypeInfo dataType, ActivationState state); @Override void handleResults(OSHDataTypeInfo dataType, List<Output> outputs, List<CancellableInputStream> streams); @Override void initializeType(OSHDataTypeInfo dataType); @Override void notify(ActiveDataGroupsChangedEvent event); }### Answer: @Test public void testCanHandle() { EasyMockSupport support = new EasyMockSupport(); DataRegistry dataRegistry = support.createMock(DataRegistry.class); UIRegistry uiRegistry = support.createMock(UIRegistry.class); PreferencesRegistry prefsRegistry = createPrefsRegistryBasic(support); Toolbox toolbox = createToolbox(support, dataRegistry, uiRegistry, prefsRegistry); OSHImageQuerier querier = support.createMock(OSHImageQuerier.class); List<Output> validOuts = createValidOutputs(); List<Output> invalidOuts = createInvalidOutputs(); support.replayAll(); AerialPlatformResultHandler handler = new AerialPlatformResultHandler(toolbox, querier); List<Output> totalOutputs = New.list(invalidOuts); totalOutputs.addAll(validOuts); List<Output> actualOuts = handler.canHandle(totalOutputs); assertEquals(validOuts, actualOuts); actualOuts = handler.canHandle(invalidOuts); assertTrue(actualOuts.isEmpty()); support.verifyAll(); }
### Question: AerialPlatformResultHandler implements ResultHandler, EventListener<ActiveDataGroupsChangedEvent> { @Override public String getQueryProperty(Offering offering, Output output) { String filterString = "Location"; if (ourPlatformAttitudeName.equals(output.getName())) { filterString = "PlatformOrientation"; } else if (ourGimbalAttitudeName.equals(output.getName())) { filterString = "Gimbal"; } String property = null; for (String aProperty : offering.getObservableProperties()) { if (aProperty.contains(filterString)) { property = aProperty; } } return property; } AerialPlatformResultHandler(Toolbox toolbox, OSHImageQuerier querier); @Override List<Output> canHandle(List<Output> outputs); @Override String getQueryProperty(Offering offering, Output output); @Override void handleGroupActivation(DataTypeInfo dataType, ActivationState state); @Override void handleResults(OSHDataTypeInfo dataType, List<Output> outputs, List<CancellableInputStream> streams); @Override void initializeType(OSHDataTypeInfo dataType); @Override void notify(ActiveDataGroupsChangedEvent event); }### Answer: @Test public void testGetQueryProperty() { EasyMockSupport support = new EasyMockSupport(); DataRegistry dataRegistry = support.createMock(DataRegistry.class); UIRegistry uiRegistry = support.createMock(UIRegistry.class); PreferencesRegistry prefsRegistry = createPrefsRegistryBasic(support); Toolbox toolbox = createToolbox(support, dataRegistry, uiRegistry, prefsRegistry); OSHImageQuerier querier = support.createMock(OSHImageQuerier.class); List<Output> validOuts = createValidOutputs(); Offering offering = createOffering(); support.replayAll(); AerialPlatformResultHandler handler = new AerialPlatformResultHandler(toolbox, querier); assertEquals("http: handler.getQueryProperty(offering, validOuts.get(0))); assertEquals("http: handler.getQueryProperty(offering, validOuts.get(1))); assertEquals("http: handler.getQueryProperty(offering, validOuts.get(2))); support.verifyAll(); }
### Question: AerialPlatformResultHandler implements ResultHandler, EventListener<ActiveDataGroupsChangedEvent> { @Override public void handleGroupActivation(DataTypeInfo dataType, ActivationState state) { if (state != ActivationState.ACTIVE) { myToolbox.getTransformerRegistry().removeObjectsForSource(dataType); } else if (state == ActivationState.ACTIVE) { String typeKey = dataType.getTypeKey(); synchronized (myVideoLayer) { if (!myVideoLayer.containsKey(typeKey)) { myVideoLayer.put(typeKey, New.list()); } } myToolbox.getTransformerRegistry().addObjectsForSource(dataType, New.list(new AerialImageryTransformer(myToolbox, myQuerier, dataType, myVideoLayer.get(typeKey)))); } } AerialPlatformResultHandler(Toolbox toolbox, OSHImageQuerier querier); @Override List<Output> canHandle(List<Output> outputs); @Override String getQueryProperty(Offering offering, Output output); @Override void handleGroupActivation(DataTypeInfo dataType, ActivationState state); @Override void handleResults(OSHDataTypeInfo dataType, List<Output> outputs, List<CancellableInputStream> streams); @Override void initializeType(OSHDataTypeInfo dataType); @Override void notify(ActiveDataGroupsChangedEvent event); }### Answer: @Test public void testHandleGroupActivation() { EasyMockSupport support = new EasyMockSupport(); DataRegistry dataRegistry = support.createMock(DataRegistry.class); UIRegistry uiRegistry = support.createMock(UIRegistry.class); OSHImageQuerier querier = support.createMock(OSHImageQuerier.class); PreferencesRegistry prefsRegistry = createPrefsRegistryBasic(support); Toolbox toolbox = createToolbox(support, dataRegistry, uiRegistry, prefsRegistry); TimeManager timeManager = support.createMock(TimeManager.class); timeManager.addActiveTimeSpanChangeListener(EasyMock.isA(TimeRefreshNotifier.class)); EasyMock.expect(toolbox.getTimeManager()).andReturn(timeManager); OrderManagerRegistry orderRegistry = support.createMock(OrderManagerRegistry.class); EasyMock.expect(toolbox.getOrderManagerRegistry()).andReturn(orderRegistry); AnimationManager animationManager = support.createMock(AnimationManager.class); animationManager.addAnimationChangeListener(EasyMock.isA(TimeRefreshNotifier.class)); EasyMock.expect(toolbox.getAnimationManager()).andReturn(animationManager); MapManager mapManager = support.createMock(MapManager.class); EasyMock.expect(toolbox.getMapManager()).andReturn(mapManager); List<Output> validOuts = createValidOutputs(); Offering offering = createOffering(); OSHDataTypeInfo dataType = createDataType(offering, validOuts); support.replayAll(); AerialPlatformResultHandler handler = new AerialPlatformResultHandler(toolbox, querier); handler.handleGroupActivation(dataType, ActivationState.ACTIVE); assertTrue(toolbox.getTransformerRegistry().getObjectsForSource(dataType).iterator() .next() instanceof AerialImageryTransformer); handler.handleGroupActivation(dataType, ActivationState.DEACTIVATING); assertTrue(toolbox.getTransformerRegistry().getObjectsForSource(dataType).isEmpty()); support.verifyAll(); }
### Question: AerialPlatformResultHandler implements ResultHandler, EventListener<ActiveDataGroupsChangedEvent> { @Override public void handleResults(OSHDataTypeInfo dataType, List<Output> outputs, List<CancellableInputStream> streams) throws IOException { int index = 0; List<PlatformMetadata> locations = New.list(); List<PlatformMetadata> platformOrientations = New.list(); List<PlatformMetadata> gimbalOrientations = New.list(); for (CancellableInputStream stream : streams) { Output output = outputs.get(index); if (ourPlatformLocationName.equals(output.getName())) { myLocationParser.parse(output, stream, locations); } else if (ourPlatformAttitudeName.equals(output.getName())) { myPlatformOrientationParser.parse(output, stream, platformOrientations); } else if (ourGimbalAttitudeName.equals(output.getName())) { myGimbalParser.parse(output, stream, gimbalOrientations); } index++; } List<PlatformMetadata> metadatas = myCombiner.combineData(locations, platformOrientations, gimbalOrientations); index = 0; for (PlatformMetadata metadata : metadatas) { metadata.setFootprint(myFootprintCalc.calculateFootprint2(metadata, ourFOVWidth, ourFOVHeight)); index++; } depositMetadatas(dataType, metadatas); } AerialPlatformResultHandler(Toolbox toolbox, OSHImageQuerier querier); @Override List<Output> canHandle(List<Output> outputs); @Override String getQueryProperty(Offering offering, Output output); @Override void handleGroupActivation(DataTypeInfo dataType, ActivationState state); @Override void handleResults(OSHDataTypeInfo dataType, List<Output> outputs, List<CancellableInputStream> streams); @Override void initializeType(OSHDataTypeInfo dataType); @Override void notify(ActiveDataGroupsChangedEvent event); }### Answer: @Test public void testHandleResults() throws IOException { TimeZone.setDefault(TimeZone.getTimeZone("GMT")); EasyMockSupport support = new EasyMockSupport(); DataRegistry dataRegistry = createRegistry(support); UIRegistry uiRegistry = createUIRegistry(support); OSHImageQuerier querier = support.createMock(OSHImageQuerier.class); PreferencesRegistry prefsRegistry = createPrefsRegistryBasic(support); Toolbox toolbox = createToolbox(support, dataRegistry, uiRegistry, prefsRegistry); List<Output> validOuts = createValidOutputs(); Offering offering = createOffering(); OSHDataTypeInfo dataType = createDataType(offering, validOuts); List<CancellableInputStream> testData = createTestData(); support.replayAll(); AerialPlatformResultHandler handler = new AerialPlatformResultHandler(toolbox, querier); handler.handleResults(dataType, validOuts, testData); support.verifyAll(); }
### Question: LayerLinker { public String getLinkedLayerId(String layerId) { LinkedLayers linkedLayers = myPrefs.getJAXBObject(LinkedLayers.class, ourLinkedLayersKey, (LinkedLayers)null); String linkedLayerId = null; if (linkedLayers != null) { for (LinkedLayer linkedLayer : linkedLayers.getLinkedLayers()) { if (layerId.equals(linkedLayer.getLinkedLayersTypeKey())) { linkedLayerId = linkedLayer.getOtherLinkedLayersTypeKey(); break; } else if (layerId.equals(linkedLayer.getOtherLinkedLayersTypeKey())) { linkedLayerId = linkedLayer.getLinkedLayersTypeKey(); break; } } } return linkedLayerId; } LayerLinker(PreferencesRegistry prefsRegistry); String getLinkedLayerId(String layerId); }### Answer: @Test public void testGetLinkedLayer() { EasyMockSupport support = new EasyMockSupport(); LinkedLayers links = createLinks(); PreferencesRegistry prefsReg = createPrefsRegistry(support, links); support.replayAll(); LayerLinker linker = new LayerLinker(prefsReg); assertEquals(ourOtherLinkedLayerId, linker.getLinkedLayerId(ourLinkedLayerId)); support.verifyAll(); } @Test public void testGetLinkedLayerReverse() { EasyMockSupport support = new EasyMockSupport(); LinkedLayers links = createLinks(); PreferencesRegistry prefsReg = createPrefsRegistry(support, links); support.replayAll(); LayerLinker linker = new LayerLinker(prefsReg); assertEquals(ourLinkedLayerId, linker.getLinkedLayerId(ourOtherLinkedLayerId)); support.verifyAll(); } @Test public void testGetLinkedNotLinked() { EasyMockSupport support = new EasyMockSupport(); LinkedLayers links = createLinks(); PreferencesRegistry prefsReg = createPrefsRegistry(support, links); support.replayAll(); LayerLinker linker = new LayerLinker(prefsReg); assertNull(linker.getLinkedLayerId("iamunlinked")); support.verifyAll(); } @Test public void testGetLinkedNull() { EasyMockSupport support = new EasyMockSupport(); PreferencesRegistry prefsReg = createPrefsRegistry(support, null); support.replayAll(); LayerLinker linker = new LayerLinker(prefsReg); assertNull(linker.getLinkedLayerId(ourLinkedLayerId)); support.verifyAll(); }
### Question: ExceptionContentHandler extends ContentHandler { public ServiceExceptionReport getContent(InputStream stream, URL url, String contentType) { ServiceExceptionReport ser = getReport(stream, url, contentType); if (ser != null) { for (ServiceException se : ser.getServiceException()) { LOGGER.warn("Service exception received for url [" + url + "]: code [" + se.getCode() + "] value [" + se.getvalue() + "]"); } } return ser; } static String formatServiceException(ServiceExceptionReport ser, int lineLength); ServiceExceptionReport getContent(InputStream stream, URL url, String contentType); @Override ServiceExceptionReport getContent(URLConnection urlc); static final String MIME_TYPE; static final String MIME_TYPE_1_3; }### Answer: @Test public void testGetContentv1dot1() throws MalformedURLException { String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>" + "<!DOCTYPE WMT_MS_Capabilities SYSTEM \"ogc/schemas/wms/1.1.1/exception_1_1_1.dtd\">" + "<ServiceExceptionReport version=\"1.1.1\"><ServiceException>" + "The value for parameter HEIGHT \"0\" is invalid: The height must be at least 1.</ServiceException></ServiceExceptionReport>"; ByteArrayInputStream stream = new ByteArrayInputStream(xml.getBytes(StringUtilities.DEFAULT_CHARSET)); ExceptionContentHandler handler = new ExceptionContentHandler(); ServiceExceptionReport report = handler.getContent(stream, new URL("http: assertEquals(1, report.getServiceException().size()); ServiceException exception = report.getServiceException().get(0); assertEquals("The value for parameter HEIGHT \"0\" is invalid: The height must be at least 1.", exception.getvalue()); } @Test public void testGetContentv1dot3() throws MalformedURLException { String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><ogc:ServiceExceptionReport version=\"1.3.0\"" + " xsi:schemaLocation=\"http: + " xmlns:ogc=\"http: + "<ogc:ServiceException locator=\"Parameter HEIGHT\">" + "The value for parameter HEIGHT \"0\" is invalid: The height must be at least 1.</ogc:ServiceException></ogc:ServiceExceptionReport>"; ByteArrayInputStream stream = new ByteArrayInputStream(xml.getBytes(StringUtilities.DEFAULT_CHARSET)); ExceptionContentHandler handler = new ExceptionContentHandler(); ServiceExceptionReport report = handler.getContent(stream, new URL("http: ExceptionContentHandler.MIME_TYPE_1_3); assertEquals(1, report.getServiceException().size()); ServiceException exception = report.getServiceException().get(0); assertEquals("The value for parameter HEIGHT \"0\" is invalid: The height must be at least 1.", exception.getvalue()); }
### Question: WMSEnvoyHelper { public static WMSServerCapabilities requestCapabilitiesFromServer(ServerConnectionParams serverConf, Toolbox toolbox) throws IOException, GeneralSecurityException, InterruptedException, URISyntaxException { byte[] bytes; try { bytes = requestCapabilities(serverConf, toolbox, "1.3.0", false); } catch (IOException | InterruptedException e) { bytes = requestCapabilities(serverConf, toolbox, "1.1.1", true); } final InputStream stream = new ByteArrayInputStream(bytes); WMSCapabilities caps130; try { caps130 = getXmlObject(stream, WMSCapabilities.class, handler -> new NamespaceContentHandler(handler)); } catch (final IOException e) { caps130 = null; } if (caps130 != null && caps130.getCapability() != null && "1.3.0".equals(caps130.getVersion())) { return new WMS130Capabilities(caps130); } stream.reset(); final WMTMSCapabilities caps111 = getXmlObject(stream, WMTMSCapabilities.class, null); if (caps111 != null && caps111.getCapability() != null) { return new WMS111Capabilities(caps111); } return null; } private WMSEnvoyHelper(); static Image getImageFromServer(SldRegistry sldRegistry, ServerConnectionParams serverConfig, WMSLayerConfig layerConfig, TileImageKey imageKey, Toolbox toolbox, String wmsVersion); static InputStream getImageStreamFromServer(SldRegistry sldRegistry, ServerConnectionParams serverConfig, WMSLayerConfig layerConfig, TileImageKey imageKey, Toolbox toolbox, String wmsVersion); static WMSServerCapabilities requestCapabilitiesFromServer(ServerConnectionParams serverConf, Toolbox toolbox); }### Answer: @Test public void testRequestCapabilitiesFromServer() throws IOException, URISyntaxException, GeneralSecurityException, InterruptedException { EasyMockSupport support = new EasyMockSupport(); ServerConnectionParams params = createParams(support); Toolbox toolbox = createToolbox(support); support.replayAll(); WMSServerCapabilities capabilities = WMSEnvoyHelper.requestCapabilitiesFromServer(params, toolbox); assertNotNull(capabilities); assertEquals("1.1.1", capabilities.getVersion()); support.verifyAll(); }
### Question: WMSLayerProvider { public List<WMSLayer> getLayers() { DataModelCategory category = new DataModelCategory(null, WMSLayer.class.getName(), null); PropertyDescriptor<WMSLayer> property = new PropertyDescriptor<>("value", WMSLayer.class); SimpleQuery<WMSLayer> query = new SimpleQuery<>(category, property); myDataRegistry.performLocalQuery(query); return query.getResults(); } WMSLayerProvider(DataRegistry registry); List<WMSLayer> getLayers(); }### Answer: @Test public void testGetLayers() { DataRegistry dataRegistry = createDataRegistry(); EasyMock.replay(dataRegistry); WMSLayerProvider provider = new WMSLayerProvider(dataRegistry); List<WMSLayer> layers = provider.getLayers(); assertEquals(2, layers.size()); EasyMock.verify(dataRegistry); }
### Question: NodeWriter { public void writeToNode(Node node, List<WMSLayerAndState> layerStates, boolean saveDataLayers) { List<WMSLayerState> dataLayers = New.list(); List<WMSLayerState> mapLayers = New.list(); segregateLayers(layerStates, dataLayers, mapLayers); Document doc = node instanceof Document ? (Document)node : node.getOwnerDocument(); try { if (saveDataLayers) { if (!dataLayers.isEmpty()) { Element dataLayerNode = (Element)StateXML.createChildNode(node, doc, node, StateConstants.DATA_LAYERS_PATH, StateConstants.LAYERS_NAME); dataLayerNode.setAttribute("type", StateConstants.DATA_LAYERS_TYPE); addToNode(dataLayerNode, dataLayers); } } else if (!mapLayers.isEmpty()) { Element mapLayerNode = (Element)StateXML.createChildNode(node, doc, node, StateConstants.MAP_LAYERS_PATH, StateConstants.LAYERS_NAME); mapLayerNode.setAttribute("type", StateConstants.MAP_LAYERS_TYPE); addToNode(mapLayerNode, mapLayers); } } catch (XPathExpressionException e) { LOGGER.error(e.getMessage(), e); } } void writeToNode(Node node, List<WMSLayerAndState> layerStates, boolean saveDataLayers); static void segregateLayers(List<WMSLayerAndState> layerStates, List<WMSLayerState> dataLayers, List<WMSLayerState> mapLayers); }### Answer: @Test public void testWriteToNode() throws ParserConfigurationException, JAXBException, SAXException, IOException { Document doc = XMLUtilities.newDocument(); Node stateElement = doc.appendChild(StateXML.createElement(doc, ModuleStateController.STATE_NAME)); performTest(stateElement); }
### Question: NodeReader { public boolean canActivateState(Node node, boolean activateDataLayer) { boolean canActivate = false; try { String path = activateDataLayer ? StateConstants.WMS_DATA_LAYER_PATH : StateConstants.WMS_MAP_LAYERS_PATH; NodeList wmsNodes = StateXML.getChildNodes(node, path); canActivate = wmsNodes.getLength() > 0; } catch (XPathExpressionException e) { LOGGER.error(e.getMessage(), e); } return canActivate; } boolean canActivateState(Node node, boolean activateDataLayer); List<WMSLayerState> readNode(Node node, boolean activateDataLayer); }### Answer: @Test public void testCanActivate() throws XPathExpressionException, ParserConfigurationException, JAXBException { Node node = createStateNodeWithGroups(); NodeReader reader = new NodeReader(); boolean actual = reader.canActivateState(node, false); assertTrue(actual); node = createStateNodeWithoutMapGroup(); actual = reader.canActivateState(node, false); assertFalse(actual); actual = reader.canActivateState(node, true); assertTrue(actual); } @Test public void testCanActivateJustGroups() throws ParserConfigurationException { Node node = createStateNodeWithDataGroup(); NodeReader reader = new NodeReader(); boolean actual = reader.canActivateState(node, true); assertFalse(actual); } @Test public void testCanActivateJustLayers() throws ParserConfigurationException { Node node = createStateNode(); Document doc = node.getOwnerDocument(); Element layers = StateXML.createElement(doc, "layers"); node.appendChild(layers); NodeReader reader = new NodeReader(); boolean actual = reader.canActivateState(node, true); assertFalse(actual); actual = reader.canActivateState(node, false); assertFalse(actual); } @Test public void testCanActivateNothing() throws ParserConfigurationException { Node node = createStateNode(); NodeReader reader = new NodeReader(); boolean actual = reader.canActivateState(node, true); assertFalse(actual); actual = reader.canActivateState(node, false); assertFalse(actual); }
### Question: NodeReader { public List<WMSLayerState> readNode(Node node, boolean activateDataLayer) { List<WMSLayerState> layerStates = New.list(); try { NodeList children = null; String path = activateDataLayer ? StateConstants.WMS_DATA_LAYER_PATH : StateConstants.WMS_MAP_LAYERS_PATH; children = StateXML.getChildNodes(node, path); if (children != null) { for (int i = 0; i < children.getLength(); i++) { Node child = children.item(i); try { WMSLayerState layerState = XMLUtilities.readXMLObject(child, WMSLayerState.class); layerStates.add(layerState); } catch (JAXBException e) { StringBuilder sb = new StringBuilder(); sb.append("Failed to read WMS layer state for index "); sb.append(i); sb.append(", isDataLayer = "); sb.append(activateDataLayer); sb.append(e.getMessage()); LOGGER.error(sb.toString(), e); } } } } catch (XPathExpressionException e) { LOGGER.error(e.getMessage(), e); } return layerStates; } boolean canActivateState(Node node, boolean activateDataLayer); List<WMSLayerState> readNode(Node node, boolean activateDataLayer); }### Answer: @Test public void testReadNodeData() throws ParserConfigurationException, JAXBException, XPathExpressionException { Node node = createStateNodeWithGroups(); NodeReader reader = new NodeReader(); List<WMSLayerState> layerStates = reader.readNode(node, true); assertEquals(ourDataLayerName1, layerStates.get(0).getId()); assertEquals(ourDataLayerName2, layerStates.get(1).getId()); } @Test public void testReadNodeMap() throws ParserConfigurationException, JAXBException, XPathExpressionException { Node node = createStateNodeWithGroups(); NodeReader reader = new NodeReader(); List<WMSLayerState> layerStates = reader.readNode(node, false); assertEquals(ourMapLayerName1, layerStates.get(0).getId()); assertEquals(ourMapLayerName2, layerStates.get(1).getId()); } @Test public void testReadNodeNoLayerGroup() throws ParserConfigurationException, JAXBException, XPathExpressionException { Node node = createStateNodeWithoutMapGroup(); NodeReader reader = new NodeReader(); List<WMSLayerState> layerStates = reader.readNode(node, false); assertTrue(layerStates.isEmpty()); } @Test public void testReadNodeNoLayers() throws ParserConfigurationException { Node node = createStateNode(); NodeReader reader = new NodeReader(); List<WMSLayerState> layerStates = reader.readNode(node, false); assertTrue(layerStates.isEmpty()); }
### Question: EnvoyCoupler { public List<WMSEnvoyAndState> retrieveRelatedEnvoys(Collection<? extends WMSLayerState> states) { List<WMSEnvoyAndState> envoyAndStates = New.list(); Map<String, WMSEnvoy> serversAndEnvoys = mapServersAndEnvoys(); Set<String> retrievedTypes = New.set(); Set<String> notLoadedServers = New.set(); for (WMSLayerState state : states) { WMSEnvoy envoy = serversAndEnvoys.get(state.getUrl()); if (envoy != null) { String[] layerNames = state.getParameters().getLayerName().split(","); for (String layerName : layerNames) { String key = WMSLayerKey.createKey( envoy.getServerConnectionConfig().getServerId(OGCServerSource.WMS_GETMAP_SERVICE), layerName); if (!retrievedTypes.contains(key)) { DataTypeInfo existingType = myDataController.findMemberById(key); if (existingType instanceof WMSDataType) { retrievedTypes.add(key); WMSDataType existingWmsType = (WMSDataType)existingType; WMSEnvoyAndState envoyAndState = new WMSEnvoyAndState(envoy, existingWmsType, state, layerName); envoyAndStates.add(envoyAndState); } else { String message = "Unable to restore WMS layer " + state.getId() + " layer does not exist on server " + state.getUrl(); LOGGER.warn(message); Notify.warn(message); } } } } else { notLoadedServers.add(state.getUrl()); } } for (String notLoadedServer : notLoadedServers) { LOGGER.warn("Server not loaded unable to load any WMS layers for " + notLoadedServer); } return envoyAndStates; } EnvoyCoupler(Plugin wmsPlugin, GenericRegistry<Envoy> envoyRegistry, DataGroupController dataController); List<WMSEnvoyAndState> retrieveRelatedEnvoys(Collection<? extends WMSLayerState> states); }### Answer: @Test public void testRetrieveRelatedEnvoys() { Plugin wmsPlugin = createPlugin(); List<ServerConnectionParams> params = createServerConnectionParams(ourServerUrl); List<WMSEnvoyAndEnvoy> envoys = createEnvoys(params); GenericRegistry<Envoy> envoyRegistry = createEnvoyRegistry(wmsPlugin, envoys); WMSDataType dataType = createDataType(); DataGroupController dataController = createDataController(dataType); EasyMock.replay(dataType); List<WMSEnvoyAndState> envoyAndStates = performTest(params, envoys, wmsPlugin, dataController, envoyRegistry); assertEquals(1, envoyAndStates.size()); WMSEnvoyAndState envoyAndState = envoyAndStates.get(0); assertEquals(myStates.get(1), envoyAndState.getState()); assertEquals(envoys.get(1), envoyAndState.getEnvoy()); assertEquals(dataType, envoyAndState.getTypeInfo()); EasyMock.verify(dataType); }
### Question: StateDeactivator { public void deactivateState(StateGroup stateGroup) throws InterruptedException { List<DataGroupInfo> stateLayers = stateGroup.getStateLayers(); myActivator.setGroupsActive(stateLayers, false); } StateDeactivator(DataGroupActivator activator); void deactivateState(StateGroup stateGroup); }### Answer: @Test public void test() throws InterruptedException { WMSEnvoy envoy = StateUtils.createEnvoy(); DataGroupInfo parent = createParent(); DataTypeInfo dataType = createDataType(parent); WMSLayerValueProvider layer = createLayer(dataType); WMSLayerEnvoy layerEnvoy = StateUtils.createLayerEnvoy(layer); StateGroup group = createStateGroup(parent); DataGroupActivator groupActivator = createDataGroupActivator(parent); EasyMock.replay(parent, envoy, dataType, layer, layerEnvoy); StateDeactivator deactivator = new StateDeactivator(groupActivator); deactivator.deactivateState(group); EasyMock.verify(parent, envoy, dataType, layer, layerEnvoy); }
### Question: LevelRowCol { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null || getClass() != obj.getClass()) { return false; } LevelRowCol other = (LevelRowCol)obj; return myCol == other.myCol && myLevel == other.myLevel && myRow == other.myRow; } LevelRowCol(int level, int row, int col); @Override boolean equals(Object obj); int getCol(); int getLevel(); int getRow(); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testEqualsObject() { assertTrue(new LevelRowCol(4, 5, 6).equals(new LevelRowCol(4, 5, 6))); assertFalse(new LevelRowCol(4, 5, 6).equals(new LevelRowCol(3, 5, 6))); assertFalse(new LevelRowCol(4, 5, 6).equals(new LevelRowCol(4, 4, 6))); assertFalse(new LevelRowCol(4, 5, 6).equals(new LevelRowCol(4, 5, 7))); }
### Question: LevelRowCol { public int getCol() { return myCol; } LevelRowCol(int level, int row, int col); @Override boolean equals(Object obj); int getCol(); int getLevel(); int getRow(); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testGetCol() { assertEquals(COL, LRC.getCol()); }
### Question: LevelRowCol { public int getLevel() { return myLevel; } LevelRowCol(int level, int row, int col); @Override boolean equals(Object obj); int getCol(); int getLevel(); int getRow(); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testGetLevel() { assertEquals(LEVEL, LRC.getLevel()); }
### Question: LevelRowCol { public int getRow() { return myRow; } LevelRowCol(int level, int row, int col); @Override boolean equals(Object obj); int getCol(); int getLevel(); int getRow(); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testGetRow() { assertEquals(ROW, LRC.getRow()); }
### Question: LevelRowCol { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + HashCodeHelper.getHashCode(myCol); result = prime * result + HashCodeHelper.getHashCode(myLevel); result = prime * result + HashCodeHelper.getHashCode(myRow); return result; } LevelRowCol(int level, int row, int col); @Override boolean equals(Object obj); int getCol(); int getLevel(); int getRow(); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testHashCode() { assertTrue(new LevelRowCol(4, 5, 6).hashCode() == new LevelRowCol(4, 5, 6).hashCode()); assertFalse(new LevelRowCol(4, 5, 6).hashCode() == new LevelRowCol(3, 5, 6).hashCode()); assertFalse(new LevelRowCol(4, 5, 6).hashCode() == new LevelRowCol(4, 4, 6).hashCode()); assertFalse(new LevelRowCol(4, 5, 6).hashCode() == new LevelRowCol(4, 5, 7).hashCode()); }
### Question: LevelRowCol { @Override public String toString() { return "LevelRowCol [myLevel=" + myLevel + ", myRow=" + myRow + ", myCol=" + myCol + "]"; } LevelRowCol(int level, int row, int col); @Override boolean equals(Object obj); int getCol(); int getLevel(); int getRow(); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testToString() { assertFalse(LRC.toString().isEmpty()); }
### Question: WMSLayer extends AbstractModel implements ImageProvider<TileImageKey> { @Override public Image getImage(TileImageKey key) { if (myImageProvider == null) { throw new IllegalStateException("getImage called before image provider has been set."); } return myImageProvider.getImage(key); } WMSLayer(Builder builder); static List<Vector2d> createQuadSplitLayerCellDimensions(int numLevels, double levelZeroSizeD); static PropertyAccessor<WMSLayer, String> getKeyAccessor(); Collection<GeographicBoundingBox> generateFixedGrid(int level); Collection<GeographicBoundingBox> generateGrid(int level); WMSLayerConfig getConfiguration(); @Override Image getImage(TileImageKey key); ImageProvider<TileImageKey> getImageProvider(); int getMaximumDisplaySize(); int getMinimumDisplaySize(); Vector2d getMinimumGridSize(); TimeSpan getTimeSpan(); String getTitle(); WMSDataTypeInfo getTypeInfo(); Duration getValidDuration(); boolean isTimeless(); @Override String toString(); static final PropertyDescriptor<WMSLayer> PROPERTY_DESCRIPTOR; static final PropertyDescriptor<String> KEY_PROPERTY_DESCRIPTOR; }### Answer: @Test public void testGetImage() throws IOException { List<Vector2d> layerCellDimensions = new ArrayList<Vector2d>(); Vector2d twentyByTwenty = new Vector2d(20., 20.); Vector2d tenByTen = new Vector2d(10., 10.); Vector2d fiveByFive = new Vector2d(5., 5.); layerCellDimensions.add(twentyByTwenty); layerCellDimensions.add(tenByTen); layerCellDimensions.add(fiveByFive); final Image expectedImage = new DDSImage(new byte[0]); GeographicBoundingBox bbox = new GeographicBoundingBox(LatLonAlt.createFromDegrees(0., 0.), LatLonAlt.createFromDegrees(1., 1.)); TimeSpan timeSpan = TimeSpan.get(100L, 200L); final TileImageKey imageKey = new TileImageKey(bbox, timeSpan); ImageProvider<TileImageKey> imageProvider = new ImageProvider<TileImageKey>() { @Override public Image getImage(TileImageKey key) { return key.equals(imageKey) ? expectedImage : null; } }; WMSLayerConfig conf = createLayerConfig(GeographicBoundingBox.WHOLE_GLOBE); WMSDataTypeInfo info = new WMSDataTypeInfo(getToolbox(), (Preferences)null, DATA_TYPE_HOST_NAME, new WMSLayerConfigurationSet(null, conf, null), conf.getLayerKey(), conf.getLayerTitle()); WMSLayer.Builder builder = new WMSLayer.Builder(info); builder.setLayerCellDimensions(layerCellDimensions); builder.setImageProvider(imageProvider); WMSLayer wmsLayer = new WMSLayer(builder); Image image = wmsLayer.getImage(imageKey); assertEquals(expectedImage, image); } @Test(expected = IllegalStateException.class) public void testGetImageNullImageProvider() { List<Vector2d> emptyList = Collections.emptyList(); WMSLayerConfig conf = createLayerConfig(GeographicBoundingBox.WHOLE_GLOBE); WMSDataTypeInfo info = new WMSDataTypeInfo(getToolbox(), (Preferences)null, DATA_TYPE_HOST_NAME, new WMSLayerConfigurationSet(null, conf, null), conf.getLayerKey(), conf.getLayerTitle()); WMSLayer.Builder builder = new WMSLayer.Builder(info); builder.setLayerCellDimensions(emptyList); WMSLayer wmsLayer = new WMSLayer(builder); wmsLayer.getImage((TileImageKey)null); }
### Question: WMSLayer extends AbstractModel implements ImageProvider<TileImageKey> { public Vector2d getMinimumGridSize() { return myLayerCellDimensions.get(myLayerCellDimensions.size() - 1); } WMSLayer(Builder builder); static List<Vector2d> createQuadSplitLayerCellDimensions(int numLevels, double levelZeroSizeD); static PropertyAccessor<WMSLayer, String> getKeyAccessor(); Collection<GeographicBoundingBox> generateFixedGrid(int level); Collection<GeographicBoundingBox> generateGrid(int level); WMSLayerConfig getConfiguration(); @Override Image getImage(TileImageKey key); ImageProvider<TileImageKey> getImageProvider(); int getMaximumDisplaySize(); int getMinimumDisplaySize(); Vector2d getMinimumGridSize(); TimeSpan getTimeSpan(); String getTitle(); WMSDataTypeInfo getTypeInfo(); Duration getValidDuration(); boolean isTimeless(); @Override String toString(); static final PropertyDescriptor<WMSLayer> PROPERTY_DESCRIPTOR; static final PropertyDescriptor<String> KEY_PROPERTY_DESCRIPTOR; }### Answer: @Test public void testGetMinimumGridSize() { List<Vector2d> layerCellDimensions = new ArrayList<Vector2d>(); Vector2d twentyByTwenty = new Vector2d(20., 20.); Vector2d tenByTen = new Vector2d(10., 10.); Vector2d fiveByFive = new Vector2d(5., 5.); layerCellDimensions.add(twentyByTwenty); layerCellDimensions.add(tenByTen); layerCellDimensions.add(fiveByFive); WMSLayerConfig conf = createLayerConfig(GeographicBoundingBox.WHOLE_GLOBE); WMSDataTypeInfo info = new WMSDataTypeInfo(getToolbox(), (Preferences)null, DATA_TYPE_HOST_NAME, new WMSLayerConfigurationSet(null, conf, null), conf.getLayerKey(), conf.getLayerTitle()); WMSLayer.Builder builder = new WMSLayer.Builder(info); builder.setLayerCellDimensions(layerCellDimensions); WMSLayer wmsLayer = new WMSLayer(builder); Vector2d minimumGridSize = wmsLayer.getMinimumGridSize(); assertEquals(fiveByFive, minimumGridSize); layerCellDimensions.clear(); layerCellDimensions.add(fiveByFive); layerCellDimensions.add(twentyByTwenty); layerCellDimensions.add(tenByTen); wmsLayer = new WMSLayer(builder); minimumGridSize = wmsLayer.getMinimumGridSize(); assertEquals(fiveByFive, minimumGridSize); }
### Question: AnimationManagerStateController extends AbstractModuleStateController { @Override public boolean canActivateState(Node node) { try { return (Node)StateXML.newXPath().evaluate("/" + ModuleStateController.STATE_QNAME + "/:time/:animation", node, XPathConstants.NODE) != null; } catch (XPathExpressionException e) { LOGGER.error(e, e); return false; } } AnimationManagerStateController(AnimationManager animationManager, TimeManager timeManager); @Override void activateState(String id, String description, Collection<? extends String> tags, Node node); @Override void activateState(String id, String description, Collection<? extends String> tags, StateType state); @Override boolean canActivateState(Node node); @Override boolean canActivateState(StateType state); @Override boolean canSaveState(); @Override void deactivateState(String id, Node node); @Override void deactivateState(String id, StateType state); @Override boolean isSaveStateByDefault(); @Override void saveState(Node node); @Override void saveState(StateType state); }### Answer: @Test public void testCanActivateStateDefault() throws ParserConfigurationException, XPathExpressionException, AnimationPlanModificationException { Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument(); Node stateNode = doc.appendChild(StateXML.createElement(doc, ModuleStateController.STATE_NAME)); Node timeNode = stateNode.appendChild(StateXML.createElement(doc, TIME_TAG)); AnimationManager animationManager = EasyMock.createMock(AnimationManager.class); EasyMock.replay(animationManager); TimeManager timeManager = EasyMock.createMock(TimeManager.class); EasyMock.replay(timeManager); AnimationManagerStateController controller = new AnimationManagerStateController(animationManager, timeManager); Assert.assertFalse(controller.canActivateState(doc)); timeNode.appendChild(StateXML.createElement(doc, ANIMATION)); Assert.assertTrue(controller.canActivateState(doc)); }