Datasets:
Minata
/
1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files
xet
Community
1
method2testcases
stringlengths
118
6.63k
### Question: InlineExecutor implements Executor { @Override public final void execute(Runnable command) { command.run(); } @Override final void execute(Runnable command); }### Answer: @Test public void testExecute() { final Thread[] result = new Thread[1]; new InlineExecutor().execute(new Runnable() { @Override public void run() { result[0] = Thread.currentThread(); } }); Assert.assertEquals(Thread.currentThread(), result[0]); }
### Question: BackgroundController implements Observer { public BackgroundController(MapModel mapModel, BackgroundModel model) { myMapModel = mapModel; myModel = model; myTileBuilder = new TileGeometry.Builder<ScreenPosition>(); myTileBuilder.setDivider(null); myTileBuilder.setParent(null); myTileBuilder.setImageManager(new ImageManager(null, new SingletonImageProvider( "/images/BMNG_world.topo.bathy.200405.3.2048x1024.jpg", Image.CompressionType.D3DFMT_DXT1))); getBackgroundGeometries(); myMapModel.addObserver(this); } BackgroundController(MapModel mapModel, BackgroundModel model); void close(); @Override void update(Observable o, Object arg); }### Answer: @SuppressWarnings("unused") @Test public void testBackgroundController() { MapModel mapModel = new MapModel(); mapModel.setHeightWidth(150, 300); mapModel.setViewport(new ScreenBoundingBox(new ScreenPosition(0d, 0d), new ScreenPosition(300, 150))); BackgroundModel model = new BackgroundModel(); new BackgroundController(mapModel, model); assertEquals(1, model.getGeometries().size()); TileGeometry geometry = model.getGeometries().iterator().next(); Vector3d upperLeft = ((ScreenBoundingBox)geometry.getBounds()).getUpperLeft().asVector3d(); Vector3d lowerRight = ((ScreenBoundingBox)geometry.getBounds()).getLowerRight().asVector3d(); assertEquals(0, (int)upperLeft.getX()); assertEquals(0, (int)upperLeft.getY()); assertEquals(150, (int)lowerRight.getY()); assertEquals(300, (int)lowerRight.getX()); assertEquals(1d, model.getGeometryScaleFactors().get(0), 0d); SingletonImageProvider provider = new SingletonImageProvider("/images/BMNG_world.topo.bathy.200405.3.2048x1024.jpg", Image.CompressionType.D3DFMT_DXT1); byte[] expected = provider.getImage(null).getByteBuffer().array(); byte[] actual = geometry.getImageManager().getImageProvider().getImage(null).getByteBuffer().array(); assertEquals(expected.length, actual.length); for (int i = 0; i < expected.length; i++) { assertEquals(expected[i], actual[i]); } }
### Question: SharedObjectPool { public T get(T input) { myReadLock.lock(); try { WeakReference<T> ref = myPool.get(input); T poolObject = ref == null ? null : ref.get(); if (poolObject != null) { return poolObject; } } finally { myReadLock.unlock(); } myWriteLock.lock(); try { WeakReference<T> ref = myPool.get(input); T poolObject = ref == null ? null : ref.get(); if (poolObject == null) { myPool.put(input, new WeakReference<>(input)); poolObject = input; } return poolObject; } finally { myWriteLock.unlock(); } } T get(T input); void remove(T obj); void runProcedure(PoolObjectProcedure<T> procedure); int size(); @Override String toString(); }### Answer: @Test @SuppressWarnings({ "PMD.IntegerInstantiation", "deprecation" }) public void testGet() { SharedObjectPool<Integer> pool = new SharedObjectPool<>(); Integer first = new Integer(1); Integer second = new Integer(1); Integer two = new Integer(2); Assert.assertNotSame(first, second); Assert.assertSame(first, pool.get(first)); Assert.assertSame(first, pool.get(second)); Assert.assertNotSame(second, pool.get(second)); Assert.assertSame(two, pool.get(two)); first = new Integer(1); System.gc(); Assert.assertSame(first, pool.get(first)); }
### Question: SharedObjectPool { public void remove(T obj) { myWriteLock.lock(); try { myPool.remove(obj); } finally { myWriteLock.unlock(); } } T get(T input); void remove(T obj); void runProcedure(PoolObjectProcedure<T> procedure); int size(); @Override String toString(); }### Answer: @Test @SuppressWarnings({ "PMD.IntegerInstantiation", "deprecation" }) public void testRemove() { SharedObjectPool<Integer> pool = new SharedObjectPool<>(); Integer first = new Integer(1); Integer second = new Integer(1); Assert.assertNotSame(first, second); Assert.assertSame(first, pool.get(first)); Assert.assertSame(first, pool.get(second)); pool.remove(second); Assert.assertNotSame(first, pool.get(second)); Assert.assertSame(second, pool.get(second)); }
### Question: AppendFunction implements Function<String, String> { @Override public String apply(String input) { return new StringBuilder().append(input).append(myString).toString(); } AppendFunction(String string); @Override String apply(String input); }### Answer: @Test public void testApply() { Assert.assertEquals("Knock knock Who's there?", new AppendFunction("Who's there?").apply("Knock knock ")); }
### Question: ToLowerCaseFunction implements Function<String, String> { @Override public String apply(String input) { return input == null ? null : input.toLowerCase(); } @Override String apply(String input); }### Answer: @Test public void test() { Assert.assertEquals("one", new ToLowerCaseFunction().apply("one")); Assert.assertEquals("one", new ToLowerCaseFunction().apply("One")); Assert.assertEquals("one", new ToLowerCaseFunction().apply("ONE")); Assert.assertEquals("", new ToLowerCaseFunction().apply("")); Assert.assertNull(new ToLowerCaseFunction().apply(null)); }
### Question: AWTUtilities { public static String encode(Font font) { String style; if (font.isBold()) { style = font.isItalic() ? "bolditalic" : "bold"; } else { style = font.isItalic() ? "italic" : "plain"; } return String.join("-", font.getName(), style, String.valueOf(font.getSize())); } private AWTUtilities(); static int getMaxX(Rectangle rect); static int getMaxY(Rectangle rect); static int getTextXLocation(String text, int anchorX, int pad, int position, Graphics g); static double getTextWidth(String text, Graphics g); static String encode(Font font); static int getFontSize(String encodedFont); }### Answer: @Test public void testEncode() { Font font = new Font("Arial", Font.BOLD + Font.ITALIC, 14); Assert.assertEquals(font, Font.decode(AWTUtilities.encode(font))); }
### Question: TerrainUtil { public double getElevationInMeters(MapContext<DynamicViewer> mapContext, GeographicPosition position) { double elevation = 0.; Projection proj = mapContext.getRawProjection(); if (proj.getElevationManager() != null) { elevation = proj.getElevationManager().getElevationM(position, true); elevation = Math.max(0., elevation); } return elevation; } private TerrainUtil(); static TerrainUtil getInstance(); double getElevationInMeters(MapContext<DynamicViewer> mapContext, GeographicPosition position); }### Answer: @Test public void testGetElevationInMeters() { EasyMockSupport support = new EasyMockSupport(); GeographicPosition pos = new GeographicPosition(LatLonAlt.createFromDegrees(10, 9)); MapContext<DynamicViewer> mapContext = createMapContext(support, new MockedElevationManager(pos)); support.replayAll(); double elevation = TerrainUtil.getInstance().getElevationInMeters(mapContext, pos); assertEquals(1001.1, elevation, 0d); support.verifyAll(); }
### Question: TimelineUtilities { public static Calendar get0000() { Calendar c = Calendar.getInstance(); CalendarUtilities.clearFields(c, CalendarUtilities.HOUR_INDEX, CalendarUtilities.MILLISECOND_INDEX); return c; } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testGet0000() throws ParseException { Date actual = TimelineUtilities.get0000().getTime(); Date expected = getDate(new SimpleDateFormat(DateTimeFormats.DATE_FORMAT).format(new Date()) + " 00:00:00.000"); Assert.assertEquals(expected, actual); } @Test public void testGet0000Date() throws ParseException { Date input = getDate("2010-02-03 04:05:43.123"); Date actual = TimelineUtilities.get0000(input).getTime(); Date expected = getDate("2010-02-03 00:00:00.000"); Assert.assertEquals(expected, actual); }
### Question: BackgroundController implements Observer { public void close() { myMapModel.deleteObserver(this); } BackgroundController(MapModel mapModel, BackgroundModel model); void close(); @Override void update(Observable o, Object arg); }### Answer: @Test public void testClose() { MapModel mapModel = new MapModel(); mapModel.setHeightWidth(150, 300); mapModel.setViewport(new ScreenBoundingBox(new ScreenPosition(0d, 0d), new ScreenPosition(300, 150))); BackgroundModel model = new BackgroundModel(); BackgroundController controller = new BackgroundController(mapModel, model); assertEquals(1, mapModel.countObservers()); controller.close(); assertEquals(0, mapModel.countObservers()); }
### Question: TimelineUtilities { static Calendar getEndCalendar(TimeSpan span) { assert !span.isInstantaneous(); Date endDate = span.getEndDate(); return isAt0000(endDate) ? get0000(endDate) : getNext0000(endDate); } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testGetEndCalendar() throws ParseException { Date start = getDate("2010-02-03 04:05:43.123"); Date end; Date actual; end = getDate("2010-02-04 00:00:00.001"); actual = TimelineUtilities.getEndCalendar(TimeSpan.get(start, end)).getTime(); Assert.assertEquals(getDate("2010-02-05 00:00:00.000"), actual); end = getDate("2010-02-04 00:00:00.000"); actual = TimelineUtilities.getEndCalendar(TimeSpan.get(start, end)).getTime(); Assert.assertEquals(getDate("2010-02-04 00:00:00.000"), actual); }
### Question: TimelineUtilities { public static Calendar getNext0000(Date aDate) { Calendar c = CalendarUtilities.toCalendar(aDate); c.set(Calendar.HOUR_OF_DAY, 24); CalendarUtilities.clearFields(c, CalendarUtilities.MINUTE_INDEX, CalendarUtilities.MILLISECOND_INDEX); return c; } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testGetNext0000Date() throws ParseException { Assert.assertEquals(getDate("2010-02-04 00:00:00.000"), TimelineUtilities.getNext0000(getDate("2010-02-03 04:05:43.123")).getTime()); Assert.assertEquals(getDate("2010-02-04 00:00:00.000"), TimelineUtilities.getNext0000(getDate("2010-02-03 00:00:00.000")).getTime()); Assert.assertEquals(getDate("2010-02-04 00:00:00.000"), TimelineUtilities.getNext0000(getDate("2010-02-03 23:59:59.999")).getTime()); }
### Question: TimelineUtilities { public static TimeSpan getPartialWeek() { return getPrecedingWeeks(1, true); } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testGetPartialWeek() { TimeSpan thisWeek = TimelineUtilities.getPartialWeek(); Assert.assertTrue(TimelineUtilities.isAt0000(thisWeek.getStartDate())); Assert.assertTrue(thisWeek.getStart() < System.currentTimeMillis()); Assert.assertTrue(System.currentTimeMillis() - thisWeek.getStart() < Constants.MILLIS_PER_WEEK); Assert.assertTrue(TimelineUtilities.isAt0000(thisWeek.getEndDate())); Assert.assertTrue(thisWeek.getEnd() > System.currentTimeMillis()); Assert.assertTrue(System.currentTimeMillis() - thisWeek.getEnd() < Constants.MILLIS_PER_DAY); Calendar cal = Calendar.getInstance(); cal.setTime(thisWeek.getStartDate()); Assert.assertEquals(Calendar.SUNDAY, cal.get(Calendar.DAY_OF_WEEK)); }
### Question: TimelineUtilities { static Calendar getStartCalendar(TimeSpan span) { assert !span.isInstantaneous(); return get0000(span.getStartDate()); } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testGetStartCalendar() throws ParseException { Date start; Date end = getDate("2010-02-04 00:00:00.001"); Date actual; start = getDate("2010-02-03 00:00:00.000"); actual = TimelineUtilities.getStartCalendar(TimeSpan.get(start, end)).getTime(); Assert.assertEquals(getDate("2010-02-03 00:00:00.000"), actual); start = getDate("2010-02-03 23:59:59.999"); actual = TimelineUtilities.getStartCalendar(TimeSpan.get(start, end)).getTime(); Assert.assertEquals(getDate("2010-02-03 00:00:00.000"), actual); }
### Question: TimelineUtilities { public static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration) { Map<Duration, List<DateDurationKey>> toReturn = new HashMap<>(); if (duration instanceof Months) { toReturn.putAll(createMonthDateEntries(span, duration)); } else if (duration instanceof Weeks) { createWeekDateEntries(span, toReturn, duration); } else if (duration instanceof Days) { createDayDateEntries(span, toReturn); } removeDayDuplicates(toReturn); return toReturn; } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testGetTableOfLegalDates() throws ParseException { Date start = getDate("2010-02-03 00:00:00.000"); Date end = getDate("2010-03-02 00:00:00.000"); TimeSpan span = TimeSpan.get(start, end); Map<Duration, List<DateDurationKey>> map = TimelineUtilities.getTableOfLegalDates(span, Months.ONE); List<DateDurationKey> actual = map.get(Months.ONE); Assert.assertEquals(2, actual.size()); Assert.assertEquals(getDate("2010-02-01 00:00:00.000"), actual.get(0).getStartDate()); Assert.assertEquals(getDate("2010-03-01 00:00:00.000"), actual.get(0).getEndDate()); Assert.assertEquals(Months.ONE, actual.get(0).getDuration()); Assert.assertEquals(getDate("2010-03-01 00:00:00.000"), actual.get(1).getStartDate()); Assert.assertEquals(getDate("2010-04-01 00:00:00.000"), actual.get(1).getEndDate()); Assert.assertEquals(Months.ONE, actual.get(1).getDuration()); actual = map.get(Weeks.ONE); actual = map.get(Days.ONE); Assert.assertEquals(63, actual.size()); long jan31 = getDate("2010-01-31 00:00:00.000").getTime(); for (int index = 0; index < 63; ++index) { Assert.assertEquals(jan31 + index * (long)Constants.MILLIS_PER_DAY, actual.get(index).getStartDate().getTime()); Assert.assertEquals(jan31 + (index + 1) * (long)Constants.MILLIS_PER_DAY, actual.get(index).getEndDate().getTime()); Assert.assertEquals(Days.ONE, actual.get(index).getDuration()); } }
### Question: TimelineUtilities { public static TimeSpan getThisDay(Date time) { GregorianCalendar cal = new GregorianCalendar(); cal.setTime(time); GregorianCalendar spanCal = new GregorianCalendar(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH)); long start = spanCal.getTimeInMillis(); spanCal.add(Calendar.DAY_OF_MONTH, 1); long end = spanCal.getTimeInMillis(); return TimeSpan.get(start, end); } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testGetThisDay() { GregorianCalendar day = new GregorianCalendar(1972, 1, 11); GregorianCalendar nextDay = new GregorianCalendar(1972, 1, 12); GregorianCalendar testTime = new GregorianCalendar(1972, 1, 11, 10, 53, 35); TimeSpan span = TimelineUtilities.getThisDay(testTime.getTime()); Assert.assertEquals(day.getTimeInMillis(), span.getStart()); Assert.assertEquals(nextDay.getTimeInMillis(), span.getEnd()); span = TimelineUtilities.getThisDay(day.getTime()); Assert.assertEquals(day.getTimeInMillis(), span.getStart()); Assert.assertEquals(nextDay.getTimeInMillis(), span.getEnd()); }
### Question: BackgroundController implements Observer { @Override public void update(Observable o, Object arg) { if (o instanceof MapModel && (MapModel.SIZE_PROP.equals(arg) || MapModel.REGION_PROP.equals(arg))) { getBackgroundGeometries(); } } BackgroundController(MapModel mapModel, BackgroundModel model); void close(); @Override void update(Observable o, Object arg); }### Answer: @SuppressWarnings("unused") @Test public void testUpdate() { MapModel mapModel = new MapModel(); mapModel.setHeightWidth(150, 300); mapModel.setViewport(new ScreenBoundingBox(new ScreenPosition(0d, 0d), new ScreenPosition(300, 150))); BackgroundModel model = new BackgroundModel(); new BackgroundController(mapModel, model); mapModel.setViewport(new ScreenBoundingBox(new ScreenPosition(0d, 0d), new ScreenPosition(600, 300))); mapModel.setHeightWidth(300, 600); assertEquals(1, model.getGeometries().size()); TileGeometry geometry = model.getGeometries().iterator().next(); Vector3d upperLeft = ((ScreenBoundingBox)geometry.getBounds()).getUpperLeft().asVector3d(); Vector3d lowerRight = ((ScreenBoundingBox)geometry.getBounds()).getLowerRight().asVector3d(); assertEquals(0, (int)upperLeft.getX()); assertEquals(0, (int)upperLeft.getY()); assertEquals(300, (int)lowerRight.getY()); assertEquals(600, (int)lowerRight.getX()); assertEquals(1d, model.getGeometryScaleFactors().get(0), 0d); SingletonImageProvider provider = new SingletonImageProvider("/images/BMNG_world.topo.bathy.200405.3.2048x1024.jpg", Image.CompressionType.D3DFMT_DXT1); byte[] expected = provider.getImage(null).getByteBuffer().array(); byte[] actual = geometry.getImageManager().getImageProvider().getImage(null).getByteBuffer().array(); assertEquals(expected.length, actual.length); for (int i = 0; i < expected.length; i++) { assertEquals(expected[i], actual[i]); } }
### Question: TimelineUtilities { public static TimeSpan getThisMonth(Date time) { GregorianCalendar cal = new GregorianCalendar(); cal.setTime(time); GregorianCalendar spanCal = new GregorianCalendar(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), 1); long start = spanCal.getTimeInMillis(); spanCal.add(Calendar.MONTH, 1); long end = spanCal.getTimeInMillis(); return TimeSpan.get(start, end); } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testGetThisMonth() { GregorianCalendar month = new GregorianCalendar(1972, 1, 1); GregorianCalendar nextMonth = new GregorianCalendar(1972, 2, 1); GregorianCalendar testTime = new GregorianCalendar(1972, 1, 11, 10, 53, 35); TimeSpan span = TimelineUtilities.getThisMonth(testTime.getTime()); Assert.assertEquals(month.getTimeInMillis(), span.getStart()); Assert.assertEquals(nextMonth.getTimeInMillis(), span.getEnd()); span = TimelineUtilities.getThisMonth(month.getTime()); Assert.assertEquals(month.getTimeInMillis(), span.getStart()); Assert.assertEquals(nextMonth.getTimeInMillis(), span.getEnd()); }
### Question: TimelineUtilities { public static TimeSpan getThisWeek(Date time) { GregorianCalendar cal = new GregorianCalendar(); cal.setTime(time); GregorianCalendar spanCal = new GregorianCalendar(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH)); spanCal.getTimeInMillis(); spanCal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY); long start = spanCal.getTimeInMillis(); spanCal.add(Calendar.WEEK_OF_YEAR, 1); long end = spanCal.getTimeInMillis(); return TimeSpan.get(start, end); } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testGetThisWeek() { GregorianCalendar sunday = new GregorianCalendar(2014, 3, 13); GregorianCalendar nextSunday = new GregorianCalendar(2014, 3, 20); GregorianCalendar testTime = new GregorianCalendar(2014, 3, 16, 10, 53, 35); TimeSpan span = TimelineUtilities.getThisWeek(testTime.getTime()); Assert.assertEquals(sunday.getTimeInMillis(), span.getStart()); Assert.assertEquals(nextSunday.getTimeInMillis(), span.getEnd()); span = TimelineUtilities.getThisWeek(sunday.getTime()); Assert.assertEquals(sunday.getTimeInMillis(), span.getStart()); Assert.assertEquals(nextSunday.getTimeInMillis(), span.getEnd()); }
### Question: TimelineUtilities { public static TimeSpan getToday() { return TimeSpan.get(get0000().getTimeInMillis(), Days.ONE); } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testGetToday() { TimeSpan today = TimelineUtilities.getToday(); Assert.assertTrue(Days.ONE.compareTo(today.getDuration()) == 0); Assert.assertTrue(TimelineUtilities.isAt0000(today.getStartDate())); Assert.assertTrue(today.getStart() < System.currentTimeMillis()); Assert.assertTrue(TimelineUtilities.isAt0000(today.getEndDate())); Assert.assertTrue(today.getEnd() > System.currentTimeMillis()); }
### Question: TimelineUtilities { public static TimeSpan getYesterday() { return TimeSpan.get(Days.ONE, get0000().getTimeInMillis()); } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testGetYesterday() { TimeSpan yesterday = TimelineUtilities.getYesterday(); Assert.assertTrue(Days.ONE.compareTo(yesterday.getDuration()) == 0); Assert.assertTrue(TimelineUtilities.isAt0000(yesterday.getStartDate())); Assert.assertTrue(yesterday.getStart() < System.currentTimeMillis()); Assert.assertTrue(TimelineUtilities.isAt0000(yesterday.getEndDate())); Assert.assertTrue(yesterday.getEnd() < System.currentTimeMillis()); }
### Question: TimelineUtilities { public static boolean isAt0000(Date aDate) { return CalendarUtilities.isClearedFrom(CalendarUtilities.toCalendar(aDate), CalendarUtilities.HOUR_INDEX); } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testIsAt0000() throws ParseException { Assert.assertTrue(TimelineUtilities.isAt0000(getDate("2010-02-04 00:00:00.000"))); Assert.assertFalse(TimelineUtilities.isAt0000(getDate("2010-02-04 00:00:00.001"))); Assert.assertFalse(TimelineUtilities.isAt0000(getDate("2010-02-04 23:59:59.999"))); }
### Question: TimelineUtilities { public static boolean isDay(TimeSpan span) { return isAt0000(span.getStartDate()) && span.getDuration().equalsIgnoreUnits(Days.ONE); } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testIsDay() throws ParseException { Assert.assertTrue(TimelineUtilities.isDay(TimeSpanFormatterTest.span("2015-04-09 00:00:00", "2015-04-10 00:00:00"))); Assert.assertFalse(TimelineUtilities.isDay(TimeSpanFormatterTest.span("2015-04-09 01:00:00", "2015-04-10 01:00:00"))); Assert.assertFalse(TimelineUtilities.isDay(TimeSpanFormatterTest.span("2015-04-09 00:00:00", "2015-04-11 00:00:00"))); }
### Question: TimelineUtilities { public static boolean isWeek(TimeSpan span) { Calendar startCal = CalendarUtilities.toCalendar(span.getStartDate()); return startCal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY && CalendarUtilities.isClearedFrom(startCal, CalendarUtilities.HOUR_INDEX) && span.getDuration().equalsIgnoreUnits(Weeks.ONE); } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testIsWeek() throws ParseException { Assert.assertTrue(TimelineUtilities.isWeek(TimeSpanFormatterTest.span("2015-04-12 00:00:00", "2015-04-19 00:00:00"))); Assert.assertFalse(TimelineUtilities.isWeek(TimeSpanFormatterTest.span("2015-04-13 00:00:00", "2015-04-20 00:00:00"))); Assert.assertFalse(TimelineUtilities.isWeek(TimeSpanFormatterTest.span("2015-04-12 00:00:00", "2015-04-26 00:00:00"))); }
### Question: TimelineUtilities { public static boolean isMonth(TimeSpan span) { Calendar startCal = CalendarUtilities.toCalendar(span.getStartDate()); boolean isMonth = CalendarUtilities.isClearedFrom(startCal, CalendarUtilities.DAY_INDEX); if (isMonth) { startCal.add(Calendar.MONTH, 1); Calendar endCal = CalendarUtilities.toCalendar(span.getEndDate()); isMonth = startCal.equals(endCal); } return isMonth; } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testIsMonth() throws ParseException { Assert.assertTrue(TimelineUtilities.isMonth(TimeSpanFormatterTest.span("2015-04-01 00:00:00", "2015-05-01 00:00:00"))); Assert.assertFalse(TimelineUtilities.isMonth(TimeSpanFormatterTest.span("2015-04-02 00:00:00", "2015-05-02 00:00:00"))); Assert.assertFalse(TimelineUtilities.isMonth(TimeSpanFormatterTest.span("2015-04-01 00:00:00", "2015-06-01 00:00:00"))); }
### Question: BackgroundOverlay implements Observer, Overlay { @Override public void close() { myController.close(); myModel.deleteObserver(this); } BackgroundOverlay(MapModel mapModel); @Override void close(); @Override void draw(Graphics graphics); @Override void update(Observable o, Object arg); }### Answer: @Test public void testClose() { MapModel mapModel = new MapModel(); mapModel.setHeightWidth(150, 300); mapModel.setViewport(new ScreenBoundingBox(new ScreenPosition(0d, 0d), new ScreenPosition(300, 150))); BackgroundOverlay overlay = new BackgroundOverlay(mapModel); assertEquals(1, mapModel.countObservers()); overlay.close(); assertEquals(0, mapModel.countObservers()); }
### Question: TimelineUtilities { public static TimeSpan scale(TimeSpan span, double factor) { Duration delta = new Milliseconds(span.getDurationMs()).multiply(factor / 2.); TimeInstant midpoint = span.getMidpointInstant(); return TimeSpan.get(midpoint.minus(delta), midpoint.plus(delta)); } private TimelineUtilities(); static void addDuration(Calendar calendar, Duration duration); static Calendar get0000(); static Calendar get0000(Date aDate); static List<TimeSpan> getIntervalsForSpan(Date startDate, TimeSpan span, int spanType); static Calendar getNext0000(Date aDate); static TimeSpan getPartialWeek(); static TimeSpan getPrecedingMonths(Date reference, int months, boolean includeThisMonth); static TimeSpan getPrecedingMonths(int months, boolean includeThisMonth); static TimeSpan getPrecedingWeeks(Date reference, int numWeeks, boolean includeThisWeek); static TimeSpan getPrecedingWeeks(int numWeeks, boolean includeThisWeek); static Map<Duration, List<DateDurationKey>> getTableOfLegalDates(TimeSpan span, Duration duration); static TimeSpan getThisDay(Date time); static TimeSpan getThisMonth(Date time); static TimeSpan getThisWeek(Date time); static TimeSpan getToday(); static TimeSpan getYesterday(); static boolean isAt0000(Date aDate); static boolean isDayWeekMonth(TimeSpan span); static boolean isDay(TimeSpan span); static boolean isWeek(TimeSpan span); static boolean isMonth(TimeSpan span); static boolean isRounded(Date time, Duration duration); static Calendar roundDown(Date date, Duration interval); static Calendar roundUp(Date date, Duration interval); static TimeSpan scale(TimeSpan span, double factor); }### Answer: @Test public void testScale() throws ParseException { TimeSpan span = TimeSpan.get(900, 1100); Assert.assertEquals(TimeSpan.get(1000), TimelineUtilities.scale(span, 0)); Assert.assertEquals(TimeSpan.get(975, 1025), TimelineUtilities.scale(span, 0.25)); Assert.assertEquals(TimeSpan.get(900, 1100), TimelineUtilities.scale(span, 1)); Assert.assertEquals(TimeSpan.get(700, 1300), TimelineUtilities.scale(span, 3)); }
### Question: ZipInputAdapter { public abstract String getName(); ZipInputAdapter(int method); void closeInputStream(); abstract InputStream getInputStream(); abstract String getLocation(); int getMethod(); abstract String getName(); long getSize(); }### Answer: @Test public void testNonPrivateMethods() { Method[] declaredMethods = ZipInputAdapter.class.getDeclaredMethods(); for (Method method : declaredMethods) { if (!method.getName().startsWith("$") && !method.getName().startsWith("lambda$")) { assertFalse(method.getName() + " is private. No private methods are permitted.", Modifier.isPrivate(method.getModifiers())); } } }
### Question: ZipInputAdapter { public void closeInputStream() throws IOException { } ZipInputAdapter(int method); void closeInputStream(); abstract InputStream getInputStream(); abstract String getLocation(); int getMethod(); abstract String getName(); long getSize(); }### Answer: @Test public void testCloseInputStream() throws IOException { myTestObject.closeInputStream(); }
### Question: ZipInputAdapter { public int getMethod() { return myMethod; } ZipInputAdapter(int method); void closeInputStream(); abstract InputStream getInputStream(); abstract String getLocation(); int getMethod(); abstract String getName(); long getSize(); }### Answer: @Test public void testGetMethod() { assertEquals(myMethod, myTestObject.getMethod()); }
### Question: ZipInputAdapter { public long getSize() { return 0; } ZipInputAdapter(int method); void closeInputStream(); abstract InputStream getInputStream(); abstract String getLocation(); int getMethod(); abstract String getName(); long getSize(); }### Answer: @Test public void testGetSize() { assertEquals(0, myTestObject.getSize()); }
### Question: ZipByteArrayInputAdapter extends ZipInputAdapter { @Override public void closeInputStream() throws IOException { if (myBAIS != null) { myBAIS.close(); myBAIS = null; } } ZipByteArrayInputAdapter(String name, String location, byte[] byteArray, int method); @Override void closeInputStream(); @Override InputStream getInputStream(); @Override String getLocation(); @Override String getName(); }### Answer: @Test public void testCloseInputStream() throws IOException { try (InputStream in = myTestObject.getInputStream()) { myTestObject.closeInputStream(); } myTestObject.closeInputStream(); }
### Question: ZipByteArrayInputAdapter extends ZipInputAdapter { @Override public InputStream getInputStream() throws IOException { if (myBAIS == null) { myBAIS = new ByteArrayInputStream(myByteArray); } return myBAIS; } ZipByteArrayInputAdapter(String name, String location, byte[] byteArray, int method); @Override void closeInputStream(); @Override InputStream getInputStream(); @Override String getLocation(); @Override String getName(); }### Answer: @Test public void testGetInputStream() throws IOException { byte[] bytes = new byte[myByteArray.length]; int bytesRead = 0; try (InputStream in = myTestObject.getInputStream(); InputStream in2 = myTestObject.getInputStream()) { bytesRead = in.read(bytes); assertTrue(Utilities.sameInstance(in, in2)); } assertEquals(bytesRead, myByteArray.length); String expectedContent = new String(myByteArray); String actualContent = new String(bytes); assertEquals(expectedContent, actualContent); }
### Question: ZipByteArrayInputAdapter extends ZipInputAdapter { @Override public String getLocation() { return myLocation; } ZipByteArrayInputAdapter(String name, String location, byte[] byteArray, int method); @Override void closeInputStream(); @Override InputStream getInputStream(); @Override String getLocation(); @Override String getName(); }### Answer: @Test public void testGetLocation() { assertEquals(myLocation, myTestObject.getLocation()); }
### Question: ZipByteArrayInputAdapter extends ZipInputAdapter { @Override public String getName() { return myName; } ZipByteArrayInputAdapter(String name, String location, byte[] byteArray, int method); @Override void closeInputStream(); @Override InputStream getInputStream(); @Override String getLocation(); @Override String getName(); }### Answer: @Test public void testGetName() { assertEquals(myName, myTestObject.getName()); }
### Question: BackgroundOverlay implements Observer, Overlay { @Override public void draw(Graphics graphics) { int index = 0; for (TileGeometry geometry : myModel.getGeometries()) { BoundingBox<? extends Position> bounds = (BoundingBox<? extends Position>)geometry.getBounds(); Vector3d upperLeft = bounds.getUpperLeft().asVector3d(); java.awt.Image image = myImages.get(index); double scaleFactor = myModel.getGeometryScaleFactors().get(index).doubleValue(); graphics.drawImage(image, (int)(upperLeft.getX() * scaleFactor), (int)(upperLeft.getY() * scaleFactor), null); index++; } } BackgroundOverlay(MapModel mapModel); @Override void close(); @Override void draw(Graphics graphics); @Override void update(Observable o, Object arg); }### Answer: @Test public void testDraw() { MapModel mapModel = new MapModel(); mapModel.setHeightWidth(150, 300); mapModel.setViewport(new ScreenBoundingBox(new ScreenPosition(0d, 0d), new ScreenPosition(300, 150))); BackgroundOverlay overlay = new BackgroundOverlay(mapModel); GraphicsMock graphics = new GraphicsMock(); overlay.draw(graphics); List<DrawnImage> drawnImages = graphics.getDrawnImages(); assertEquals(1, drawnImages.size()); DrawnImage drawn = drawnImages.get(0); assertEquals(0, drawn.getX()); assertEquals(0, drawn.getY()); assertNotNull(drawn.getImage()); assertEquals(150, drawn.getImage().getHeight(null)); assertEquals(300, drawn.getImage().getWidth(null)); } @Test public void testDrawZoomed() { MapModel mapModel = new MapModel(); mapModel.setHeightWidth(150, 300); mapModel.setViewport(new ScreenBoundingBox(new ScreenPosition(150d, 75d), new ScreenPosition(300, 150))); BackgroundOverlay overlay = new BackgroundOverlay(mapModel); GraphicsMock graphics = new GraphicsMock(); overlay.draw(graphics); List<DrawnImage> drawnImages = graphics.getDrawnImages(); assertEquals(1, drawnImages.size()); DrawnImage drawn = drawnImages.get(0); assertEquals(-300, drawn.getX()); assertEquals(-150, drawn.getY()); assertNotNull(drawn.getImage()); assertEquals(300, drawn.getImage().getHeight(null)); assertEquals(600, drawn.getImage().getWidth(null)); }
### Question: ZipByteArrayInputAdapter extends ZipInputAdapter { public ZipByteArrayInputAdapter(String name, String location, byte[] byteArray, int method) { super(method); myName = name; myLocation = location; myByteArray = Arrays.copyOf(byteArray, byteArray.length); } ZipByteArrayInputAdapter(String name, String location, byte[] byteArray, int method); @Override void closeInputStream(); @Override InputStream getInputStream(); @Override String getLocation(); @Override String getName(); }### Answer: @Test public void testZipByteArrayInputAdapter() { assertNotNull(myTestObject); assertEquals(myName, myTestObject.getName()); assertEquals(myMethod, myTestObject.getMethod()); assertEquals(myLocation, myTestObject.getLocation()); }
### Question: ChainFunction implements Function<T, T> { @Override public T apply(T input) { T result = input; for (Function<? super T, ? extends T> f : myFunctions) { result = f.apply(result); } return result; } ChainFunction(Collection<? extends Function<? super T, ? extends T>> functions); ChainFunction(Function<? super T, ? extends T> arg1, Function<? super T, ? extends T> arg2); @Override T apply(T input); }### Answer: @Test public void test() { Function<? super Integer, ? extends Integer> plusFive = new Function<Integer, Integer>() { @Override public Integer apply(Integer t) { return Integer.valueOf(t.intValue() + 5); } }; Function<? super Integer, ? extends Integer> timesThree = new Function<Integer, Integer>() { @Override public Integer apply(Integer t) { return Integer.valueOf(t.intValue() * 3); } }; Assert.assertEquals(Integer.valueOf(36), new ChainFunction<Integer>(plusFive, timesThree).apply(Integer.valueOf(7))); Assert.assertEquals(Integer.valueOf(26), new ChainFunction<Integer>(timesThree, plusFive).apply(Integer.valueOf(7))); Assert.assertEquals(Integer.valueOf(31), new ChainFunction<Integer>( Arrays.<Function<? super Integer, ? extends Integer>>asList(timesThree, plusFive, plusFive)) .apply(Integer.valueOf(7))); }
### Question: RollupValidator extends DefaultValidatorSupport { public void addChildValidator(ValidatorSupport childValidatorSupport) { synchronized (myChildren) { myChildren.add(childValidatorSupport); childValidatorSupport.addAndNotifyValidationListener(myListener); } } RollupValidator(Object validationObject); void addChildValidator(ValidatorSupport childValidatorSupport); void removeChildValidator(ValidatorSupport childValidatorSupport); void clear(); }### Answer: @Test public void test() { EasyMockSupport em = new EasyMockSupport(); Object obj = new Object(); RollupValidator val = new RollupValidator(obj); ValidatorSupport child1 = em.createMock(ValidatorSupport.class); ValidatorSupport child2 = em.createMock(ValidatorSupport.class); ValidatorSupport child3 = em.createMock(ValidatorSupport.class); Capture<ValidationStatusChangeListener> listenerCapture = EasyMock.newCapture(); child1.addAndNotifyValidationListener(EasyMock.capture(listenerCapture)); child2.addAndNotifyValidationListener(EasyMockHelper.eq(listenerCapture)); child3.addAndNotifyValidationListener(EasyMockHelper.eq(listenerCapture)); ValidationStatusChangeListener listener = em.createMock(ValidationStatusChangeListener.class); listener.statusChanged(obj, ValidationStatus.VALID, null); em.replayAll(); val.addChildValidator(child1); val.addChildValidator(child2); val.addChildValidator(child3); val.addAndNotifyValidationListener(listener); em.verifyAll(); em.resetAll(); Object obj1 = new Object(); String message1 = "message1"; EasyMock.expect(child1.getValidationStatus()).andReturn(ValidationStatus.ERROR).times(2); EasyMock.expect(child1.getValidationMessage()).andReturn(message1); listener.statusChanged(obj, ValidationStatus.ERROR, message1); em.replayAll(); listenerCapture.getValue().statusChanged(obj1, ValidationStatus.ERROR, message1); Assert.assertEquals(ValidationStatus.ERROR, val.getValidationStatus()); Assert.assertEquals(message1, val.getValidationMessage()); em.verifyAll(); em.resetAll(); String message2 = "message2"; EasyMock.expect(child1.getValidationStatus()).andReturn(ValidationStatus.VALID); EasyMock.expect(child2.getValidationStatus()).andReturn(ValidationStatus.ERROR).times(2); EasyMock.expect(child2.getValidationMessage()).andReturn(message2); listener.statusChanged(obj, ValidationStatus.ERROR, message2); em.replayAll(); listenerCapture.getValue().statusChanged(null, ValidationStatus.ERROR, message2); Assert.assertEquals(ValidationStatus.ERROR, val.getValidationStatus()); Assert.assertEquals(message2, val.getValidationMessage()); em.verifyAll(); em.resetAll(); EasyMock.expect(child1.getValidationStatus()).andReturn(ValidationStatus.VALID); EasyMock.expect(child2.getValidationStatus()).andReturn(ValidationStatus.VALID); EasyMock.expect(child3.getValidationStatus()).andReturn(ValidationStatus.VALID); listener.statusChanged(obj, ValidationStatus.VALID, null); em.replayAll(); listenerCapture.getValue().statusChanged(null, ValidationStatus.VALID, null); Assert.assertEquals(ValidationStatus.VALID, val.getValidationStatus()); Assert.assertNull(val.getValidationMessage()); em.verifyAll(); }
### Question: Utilities { public static <T> T checkNull(T parameter, String name) throws IllegalArgumentException { if (parameter == null) { throw new IllegalArgumentException("Parameter [" + name + "] cannot be null."); } return parameter; } private Utilities(); static boolean booleanValue(@Nullable Boolean value); static T checkNull(T parameter, String name); static boolean[] clone(boolean[] obj); static byte[] clone(byte[] obj); static char[] clone(char[] obj); static Date clone(Date date); static double[] clone(double[] obj); static float[] clone(float[] obj); static int[] clone(int[] obj); static long[] clone(long[] obj); static Object[] clone(Object[] obj); static void close(AutoCloseable... closeables); static void closeQuietly(AutoCloseable... closeables); static T getNonNull(T o1, T o2, BinaryOperator<T> resolver); static byte[] concatenate(byte[] arr1, byte[] arr2); static int[] concatenate(int[] arr1, int[] arr2); static long[] concatenate(long[] arr1, long[] arr2); static boolean equalsOrBothNaN(double val1, double val2); static ByteArrayOutputStream getByteArrayOutputStream(); static T getValue(T value, T defaultValue); static void ifNotNull(T obj, Consumer<? super T> consumer); static int indexOf(char[] arr, char element); static boolean isSequential(int[] ints); static boolean isSequential(long[] longs); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean notSameInstance(Object obj1, Object obj2); static double parseDouble(String value, double defaultValue); static float parseFloat(String value, float defaultValue); static int parseInt(String value, int defaultValue); static long parseLong(String value, long defaultValue); static double parseSystemProperty(String propName, double defValue); static float parseSystemProperty(String propName, float defValue); static int parseSystemProperty(String propName, int defValue); static long parseSystemProperty(String propName, long defValue); static Class<?> primitiveTypeFor(Class<?> wrapper); static T[] removeFromArray(T[] arr, Object obj); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean sameInstance(Object obj1, Object obj2); static int sizeOfArrayListBytes(int arrayLength); static int sizeOfEnumMapBytes(Class<K> type); static int sizeOfLinkedListBytes(int size); static double sumDouble(Collection<? extends Number> collection); static float sumFloat(Collection<? extends Number> collection); static int sumInt(Collection<? extends Number> collection); static long sumLong(Collection<? extends Number> collection); static boolean sumOverflow(long a, long b); static int sumRoundInt(Collection<? extends Number> collection); static long sumRoundLong(Collection<? extends Number> collection); static void times(int times, Runnable r); static int[] unique(int[] arr); static int[] uniqueUnsorted(int[] arr); @SuppressFBWarnings("WA_NOT_IN_LOOP") static boolean wait(Object obj); }### Answer: @Test public void testCheckNull() { try { Utilities.checkNull(new Object(), "param"); } catch (IllegalArgumentException e) { Assert.fail("Should not have thrown illegal argument exception for non-null argument."); } try { Utilities.checkNull(null, null); Assert.fail("Should have thrown illegal argument exception for null argument."); } catch (IllegalArgumentException e) { Assert.assertTrue(true); } }
### Question: Utilities { public static boolean[] clone(boolean[] obj) { return obj == null ? null : obj.clone(); } private Utilities(); static boolean booleanValue(@Nullable Boolean value); static T checkNull(T parameter, String name); static boolean[] clone(boolean[] obj); static byte[] clone(byte[] obj); static char[] clone(char[] obj); static Date clone(Date date); static double[] clone(double[] obj); static float[] clone(float[] obj); static int[] clone(int[] obj); static long[] clone(long[] obj); static Object[] clone(Object[] obj); static void close(AutoCloseable... closeables); static void closeQuietly(AutoCloseable... closeables); static T getNonNull(T o1, T o2, BinaryOperator<T> resolver); static byte[] concatenate(byte[] arr1, byte[] arr2); static int[] concatenate(int[] arr1, int[] arr2); static long[] concatenate(long[] arr1, long[] arr2); static boolean equalsOrBothNaN(double val1, double val2); static ByteArrayOutputStream getByteArrayOutputStream(); static T getValue(T value, T defaultValue); static void ifNotNull(T obj, Consumer<? super T> consumer); static int indexOf(char[] arr, char element); static boolean isSequential(int[] ints); static boolean isSequential(long[] longs); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean notSameInstance(Object obj1, Object obj2); static double parseDouble(String value, double defaultValue); static float parseFloat(String value, float defaultValue); static int parseInt(String value, int defaultValue); static long parseLong(String value, long defaultValue); static double parseSystemProperty(String propName, double defValue); static float parseSystemProperty(String propName, float defValue); static int parseSystemProperty(String propName, int defValue); static long parseSystemProperty(String propName, long defValue); static Class<?> primitiveTypeFor(Class<?> wrapper); static T[] removeFromArray(T[] arr, Object obj); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean sameInstance(Object obj1, Object obj2); static int sizeOfArrayListBytes(int arrayLength); static int sizeOfEnumMapBytes(Class<K> type); static int sizeOfLinkedListBytes(int size); static double sumDouble(Collection<? extends Number> collection); static float sumFloat(Collection<? extends Number> collection); static int sumInt(Collection<? extends Number> collection); static long sumLong(Collection<? extends Number> collection); static boolean sumOverflow(long a, long b); static int sumRoundInt(Collection<? extends Number> collection); static long sumRoundLong(Collection<? extends Number> collection); static void times(int times, Runnable r); static int[] unique(int[] arr); static int[] uniqueUnsorted(int[] arr); @SuppressFBWarnings("WA_NOT_IN_LOOP") static boolean wait(Object obj); }### Answer: @Test public void testCloneDate() { Assert.assertNull(Utilities.clone((Date)null)); Date date = new Date(); Date clone = Utilities.clone(date); Assert.assertNotSame(clone, date); Assert.assertEquals(clone, date); }
### Question: Utilities { public static <T> T getNonNull(T o1, T o2, BinaryOperator<T> resolver) { T result = null; if (o1 != null && o2 != null) { result = resolver.apply(o1, o2); } else if (o1 != null) { result = o1; } else { result = o2; } return result; } private Utilities(); static boolean booleanValue(@Nullable Boolean value); static T checkNull(T parameter, String name); static boolean[] clone(boolean[] obj); static byte[] clone(byte[] obj); static char[] clone(char[] obj); static Date clone(Date date); static double[] clone(double[] obj); static float[] clone(float[] obj); static int[] clone(int[] obj); static long[] clone(long[] obj); static Object[] clone(Object[] obj); static void close(AutoCloseable... closeables); static void closeQuietly(AutoCloseable... closeables); static T getNonNull(T o1, T o2, BinaryOperator<T> resolver); static byte[] concatenate(byte[] arr1, byte[] arr2); static int[] concatenate(int[] arr1, int[] arr2); static long[] concatenate(long[] arr1, long[] arr2); static boolean equalsOrBothNaN(double val1, double val2); static ByteArrayOutputStream getByteArrayOutputStream(); static T getValue(T value, T defaultValue); static void ifNotNull(T obj, Consumer<? super T> consumer); static int indexOf(char[] arr, char element); static boolean isSequential(int[] ints); static boolean isSequential(long[] longs); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean notSameInstance(Object obj1, Object obj2); static double parseDouble(String value, double defaultValue); static float parseFloat(String value, float defaultValue); static int parseInt(String value, int defaultValue); static long parseLong(String value, long defaultValue); static double parseSystemProperty(String propName, double defValue); static float parseSystemProperty(String propName, float defValue); static int parseSystemProperty(String propName, int defValue); static long parseSystemProperty(String propName, long defValue); static Class<?> primitiveTypeFor(Class<?> wrapper); static T[] removeFromArray(T[] arr, Object obj); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean sameInstance(Object obj1, Object obj2); static int sizeOfArrayListBytes(int arrayLength); static int sizeOfEnumMapBytes(Class<K> type); static int sizeOfLinkedListBytes(int size); static double sumDouble(Collection<? extends Number> collection); static float sumFloat(Collection<? extends Number> collection); static int sumInt(Collection<? extends Number> collection); static long sumLong(Collection<? extends Number> collection); static boolean sumOverflow(long a, long b); static int sumRoundInt(Collection<? extends Number> collection); static long sumRoundLong(Collection<? extends Number> collection); static void times(int times, Runnable r); static int[] unique(int[] arr); static int[] uniqueUnsorted(int[] arr); @SuppressFBWarnings("WA_NOT_IN_LOOP") static boolean wait(Object obj); }### Answer: @Test public void testGetNonNull() { Assert.assertEquals("a", Utilities.getNonNull("a", null, null)); Assert.assertEquals("b", Utilities.getNonNull(null, "b", null)); Assert.assertEquals("ab", Utilities.getNonNull("a", "b", (o1, o2) -> o1 + o2)); Assert.assertArrayEquals((Object[])null, Utilities.getNonNull(null, null, null)); }
### Question: Utilities { public static int indexOf(char[] arr, char element) { for (int index = 0; index < arr.length; ++index) { if (arr[index] == element) { return index; } } return -1; } private Utilities(); static boolean booleanValue(@Nullable Boolean value); static T checkNull(T parameter, String name); static boolean[] clone(boolean[] obj); static byte[] clone(byte[] obj); static char[] clone(char[] obj); static Date clone(Date date); static double[] clone(double[] obj); static float[] clone(float[] obj); static int[] clone(int[] obj); static long[] clone(long[] obj); static Object[] clone(Object[] obj); static void close(AutoCloseable... closeables); static void closeQuietly(AutoCloseable... closeables); static T getNonNull(T o1, T o2, BinaryOperator<T> resolver); static byte[] concatenate(byte[] arr1, byte[] arr2); static int[] concatenate(int[] arr1, int[] arr2); static long[] concatenate(long[] arr1, long[] arr2); static boolean equalsOrBothNaN(double val1, double val2); static ByteArrayOutputStream getByteArrayOutputStream(); static T getValue(T value, T defaultValue); static void ifNotNull(T obj, Consumer<? super T> consumer); static int indexOf(char[] arr, char element); static boolean isSequential(int[] ints); static boolean isSequential(long[] longs); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean notSameInstance(Object obj1, Object obj2); static double parseDouble(String value, double defaultValue); static float parseFloat(String value, float defaultValue); static int parseInt(String value, int defaultValue); static long parseLong(String value, long defaultValue); static double parseSystemProperty(String propName, double defValue); static float parseSystemProperty(String propName, float defValue); static int parseSystemProperty(String propName, int defValue); static long parseSystemProperty(String propName, long defValue); static Class<?> primitiveTypeFor(Class<?> wrapper); static T[] removeFromArray(T[] arr, Object obj); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean sameInstance(Object obj1, Object obj2); static int sizeOfArrayListBytes(int arrayLength); static int sizeOfEnumMapBytes(Class<K> type); static int sizeOfLinkedListBytes(int size); static double sumDouble(Collection<? extends Number> collection); static float sumFloat(Collection<? extends Number> collection); static int sumInt(Collection<? extends Number> collection); static long sumLong(Collection<? extends Number> collection); static boolean sumOverflow(long a, long b); static int sumRoundInt(Collection<? extends Number> collection); static long sumRoundLong(Collection<? extends Number> collection); static void times(int times, Runnable r); static int[] unique(int[] arr); static int[] uniqueUnsorted(int[] arr); @SuppressFBWarnings("WA_NOT_IN_LOOP") static boolean wait(Object obj); }### Answer: @Test public void testIndexOf() { Assert.assertEquals(-1, Utilities.indexOf(new char[] {}, 'a')); Assert.assertEquals(0, Utilities.indexOf(new char[] { 'a', 'a' }, 'a')); Assert.assertEquals(0, Utilities.indexOf(new char[] { 'a', 'b' }, 'a')); Assert.assertEquals(1, Utilities.indexOf(new char[] { 'a', 'b' }, 'b')); Assert.assertEquals(-1, Utilities.indexOf(new char[] { 'a', 'b' }, 'c')); }
### Question: ElementData { public VisualizationState getVisualizationState() { return myVisualizationState; } ElementData(); ElementData(Long id, TimeSpan ts, VisualizationState vs, MetaDataProvider mdp, MapGeometrySupport mgs); boolean found(); Long getID(); MapGeometrySupport getMapGeometrySupport(); MetaDataProvider getMetaDataProvider(); TimeSpan getTimeSpan(); VisualizationState getVisualizationState(); final void updateValues(Long id, TimeSpan ts, VisualizationState vs, MetaDataProvider mdp, MapGeometrySupport mgs); }### Answer: @Test public void testGetVisualizationState() { assertEquals(myVisualizationState, myTestObject.getVisualizationState()); }
### Question: Utilities { public static double sumDouble(Collection<? extends Number> collection) { double total = 0.; for (Number number : collection) { total += number.doubleValue(); } return total; } private Utilities(); static boolean booleanValue(@Nullable Boolean value); static T checkNull(T parameter, String name); static boolean[] clone(boolean[] obj); static byte[] clone(byte[] obj); static char[] clone(char[] obj); static Date clone(Date date); static double[] clone(double[] obj); static float[] clone(float[] obj); static int[] clone(int[] obj); static long[] clone(long[] obj); static Object[] clone(Object[] obj); static void close(AutoCloseable... closeables); static void closeQuietly(AutoCloseable... closeables); static T getNonNull(T o1, T o2, BinaryOperator<T> resolver); static byte[] concatenate(byte[] arr1, byte[] arr2); static int[] concatenate(int[] arr1, int[] arr2); static long[] concatenate(long[] arr1, long[] arr2); static boolean equalsOrBothNaN(double val1, double val2); static ByteArrayOutputStream getByteArrayOutputStream(); static T getValue(T value, T defaultValue); static void ifNotNull(T obj, Consumer<? super T> consumer); static int indexOf(char[] arr, char element); static boolean isSequential(int[] ints); static boolean isSequential(long[] longs); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean notSameInstance(Object obj1, Object obj2); static double parseDouble(String value, double defaultValue); static float parseFloat(String value, float defaultValue); static int parseInt(String value, int defaultValue); static long parseLong(String value, long defaultValue); static double parseSystemProperty(String propName, double defValue); static float parseSystemProperty(String propName, float defValue); static int parseSystemProperty(String propName, int defValue); static long parseSystemProperty(String propName, long defValue); static Class<?> primitiveTypeFor(Class<?> wrapper); static T[] removeFromArray(T[] arr, Object obj); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean sameInstance(Object obj1, Object obj2); static int sizeOfArrayListBytes(int arrayLength); static int sizeOfEnumMapBytes(Class<K> type); static int sizeOfLinkedListBytes(int size); static double sumDouble(Collection<? extends Number> collection); static float sumFloat(Collection<? extends Number> collection); static int sumInt(Collection<? extends Number> collection); static long sumLong(Collection<? extends Number> collection); static boolean sumOverflow(long a, long b); static int sumRoundInt(Collection<? extends Number> collection); static long sumRoundLong(Collection<? extends Number> collection); static void times(int times, Runnable r); static int[] unique(int[] arr); static int[] uniqueUnsorted(int[] arr); @SuppressFBWarnings("WA_NOT_IN_LOOP") static boolean wait(Object obj); }### Answer: @Test public void testSumDouble() { Assert.assertEquals(1138. + Integer.MAX_VALUE, Utilities.sumDouble(Arrays.asList(Integer.valueOf(7), Integer.valueOf(-1), Integer.valueOf(1142), Integer.valueOf(-10), Integer.valueOf(Integer.MAX_VALUE))), 0.); Assert.assertEquals(1138. + Float.MAX_VALUE, Utilities.sumDouble(Arrays.asList(Float.valueOf(7.1f), Float.valueOf(-1.4f), Float.valueOf(1142.9f), Float.valueOf(-10.1f), Float.valueOf(Float.MAX_VALUE))), 0.); Assert.assertEquals(1138. + Float.MAX_VALUE, Utilities.sumDouble(Arrays.asList(Double.valueOf(7.1), Double.valueOf(-1.4), Double.valueOf(1142.9), Double.valueOf(-10.1), Double.valueOf(Float.MAX_VALUE))), 0.); Assert.assertEquals(1138. + Integer.MAX_VALUE, Utilities.sumDouble(Arrays.asList(Long.valueOf(7), Long.valueOf(-1), Long.valueOf(1142), Long.valueOf(-10), Long.valueOf(Integer.MAX_VALUE))), 0.); }
### Question: Utilities { public static float sumFloat(Collection<? extends Number> collection) { float total = 0f; for (Number number : collection) { total += number.floatValue(); } return total; } private Utilities(); static boolean booleanValue(@Nullable Boolean value); static T checkNull(T parameter, String name); static boolean[] clone(boolean[] obj); static byte[] clone(byte[] obj); static char[] clone(char[] obj); static Date clone(Date date); static double[] clone(double[] obj); static float[] clone(float[] obj); static int[] clone(int[] obj); static long[] clone(long[] obj); static Object[] clone(Object[] obj); static void close(AutoCloseable... closeables); static void closeQuietly(AutoCloseable... closeables); static T getNonNull(T o1, T o2, BinaryOperator<T> resolver); static byte[] concatenate(byte[] arr1, byte[] arr2); static int[] concatenate(int[] arr1, int[] arr2); static long[] concatenate(long[] arr1, long[] arr2); static boolean equalsOrBothNaN(double val1, double val2); static ByteArrayOutputStream getByteArrayOutputStream(); static T getValue(T value, T defaultValue); static void ifNotNull(T obj, Consumer<? super T> consumer); static int indexOf(char[] arr, char element); static boolean isSequential(int[] ints); static boolean isSequential(long[] longs); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean notSameInstance(Object obj1, Object obj2); static double parseDouble(String value, double defaultValue); static float parseFloat(String value, float defaultValue); static int parseInt(String value, int defaultValue); static long parseLong(String value, long defaultValue); static double parseSystemProperty(String propName, double defValue); static float parseSystemProperty(String propName, float defValue); static int parseSystemProperty(String propName, int defValue); static long parseSystemProperty(String propName, long defValue); static Class<?> primitiveTypeFor(Class<?> wrapper); static T[] removeFromArray(T[] arr, Object obj); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean sameInstance(Object obj1, Object obj2); static int sizeOfArrayListBytes(int arrayLength); static int sizeOfEnumMapBytes(Class<K> type); static int sizeOfLinkedListBytes(int size); static double sumDouble(Collection<? extends Number> collection); static float sumFloat(Collection<? extends Number> collection); static int sumInt(Collection<? extends Number> collection); static long sumLong(Collection<? extends Number> collection); static boolean sumOverflow(long a, long b); static int sumRoundInt(Collection<? extends Number> collection); static long sumRoundLong(Collection<? extends Number> collection); static void times(int times, Runnable r); static int[] unique(int[] arr); static int[] uniqueUnsorted(int[] arr); @SuppressFBWarnings("WA_NOT_IN_LOOP") static boolean wait(Object obj); }### Answer: @Test public void testSumFloat() { Assert.assertEquals(1138f, Utilities.sumFloat( Arrays.asList(Integer.valueOf(7), Integer.valueOf(-1), Integer.valueOf(1142), Integer.valueOf(-10))), 0.); Assert.assertEquals(1138.5f, Utilities.sumFloat( Arrays.asList(Float.valueOf(7.1f), Float.valueOf(-1.4f), Float.valueOf(1142.9f), Float.valueOf(-10.1f))), 0.); Assert.assertEquals(1138.5f, Utilities.sumFloat( Arrays.asList(Double.valueOf(7.1), Double.valueOf(-1.4), Double.valueOf(1142.9), Double.valueOf(-10.1))), 0.); Assert.assertEquals(1138f, Utilities.sumFloat(Arrays.asList(Long.valueOf(7), Long.valueOf(-1), Long.valueOf(1142), Long.valueOf(-10))), 0.); }
### Question: Utilities { public static int sumInt(Collection<? extends Number> collection) { int total = 0; for (Number number : collection) { total += number.intValue(); } return total; } private Utilities(); static boolean booleanValue(@Nullable Boolean value); static T checkNull(T parameter, String name); static boolean[] clone(boolean[] obj); static byte[] clone(byte[] obj); static char[] clone(char[] obj); static Date clone(Date date); static double[] clone(double[] obj); static float[] clone(float[] obj); static int[] clone(int[] obj); static long[] clone(long[] obj); static Object[] clone(Object[] obj); static void close(AutoCloseable... closeables); static void closeQuietly(AutoCloseable... closeables); static T getNonNull(T o1, T o2, BinaryOperator<T> resolver); static byte[] concatenate(byte[] arr1, byte[] arr2); static int[] concatenate(int[] arr1, int[] arr2); static long[] concatenate(long[] arr1, long[] arr2); static boolean equalsOrBothNaN(double val1, double val2); static ByteArrayOutputStream getByteArrayOutputStream(); static T getValue(T value, T defaultValue); static void ifNotNull(T obj, Consumer<? super T> consumer); static int indexOf(char[] arr, char element); static boolean isSequential(int[] ints); static boolean isSequential(long[] longs); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean notSameInstance(Object obj1, Object obj2); static double parseDouble(String value, double defaultValue); static float parseFloat(String value, float defaultValue); static int parseInt(String value, int defaultValue); static long parseLong(String value, long defaultValue); static double parseSystemProperty(String propName, double defValue); static float parseSystemProperty(String propName, float defValue); static int parseSystemProperty(String propName, int defValue); static long parseSystemProperty(String propName, long defValue); static Class<?> primitiveTypeFor(Class<?> wrapper); static T[] removeFromArray(T[] arr, Object obj); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean sameInstance(Object obj1, Object obj2); static int sizeOfArrayListBytes(int arrayLength); static int sizeOfEnumMapBytes(Class<K> type); static int sizeOfLinkedListBytes(int size); static double sumDouble(Collection<? extends Number> collection); static float sumFloat(Collection<? extends Number> collection); static int sumInt(Collection<? extends Number> collection); static long sumLong(Collection<? extends Number> collection); static boolean sumOverflow(long a, long b); static int sumRoundInt(Collection<? extends Number> collection); static long sumRoundLong(Collection<? extends Number> collection); static void times(int times, Runnable r); static int[] unique(int[] arr); static int[] uniqueUnsorted(int[] arr); @SuppressFBWarnings("WA_NOT_IN_LOOP") static boolean wait(Object obj); }### Answer: @Test public void testSumInt() { Assert.assertEquals(1138, Utilities .sumInt(Arrays.asList(Integer.valueOf(7), Integer.valueOf(-1), Integer.valueOf(1142), Integer.valueOf(-10)))); Assert.assertEquals(1138, Utilities .sumInt(Arrays.asList(Float.valueOf(7.1f), Float.valueOf(-1.4f), Float.valueOf(1142.9f), Float.valueOf(-10.1f)))); Assert.assertEquals(1138, Utilities .sumInt(Arrays.asList(Double.valueOf(7.1), Double.valueOf(-1.4), Double.valueOf(1142.9), Double.valueOf(-10.1)))); Assert.assertEquals(1138, Utilities.sumInt(Arrays.asList(Long.valueOf(7), Long.valueOf(-1), Long.valueOf(1142), Long.valueOf(-10)))); }
### Question: Utilities { public static long sumLong(Collection<? extends Number> collection) { long total = 0L; for (Number number : collection) { total += number.longValue(); } return total; } private Utilities(); static boolean booleanValue(@Nullable Boolean value); static T checkNull(T parameter, String name); static boolean[] clone(boolean[] obj); static byte[] clone(byte[] obj); static char[] clone(char[] obj); static Date clone(Date date); static double[] clone(double[] obj); static float[] clone(float[] obj); static int[] clone(int[] obj); static long[] clone(long[] obj); static Object[] clone(Object[] obj); static void close(AutoCloseable... closeables); static void closeQuietly(AutoCloseable... closeables); static T getNonNull(T o1, T o2, BinaryOperator<T> resolver); static byte[] concatenate(byte[] arr1, byte[] arr2); static int[] concatenate(int[] arr1, int[] arr2); static long[] concatenate(long[] arr1, long[] arr2); static boolean equalsOrBothNaN(double val1, double val2); static ByteArrayOutputStream getByteArrayOutputStream(); static T getValue(T value, T defaultValue); static void ifNotNull(T obj, Consumer<? super T> consumer); static int indexOf(char[] arr, char element); static boolean isSequential(int[] ints); static boolean isSequential(long[] longs); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean notSameInstance(Object obj1, Object obj2); static double parseDouble(String value, double defaultValue); static float parseFloat(String value, float defaultValue); static int parseInt(String value, int defaultValue); static long parseLong(String value, long defaultValue); static double parseSystemProperty(String propName, double defValue); static float parseSystemProperty(String propName, float defValue); static int parseSystemProperty(String propName, int defValue); static long parseSystemProperty(String propName, long defValue); static Class<?> primitiveTypeFor(Class<?> wrapper); static T[] removeFromArray(T[] arr, Object obj); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean sameInstance(Object obj1, Object obj2); static int sizeOfArrayListBytes(int arrayLength); static int sizeOfEnumMapBytes(Class<K> type); static int sizeOfLinkedListBytes(int size); static double sumDouble(Collection<? extends Number> collection); static float sumFloat(Collection<? extends Number> collection); static int sumInt(Collection<? extends Number> collection); static long sumLong(Collection<? extends Number> collection); static boolean sumOverflow(long a, long b); static int sumRoundInt(Collection<? extends Number> collection); static long sumRoundLong(Collection<? extends Number> collection); static void times(int times, Runnable r); static int[] unique(int[] arr); static int[] uniqueUnsorted(int[] arr); @SuppressFBWarnings("WA_NOT_IN_LOOP") static boolean wait(Object obj); }### Answer: @Test public void testSumLong() { Assert.assertEquals(1138L + Integer.MAX_VALUE, Utilities.sumLong(Arrays.asList(Integer.valueOf(7), Integer.valueOf(-1), Integer.valueOf(1142), Integer.valueOf(-10), Integer.valueOf(Integer.MAX_VALUE)))); Assert.assertEquals(1138L + (long)Float.MAX_VALUE, Utilities.sumLong(Arrays.asList(Float.valueOf(7.1f), Float.valueOf(-1.4f), Float.valueOf(1142.9f), Float.valueOf(-10.1f), Float.valueOf(Float.MAX_VALUE)))); Assert.assertEquals(1138L + (long)Float.MAX_VALUE, Utilities.sumLong(Arrays.asList(Double.valueOf(7.1), Double.valueOf(-1.4), Double.valueOf(1142.9), Double.valueOf(-10.1), Double.valueOf(Float.MAX_VALUE)))); Assert.assertEquals(1138L + Integer.MAX_VALUE, Utilities.sumLong(Arrays.asList(Long.valueOf(7), Long.valueOf(-1), Long.valueOf(1142), Long.valueOf(-10), Long.valueOf(Integer.MAX_VALUE)))); }
### Question: Utilities { public static boolean sumOverflow(long a, long b) { return b > Long.MAX_VALUE - a; } private Utilities(); static boolean booleanValue(@Nullable Boolean value); static T checkNull(T parameter, String name); static boolean[] clone(boolean[] obj); static byte[] clone(byte[] obj); static char[] clone(char[] obj); static Date clone(Date date); static double[] clone(double[] obj); static float[] clone(float[] obj); static int[] clone(int[] obj); static long[] clone(long[] obj); static Object[] clone(Object[] obj); static void close(AutoCloseable... closeables); static void closeQuietly(AutoCloseable... closeables); static T getNonNull(T o1, T o2, BinaryOperator<T> resolver); static byte[] concatenate(byte[] arr1, byte[] arr2); static int[] concatenate(int[] arr1, int[] arr2); static long[] concatenate(long[] arr1, long[] arr2); static boolean equalsOrBothNaN(double val1, double val2); static ByteArrayOutputStream getByteArrayOutputStream(); static T getValue(T value, T defaultValue); static void ifNotNull(T obj, Consumer<? super T> consumer); static int indexOf(char[] arr, char element); static boolean isSequential(int[] ints); static boolean isSequential(long[] longs); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean notSameInstance(Object obj1, Object obj2); static double parseDouble(String value, double defaultValue); static float parseFloat(String value, float defaultValue); static int parseInt(String value, int defaultValue); static long parseLong(String value, long defaultValue); static double parseSystemProperty(String propName, double defValue); static float parseSystemProperty(String propName, float defValue); static int parseSystemProperty(String propName, int defValue); static long parseSystemProperty(String propName, long defValue); static Class<?> primitiveTypeFor(Class<?> wrapper); static T[] removeFromArray(T[] arr, Object obj); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean sameInstance(Object obj1, Object obj2); static int sizeOfArrayListBytes(int arrayLength); static int sizeOfEnumMapBytes(Class<K> type); static int sizeOfLinkedListBytes(int size); static double sumDouble(Collection<? extends Number> collection); static float sumFloat(Collection<? extends Number> collection); static int sumInt(Collection<? extends Number> collection); static long sumLong(Collection<? extends Number> collection); static boolean sumOverflow(long a, long b); static int sumRoundInt(Collection<? extends Number> collection); static long sumRoundLong(Collection<? extends Number> collection); static void times(int times, Runnable r); static int[] unique(int[] arr); static int[] uniqueUnsorted(int[] arr); @SuppressFBWarnings("WA_NOT_IN_LOOP") static boolean wait(Object obj); }### Answer: @Test public void testSumOverflow() { Assert.assertFalse(Utilities.sumOverflow(0L, 0L)); Assert.assertFalse(Utilities.sumOverflow(Long.MAX_VALUE, 0L)); Assert.assertTrue(Utilities.sumOverflow(Long.MAX_VALUE, 1L)); Assert.assertFalse(Utilities.sumOverflow(Long.MAX_VALUE, -1L)); }
### Question: Utilities { public static int sumRoundInt(Collection<? extends Number> collection) { int total = 0; for (Number number : collection) { total += Math.round(number.floatValue()); } return total; } private Utilities(); static boolean booleanValue(@Nullable Boolean value); static T checkNull(T parameter, String name); static boolean[] clone(boolean[] obj); static byte[] clone(byte[] obj); static char[] clone(char[] obj); static Date clone(Date date); static double[] clone(double[] obj); static float[] clone(float[] obj); static int[] clone(int[] obj); static long[] clone(long[] obj); static Object[] clone(Object[] obj); static void close(AutoCloseable... closeables); static void closeQuietly(AutoCloseable... closeables); static T getNonNull(T o1, T o2, BinaryOperator<T> resolver); static byte[] concatenate(byte[] arr1, byte[] arr2); static int[] concatenate(int[] arr1, int[] arr2); static long[] concatenate(long[] arr1, long[] arr2); static boolean equalsOrBothNaN(double val1, double val2); static ByteArrayOutputStream getByteArrayOutputStream(); static T getValue(T value, T defaultValue); static void ifNotNull(T obj, Consumer<? super T> consumer); static int indexOf(char[] arr, char element); static boolean isSequential(int[] ints); static boolean isSequential(long[] longs); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean notSameInstance(Object obj1, Object obj2); static double parseDouble(String value, double defaultValue); static float parseFloat(String value, float defaultValue); static int parseInt(String value, int defaultValue); static long parseLong(String value, long defaultValue); static double parseSystemProperty(String propName, double defValue); static float parseSystemProperty(String propName, float defValue); static int parseSystemProperty(String propName, int defValue); static long parseSystemProperty(String propName, long defValue); static Class<?> primitiveTypeFor(Class<?> wrapper); static T[] removeFromArray(T[] arr, Object obj); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean sameInstance(Object obj1, Object obj2); static int sizeOfArrayListBytes(int arrayLength); static int sizeOfEnumMapBytes(Class<K> type); static int sizeOfLinkedListBytes(int size); static double sumDouble(Collection<? extends Number> collection); static float sumFloat(Collection<? extends Number> collection); static int sumInt(Collection<? extends Number> collection); static long sumLong(Collection<? extends Number> collection); static boolean sumOverflow(long a, long b); static int sumRoundInt(Collection<? extends Number> collection); static long sumRoundLong(Collection<? extends Number> collection); static void times(int times, Runnable r); static int[] unique(int[] arr); static int[] uniqueUnsorted(int[] arr); @SuppressFBWarnings("WA_NOT_IN_LOOP") static boolean wait(Object obj); }### Answer: @Test public void testSumRoundInt() { Assert.assertEquals(1138, Utilities.sumRoundInt( Arrays.asList(Integer.valueOf(7), Integer.valueOf(-1), Integer.valueOf(1142), Integer.valueOf(-10)))); Assert.assertEquals(1139, Utilities.sumRoundInt( Arrays.asList(Float.valueOf(7.1f), Float.valueOf(-1.4f), Float.valueOf(1142.9f), Float.valueOf(-10.1f)))); Assert.assertEquals(1139, Utilities.sumRoundInt( Arrays.asList(Double.valueOf(7.1), Double.valueOf(-1.4), Double.valueOf(1142.9), Double.valueOf(-10.1)))); Assert.assertEquals(1138, Utilities.sumRoundInt(Arrays.asList(Long.valueOf(7), Long.valueOf(-1), Long.valueOf(1142), Long.valueOf(-10)))); }
### Question: Utilities { public static long sumRoundLong(Collection<? extends Number> collection) { long total = 0; for (Number number : collection) { total += Math.round(number.doubleValue()); } return total; } private Utilities(); static boolean booleanValue(@Nullable Boolean value); static T checkNull(T parameter, String name); static boolean[] clone(boolean[] obj); static byte[] clone(byte[] obj); static char[] clone(char[] obj); static Date clone(Date date); static double[] clone(double[] obj); static float[] clone(float[] obj); static int[] clone(int[] obj); static long[] clone(long[] obj); static Object[] clone(Object[] obj); static void close(AutoCloseable... closeables); static void closeQuietly(AutoCloseable... closeables); static T getNonNull(T o1, T o2, BinaryOperator<T> resolver); static byte[] concatenate(byte[] arr1, byte[] arr2); static int[] concatenate(int[] arr1, int[] arr2); static long[] concatenate(long[] arr1, long[] arr2); static boolean equalsOrBothNaN(double val1, double val2); static ByteArrayOutputStream getByteArrayOutputStream(); static T getValue(T value, T defaultValue); static void ifNotNull(T obj, Consumer<? super T> consumer); static int indexOf(char[] arr, char element); static boolean isSequential(int[] ints); static boolean isSequential(long[] longs); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean notSameInstance(Object obj1, Object obj2); static double parseDouble(String value, double defaultValue); static float parseFloat(String value, float defaultValue); static int parseInt(String value, int defaultValue); static long parseLong(String value, long defaultValue); static double parseSystemProperty(String propName, double defValue); static float parseSystemProperty(String propName, float defValue); static int parseSystemProperty(String propName, int defValue); static long parseSystemProperty(String propName, long defValue); static Class<?> primitiveTypeFor(Class<?> wrapper); static T[] removeFromArray(T[] arr, Object obj); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean sameInstance(Object obj1, Object obj2); static int sizeOfArrayListBytes(int arrayLength); static int sizeOfEnumMapBytes(Class<K> type); static int sizeOfLinkedListBytes(int size); static double sumDouble(Collection<? extends Number> collection); static float sumFloat(Collection<? extends Number> collection); static int sumInt(Collection<? extends Number> collection); static long sumLong(Collection<? extends Number> collection); static boolean sumOverflow(long a, long b); static int sumRoundInt(Collection<? extends Number> collection); static long sumRoundLong(Collection<? extends Number> collection); static void times(int times, Runnable r); static int[] unique(int[] arr); static int[] uniqueUnsorted(int[] arr); @SuppressFBWarnings("WA_NOT_IN_LOOP") static boolean wait(Object obj); }### Answer: @Test public void testSumRoundLong() { Assert.assertEquals(1138L + Integer.MAX_VALUE, Utilities.sumRoundLong(Arrays.asList(Integer.valueOf(7), Integer.valueOf(-1), Integer.valueOf(1142), Integer.valueOf(-10), Integer.valueOf(Integer.MAX_VALUE)))); Assert.assertEquals(1139L + (long)Float.MAX_VALUE, Utilities.sumRoundLong(Arrays.asList(Float.valueOf(7.1f), Float.valueOf(-1.4f), Float.valueOf(1142.9f), Float.valueOf(-10.1f), Float.valueOf(Float.MAX_VALUE)))); Assert.assertEquals(1139L + (long)Float.MAX_VALUE, Utilities.sumRoundLong(Arrays.asList(Double.valueOf(7.1), Double.valueOf(-1.4), Double.valueOf(1142.9), Double.valueOf(-10.1), Double.valueOf(Float.MAX_VALUE)))); Assert.assertEquals(1138L + Integer.MAX_VALUE, Utilities.sumRoundLong(Arrays.asList(Long.valueOf(7), Long.valueOf(-1), Long.valueOf(1142), Long.valueOf(-10), Long.valueOf(Integer.MAX_VALUE)))); }
### Question: Utilities { public static int[] uniqueUnsorted(int[] arr) { int[] sorted = arr.clone(); Arrays.sort(sorted); return unique(sorted); } private Utilities(); static boolean booleanValue(@Nullable Boolean value); static T checkNull(T parameter, String name); static boolean[] clone(boolean[] obj); static byte[] clone(byte[] obj); static char[] clone(char[] obj); static Date clone(Date date); static double[] clone(double[] obj); static float[] clone(float[] obj); static int[] clone(int[] obj); static long[] clone(long[] obj); static Object[] clone(Object[] obj); static void close(AutoCloseable... closeables); static void closeQuietly(AutoCloseable... closeables); static T getNonNull(T o1, T o2, BinaryOperator<T> resolver); static byte[] concatenate(byte[] arr1, byte[] arr2); static int[] concatenate(int[] arr1, int[] arr2); static long[] concatenate(long[] arr1, long[] arr2); static boolean equalsOrBothNaN(double val1, double val2); static ByteArrayOutputStream getByteArrayOutputStream(); static T getValue(T value, T defaultValue); static void ifNotNull(T obj, Consumer<? super T> consumer); static int indexOf(char[] arr, char element); static boolean isSequential(int[] ints); static boolean isSequential(long[] longs); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean notSameInstance(Object obj1, Object obj2); static double parseDouble(String value, double defaultValue); static float parseFloat(String value, float defaultValue); static int parseInt(String value, int defaultValue); static long parseLong(String value, long defaultValue); static double parseSystemProperty(String propName, double defValue); static float parseSystemProperty(String propName, float defValue); static int parseSystemProperty(String propName, int defValue); static long parseSystemProperty(String propName, long defValue); static Class<?> primitiveTypeFor(Class<?> wrapper); static T[] removeFromArray(T[] arr, Object obj); @SuppressWarnings("PMD.CompareObjectsWithEquals") static boolean sameInstance(Object obj1, Object obj2); static int sizeOfArrayListBytes(int arrayLength); static int sizeOfEnumMapBytes(Class<K> type); static int sizeOfLinkedListBytes(int size); static double sumDouble(Collection<? extends Number> collection); static float sumFloat(Collection<? extends Number> collection); static int sumInt(Collection<? extends Number> collection); static long sumLong(Collection<? extends Number> collection); static boolean sumOverflow(long a, long b); static int sumRoundInt(Collection<? extends Number> collection); static long sumRoundLong(Collection<? extends Number> collection); static void times(int times, Runnable r); static int[] unique(int[] arr); static int[] uniqueUnsorted(int[] arr); @SuppressFBWarnings("WA_NOT_IN_LOOP") static boolean wait(Object obj); }### Answer: @Test public void testUniqueUnsorted() { int[] arr; int[] expected; int[] result; String msg = "Arrays are not equal."; arr = new int[0]; expected = new int[0]; result = Utilities.uniqueUnsorted(arr); Assert.assertTrue(msg, Arrays.equals(result, expected)); arr = new int[] { 0 }; expected = new int[] { 0 }; result = Utilities.uniqueUnsorted(arr); Assert.assertTrue(msg, Arrays.equals(result, expected)); arr = new int[] { 1, 1, 1 }; expected = new int[] { 1 }; result = Utilities.uniqueUnsorted(arr); Assert.assertTrue(msg, Arrays.equals(result, expected)); arr = new int[] { -5, -3, -5, 2, 2, 1, 1, 0, -2 }; expected = new int[] { -5, -3, -2, 0, 1, 2 }; result = Utilities.uniqueUnsorted(arr); Assert.assertTrue(msg, Arrays.equals(result, expected)); }
### Question: SceneGraph { public GroupNode<E, T> buildTree() { List<Entry<Object, Set<SceneGraphParameter>>> list = new LinkedList<>( myParameterTypeMap.entrySet()); Collections.sort(list, myEntryComparator); GroupNode<E, T> root = new GroupNode<>(null, null); Stack<GroupNode<E, T>> parentStack = new Stack<>(); parentStack.add(root); if (list.isEmpty()) { return root; } Map<SceneGraphParameter, Set<E>> parameterMap = new HashMap<>(myParameterMap.size()); for (Entry<SceneGraphParameter, Set<E>> entry : myParameterMap.entrySet()) { parameterMap.put(entry.getKey(), new HashSet<>(entry.getValue())); } Stack<Iterator<SceneGraphParameter>> iterStack = new Stack<>(); Stack<Set<E>> intersectingObjectsStack = new Stack<>(); int level = 0; final int lastLevel = list.size() - 1; while (level >= 0) { Iterator<SceneGraphParameter> iter = getIter(list, iterStack, level); if (iter.hasNext()) { SceneGraphParameter param = iter.next(); Set<E> objs = parameterMap.get(param); Set<E> intersectingObjects = getIntersectingObjects(objs, level, intersectingObjectsStack); if (!intersectingObjects.isEmpty()) { Node<E, T> node; GroupNode<E, T> parentNode = parentStack.get(level); T paramForNode = castNode(param); if (level == lastLevel) { LeafNode<E, T> leafNode = new LeafNode<>(parentNode, paramForNode); leafNode.getObjects().addAll(intersectingObjects); node = leafNode; objs.removeAll(intersectingObjects); } else { intersectingObjectsStack.add(intersectingObjects); GroupNode<E, T> groupNode = new GroupNode<>(parentNode, paramForNode); parentStack.add(groupNode); node = groupNode; } if (LOGGER.isTraceEnabled()) { LOGGER.trace("Adding " + node.getClass().getSimpleName() + " with parameter [" + param + "] and intersecting objects [" + intersectingObjects + "]"); } if (level < lastLevel) { ++level; } } } else { --level; parentStack.pop(); iterStack.pop(); if (level >= 0) { intersectingObjectsStack.pop(); } } } return root; } @SuppressWarnings("varargs") @SafeVarargs final void add(E obj, T... parameters); GroupNode<E, T> buildTree(); }### Answer: @Test public void test0Levels() { SceneGraph<TestGeometry, Param1> sceneGraph = new SceneGraph<>(); GroupNode<TestGeometry, Param1> root = sceneGraph.buildTree(); assertNotNull(root); List<Node<TestGeometry, Param1>> nodes = root.getNodes(); assertEquals(0, nodes.size()); }
### Question: DriverChecker { static List<String> getActions(String glVendor, String driverVersion, Map<String, String> configMap) { List<String> actions = null; for (Map.Entry<String, String> entry : configMap.entrySet()) { String[] tokens = entry.getKey().split(":"); String vendor = tokens[0]; String versionFragment = tokens[1]; if (glVendor.startsWith(vendor) && driverVersion.startsWith(versionFragment) && !versionFragment.isEmpty()) { actions = New.list(entry.getValue().split(",")); } } return actions; } DriverChecker(Component component, Preferences prefs, PreferencesRegistry preferencesRegistry, String displayListPrefsKey); void checkGraphicsDriver(GL gl); }### Answer: @Test public void testGetActionsNvidia() { Assert.assertNull(DriverChecker.getActions("NVIDIA Corporation", "369.49", UNSUPPORTED_DRIVERS)); } @Test public void testGetActionsAtiGood() { Assert.assertNull(DriverChecker.getActions("ATI Technologies Inc.", "15.201.2201.0", UNSUPPORTED_DRIVERS)); } @Test public void testGetActionsAtiBad() { Assert.assertEquals(New.list("disableTooltips"), DriverChecker.getActions("ATI Technologies Inc.", "14.501.1003.0", UNSUPPORTED_DRIVERS)); }
### Question: EllipsoidVertexGenerator { public List<List<Position>> generateVertices(int detailLevel, double axisAInMeters, double axisBInMeters, double axisCInMeters) { List<List<Position>> vertices = New.list(); double pi = Math.PI; double tStep = pi / detailLevel; double sStep = tStep; double axisBRadius = axisBInMeters / 2; double axisARadius = axisAInMeters / 2; double axisCRadius = axisCInMeters / 2; boolean hasDrawnPole = false; for (double t = -pi / 2; t <= pi / 2 && !hasDrawnPole; t += tStep) { List<Position> triangleStrip = New.list(); for (double s = -pi; s <= pi + ourTolerance; s += sStep) { double x = axisBRadius * Math.cos(t) * Math.cos(s); double y = axisARadius * Math.cos(t) * Math.sin(s); double z = axisCRadius * Math.sin(t); if (z >= axisCRadius) { hasDrawnPole = true; } triangleStrip.add(new ModelPosition(x, y, z)); x = axisBRadius * Math.cos(t + tStep) * Math.cos(s); y = axisARadius * Math.cos(t + tStep) * Math.sin(s); z = axisCRadius * Math.sin(t + tStep); triangleStrip.add(new ModelPosition(x, y, z)); if (z >= axisCRadius) { hasDrawnPole = true; } } vertices.add(triangleStrip); } return vertices; } List<List<Position>> generateVertices(int detailLevel, double axisAInMeters, double axisBInMeters, double axisCInMeters); }### Answer: @Test public void test() { List<List<Position>> expectedPositions = EllipsoidTestUtils.getExpectedPositions(); EllipsoidVertexGenerator generator = new EllipsoidVertexGenerator(); List<List<Position>> actualPositions = generator.generateVertices(EllipsoidTestUtils.QUALITY, EllipsoidTestUtils.AXIS_A, EllipsoidTestUtils.AXIS_B, EllipsoidTestUtils.AXIS_C); assertFalse(actualPositions.isEmpty()); assertEquals(expectedPositions.size(), actualPositions.size()); for (int i = 0; i < expectedPositions.size(); i++) { List<Position> expectedStrip = expectedPositions.get(i); List<Position> actualStrip = actualPositions.get(i); assertFalse(actualStrip.isEmpty()); assertEquals(expectedStrip.size(), actualStrip.size()); int index = 0; for (Position expected : expectedStrip) { Position actual = actualStrip.get(index); assertEquals(expected.asVector3d(), actual.asVector3d()); index++; } } }
### Question: BoundedTimeConstraint extends TimeConstraint { public static synchronized BoundedTimeConstraint getTimeConstraint(Object key, TimeSpan timeSpan, Duration minDuration, Duration maxDuration) { long minTime = timeSpan.isUnboundedStart() ? Long.MIN_VALUE : timeSpan.getStart(); long maxTime = timeSpan.isUnboundedEnd() ? Long.MAX_VALUE : timeSpan.getEnd(); int minDurationSeconds = minDuration == null ? 0 : new Seconds(minDuration).intValue(); int maxDurationSeconds = maxDuration == null ? Integer.MAX_VALUE : new Seconds(maxDuration).intValue(); return (BoundedTimeConstraint)getPool() .get(new BoundedTimeConstraint(key, minTime, maxTime, minDurationSeconds, maxDurationSeconds)); } protected BoundedTimeConstraint(Object key, long minTime, long maxTime, int minDurationSeconds, int maxDurationSeconds); static synchronized BoundedTimeConstraint getTimeConstraint(Object key, TimeSpan timeSpan, Duration minDuration, Duration maxDuration); static synchronized BoundedTimeConstraint getTimeConstraint(TimeSpan timeSpan, Duration minDuration, Duration maxDuration); @Override boolean check(TimeSpan span); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test(expected = IllegalArgumentException.class) public void testBadConstruct1() { BoundedTimeConstraint.getTimeConstraint(TimeSpan.TIMELESS, new Seconds(3600), new Seconds(3600)); } @Test(expected = IllegalArgumentException.class) public void testBadConstruct2() { BoundedTimeConstraint.getTimeConstraint(TimeSpan.TIMELESS, new Seconds(3601), new Seconds(3600)); } @Test public void testPool() { BoundedTimeConstraint con = BoundedTimeConstraint.getTimeConstraint(TimeSpan.TIMELESS, Seconds.ZERO, Hours.ONE); Assert.assertSame(con, BoundedTimeConstraint.getTimeConstraint(TimeSpan.TIMELESS, Seconds.ZERO, Hours.ONE)); Assert.assertNotSame(con, BoundedTimeConstraint.getTimeConstraint(TimeSpan.TIMELESS, Seconds.ONE, Hours.ONE)); Assert.assertNotSame(con, BoundedTimeConstraint.getTimeConstraint(TimeSpan.TIMELESS, Seconds.ZERO, new Hours(2))); Assert.assertNotSame(con, BoundedTimeConstraint.getTimeConstraint(TimeSpan.get(0L, 3600L), Seconds.ZERO, Hours.ONE)); Assert.assertNotSame(con, TimeConstraint.getTimeConstraint(TimeSpan.TIMELESS)); }
### Question: TorusMeshGeometry extends PolygonMeshGeometry { @Override public TorusMeshGeometry clone() { TorusMeshGeometry clone = (TorusMeshGeometry)super.clone(); clone.myPositionTransform = myPositionTransform == null ? null : myPositionTransform.clone(); return clone; } TorusMeshGeometry(Builder<?> builder, PolygonMeshRenderProperties renderProperties, Constraints constraints); @Override TorusMeshGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override TorusMeshGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); Position getCenter(); int getCirPoints(); Matrix3d getPositionTransform(); double getRadius(); double getTubeRadius(); int getTubeSections(); }### Answer: @Test public void testClone() { TorusMeshGeometry.Builder<GeographicPosition> builder = new TorusMeshGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); builder.setCircularPoints(13); builder.setRadius(.123f); builder.setTubeRadius(.0543); builder.setTubeSections(20); builder.setPositionTransform(new Matrix3d()); builder.setCenter(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.))); PolygonMeshRenderProperties renderProperties1 = new DefaultPolygonMeshRenderProperties(65763, false, true, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); TorusMeshGeometry geom = new TorusMeshGeometry(builder, renderProperties1, constraints1); TorusMeshGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.getRadius(), clone.getRadius(), 0.f); Assert.assertEquals(geom.getTubeRadius(), clone.getTubeRadius(), 0.f); Assert.assertEquals(geom.getTubeSections(), clone.getTubeSections()); Assert.assertEquals(geom.getCenter(), clone.getCenter()); Assert.assertEquals(geom.getCirPoints(), clone.getCirPoints()); Assert.assertEquals(geom.getPositionTransform(), clone.getPositionTransform()); Assert.assertNotSame(geom.getPositionTransform(), clone.getPositionTransform()); Assert.assertEquals(geom.getPolygonVertexCount(), clone.getPolygonVertexCount()); Assert.assertEquals(geom.getColors(), clone.getColors()); Assert.assertEquals(geom.getNormals(), clone.getNormals()); Assert.assertEquals(geom.getPositions(), clone.getPositions()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); Assert.assertNotSame(geom.getConstraints(), clone.getConstraints()); }
### Question: TorusMeshGeometry extends PolygonMeshGeometry { @Override public TorusMeshGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new TorusMeshGeometry(createBuilder(), (PolygonMeshRenderProperties)renderProperties, constraints); } TorusMeshGeometry(Builder<?> builder, PolygonMeshRenderProperties renderProperties, Constraints constraints); @Override TorusMeshGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override TorusMeshGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); Position getCenter(); int getCirPoints(); Matrix3d getPositionTransform(); double getRadius(); double getTubeRadius(); int getTubeSections(); }### Answer: @Test public void testDerive() { TorusMeshGeometry.Builder<GeographicPosition> builder = new TorusMeshGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); builder.setCircularPoints(13); builder.setRadius(.123f); builder.setTubeRadius(.0543); builder.setTubeSections(20); builder.setPositionTransform(new Matrix3d()); builder.setCenter(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.))); PolygonMeshRenderProperties renderProperties1 = new DefaultPolygonMeshRenderProperties(65763, false, true, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); TorusMeshGeometry geom = new TorusMeshGeometry(builder, renderProperties1, constraints1); AbstractRenderableGeometry absGeom = geom; ColorRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); AbstractRenderableGeometry derived = absGeom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.getRadius(), ((TorusMeshGeometry)derived).getRadius(), 0.f); Assert.assertEquals(geom.getTubeRadius(), ((TorusMeshGeometry)derived).getTubeRadius(), 0.f); Assert.assertEquals(geom.getTubeSections(), ((TorusMeshGeometry)derived).getTubeSections()); Assert.assertEquals(geom.getCenter(), ((TorusMeshGeometry)derived).getCenter()); Assert.assertEquals(geom.getCirPoints(), ((TorusMeshGeometry)derived).getCirPoints()); Assert.assertEquals(geom.getPositionTransform(), ((TorusMeshGeometry)derived).getPositionTransform()); Assert.assertNotSame(geom.getPositionTransform(), ((TorusMeshGeometry)derived).getPositionTransform()); Assert.assertEquals(geom.getPolygonVertexCount(), ((TorusMeshGeometry)derived).getPolygonVertexCount()); Assert.assertEquals(geom.getColors(), ((TorusMeshGeometry)derived).getColors()); Assert.assertEquals(geom.getNormals(), ((TorusMeshGeometry)derived).getNormals()); Assert.assertEquals(geom.getPositions(), ((TorusMeshGeometry)derived).getPositions()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: EllipseGeometry extends PolygonGeometry { @Override public EllipseGeometry clone() { return (EllipseGeometry)super.clone(); } EllipseGeometry(EllipseGeometry.AngleBuilder<?> builder, PolygonRenderProperties renderProperties, Constraints constraints); EllipseGeometry(EllipseGeometry.Builder<?> builder, PolygonRenderProperties renderProperties, Constraints constraints); EllipseGeometry(EllipseGeometry.FocusBuilder<?> builder, PolygonRenderProperties renderProperties, Constraints constraints); EllipseGeometry(EllipseGeometry.ProjectedBuilder builder, PolygonRenderProperties renderProperties, Constraints constraints); protected EllipseGeometry(PolygonGeometry.Builder<?> builder, PolygonRenderProperties renderProperties, Constraints constraints); @Override EllipseGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override EllipseGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); @Override Position getReferencePoint(); }### Answer: @Test public void testClone() { EllipseGeometry.AngleBuilder<GeographicPosition> builder = new EllipseGeometry.AngleBuilder<GeographicPosition>(); builder.setDataModelId(3423L); GeographicPosition position = new GeographicPosition(LatLonAlt.createFromDegrees(23., 56.)); builder.setCenter(position); builder.setAngle(45.); builder.setSemiMajorAxis(23f); builder.setSemiMinorAxis(26f); builder.setLineSmoothing(true); builder.setLineType(LineType.GREAT_CIRCLE); builder.setRapidUpdate(true); PolygonRenderProperties renderProperties1 = new DefaultPolygonRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); EllipseGeometry geom = new EllipseGeometry(builder, renderProperties1, constraints1); EllipseGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.isLineSmoothing(), clone.isLineSmoothing()); Assert.assertEquals(geom.getLineType(), clone.getLineType()); Assert.assertEquals(geom.getVertices(), clone.getVertices()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), clone.getConstraints()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); }
### Question: EllipseGeometry extends PolygonGeometry { @Override public EllipseGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new EllipseGeometry(createBuilder(), (PolygonRenderProperties)renderProperties, constraints); } EllipseGeometry(EllipseGeometry.AngleBuilder<?> builder, PolygonRenderProperties renderProperties, Constraints constraints); EllipseGeometry(EllipseGeometry.Builder<?> builder, PolygonRenderProperties renderProperties, Constraints constraints); EllipseGeometry(EllipseGeometry.FocusBuilder<?> builder, PolygonRenderProperties renderProperties, Constraints constraints); EllipseGeometry(EllipseGeometry.ProjectedBuilder builder, PolygonRenderProperties renderProperties, Constraints constraints); protected EllipseGeometry(PolygonGeometry.Builder<?> builder, PolygonRenderProperties renderProperties, Constraints constraints); @Override EllipseGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override EllipseGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); @Override Position getReferencePoint(); }### Answer: @Test public void testDerive() { EllipseGeometry.AngleBuilder<GeographicPosition> builder = new EllipseGeometry.AngleBuilder<GeographicPosition>(); builder.setDataModelId(3423L); GeographicPosition position = new GeographicPosition(LatLonAlt.createFromDegrees(23., 56.)); builder.setCenter(position); builder.setAngle(45.); builder.setSemiMajorAxis(23f); builder.setSemiMinorAxis(26f); builder.setLineSmoothing(true); builder.setLineType(LineType.GREAT_CIRCLE); builder.setRapidUpdate(true); PolygonRenderProperties renderProperties1 = new DefaultPolygonRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); EllipseGeometry geom = new EllipseGeometry(builder, renderProperties1, constraints1); AbstractRenderableGeometry absGeom = geom; ColorRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); AbstractRenderableGeometry derived = absGeom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.isLineSmoothing(), ((EllipseGeometry)derived).isLineSmoothing()); Assert.assertEquals(geom.getLineType(), ((EllipseGeometry)derived).getLineType()); Assert.assertEquals(geom.getVertices(), ((EllipseGeometry)derived).getVertices()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: LabelGeometry extends AbstractColorGeometry { @Override public LabelGeometry clone() { return (LabelGeometry)super.clone(); } LabelGeometry(LabelGeometry.Builder<?> builder, LabelRenderProperties renderProperties, Constraints constraints); @Override LabelGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override LabelGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); @Override GeometryOrderKey getGeometryOrderKey(); float getHorizontalAlignment(); Color getOutlineColor(); Position getPosition(); @Override Class<? extends Position> getPositionType(); @Override Position getReferencePoint(); @Override LabelRenderProperties getRenderProperties(); String getText(); float getVerticalAlignment(); boolean isOutlined(); @Override boolean overlaps(BoundingBox<T> boundingBox, double tolerance); @Override String toString(); }### Answer: @Test public void testClone() { LabelGeometry.Builder<GeographicPosition> builder = new LabelGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); GeographicPosition position = new GeographicPosition(LatLonAlt.createFromDegrees(23., 56.)); builder.setPosition(position); builder.setRapidUpdate(true); builder.setFont("font"); builder.setText("text"); builder.setHorizontalAlignment(.5f); builder.setVerticalAlignment(.5f); LabelRenderProperties renderProperties1 = new DefaultLabelRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); LabelGeometry geom = new LabelGeometry(builder, renderProperties1, constraints1); LabelGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.getPosition(), clone.getPosition()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertEquals(geom.getText(), clone.getText()); Assert.assertEquals(geom.getHorizontalAlignment(), clone.getHorizontalAlignment(), 0f); Assert.assertEquals(geom.getVerticalAlignment(), clone.getVerticalAlignment(), 0f); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), clone.getConstraints()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); }
### Question: LabelGeometry extends AbstractColorGeometry { @Override public LabelGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new LabelGeometry(createBuilder(), (LabelRenderProperties)renderProperties, constraints); } LabelGeometry(LabelGeometry.Builder<?> builder, LabelRenderProperties renderProperties, Constraints constraints); @Override LabelGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override LabelGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); @Override GeometryOrderKey getGeometryOrderKey(); float getHorizontalAlignment(); Color getOutlineColor(); Position getPosition(); @Override Class<? extends Position> getPositionType(); @Override Position getReferencePoint(); @Override LabelRenderProperties getRenderProperties(); String getText(); float getVerticalAlignment(); boolean isOutlined(); @Override boolean overlaps(BoundingBox<T> boundingBox, double tolerance); @Override String toString(); }### Answer: @Test public void testDerive() { LabelGeometry.Builder<GeographicPosition> builder = new LabelGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); GeographicPosition position = new GeographicPosition(LatLonAlt.createFromDegrees(23., 56.)); builder.setPosition(position); builder.setRapidUpdate(true); builder.setFont("font"); builder.setText("text"); builder.setHorizontalAlignment(.5f); builder.setVerticalAlignment(.5f); LabelRenderProperties renderProperties1 = new DefaultLabelRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); LabelGeometry geom = new LabelGeometry(builder, renderProperties1, constraints1); AbstractRenderableGeometry absGeom = geom; LabelRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); AbstractRenderableGeometry derived = absGeom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.getPosition(), ((LabelGeometry)derived).getPosition()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertEquals(geom.getText(), ((LabelGeometry)derived).getText()); Assert.assertEquals(geom.getHorizontalAlignment(), ((LabelGeometry)derived).getHorizontalAlignment(), 0f); Assert.assertEquals(geom.getVerticalAlignment(), ((LabelGeometry)derived).getVerticalAlignment(), 0f); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: LineOfBearingGeometry extends PolylineGeometry { @Override public LineOfBearingGeometry clone() { return (LineOfBearingGeometry)super.clone(); } LineOfBearingGeometry(LineOfBearingGeometry.Builder builder, LOBRenderProperties renderProperties, Constraints constraints); @Override LineOfBearingGeometry clone(); @Override Builder createBuilder(); @Override LineOfBearingGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); final float getLineOrientation(); GeographicPosition getPosition(); @Override LOBRenderProperties getRenderProperties(); boolean isDisplayArrow(); }### Answer: @Test public void testClone() { LineOfBearingGeometry.Builder builder = new LineOfBearingGeometry.Builder(); builder.setDataModelId(3423L); GeographicPosition position = new GeographicPosition(LatLonAlt.createFromDegrees(23., 56.)); builder.setPosition(position); builder.setRapidUpdate(true); builder.setLineOrientation(15f); LOBRenderProperties renderProperties1 = new DefaultLOBRenderProperties(65763, false, true); renderProperties1.setWidth(5f); renderProperties1.setLineLength(200f); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); LineOfBearingGeometry geom = new LineOfBearingGeometry(builder, renderProperties1, constraints1); LineOfBearingGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.getPosition(), clone.getPosition()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertEquals(geom.getRenderProperties().getWidth(), clone.getRenderProperties().getWidth(), 0f); Assert.assertEquals(geom.getRenderProperties().getLineLength(), clone.getRenderProperties().getLineLength(), 0f); Assert.assertEquals(geom.getRenderProperties().getDirectionalArrowLength(), clone.getRenderProperties().getDirectionalArrowLength(), 0f); Assert.assertEquals(geom.getLineOrientation(), clone.getLineOrientation(), 0f); Assert.assertEquals(geom.isDisplayArrow(), clone.isDisplayArrow()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), clone.getConstraints()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); }
### Question: LineOfBearingGeometry extends PolylineGeometry { @Override public LineOfBearingGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new LineOfBearingGeometry(createBuilder(), (LOBRenderProperties)renderProperties, constraints); } LineOfBearingGeometry(LineOfBearingGeometry.Builder builder, LOBRenderProperties renderProperties, Constraints constraints); @Override LineOfBearingGeometry clone(); @Override Builder createBuilder(); @Override LineOfBearingGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); final float getLineOrientation(); GeographicPosition getPosition(); @Override LOBRenderProperties getRenderProperties(); boolean isDisplayArrow(); }### Answer: @Test public void testDerive() { LineOfBearingGeometry.Builder builder = new LineOfBearingGeometry.Builder(); builder.setDataModelId(3423L); GeographicPosition position = new GeographicPosition(LatLonAlt.createFromDegrees(23., 56.)); builder.setPosition(position); builder.setRapidUpdate(true); builder.setLineOrientation(15f); LOBRenderProperties renderProperties1 = new DefaultLOBRenderProperties(65763, false, true); renderProperties1.setWidth(5f); renderProperties1.setLineLength(200f); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); LineOfBearingGeometry geom = new LineOfBearingGeometry(builder, renderProperties1, constraints1); AbstractRenderableGeometry absGeom = geom; PolylineRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); AbstractRenderableGeometry derived = absGeom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.getPosition(), ((LineOfBearingGeometry)derived).getPosition()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertEquals(geom.getRenderProperties().getWidth(), ((LineOfBearingGeometry)derived).getRenderProperties().getWidth(), 0f); Assert.assertEquals(geom.getRenderProperties().getLineLength(), ((LineOfBearingGeometry)derived).getRenderProperties().getLineLength(), 0f); Assert.assertEquals(geom.getRenderProperties().getDirectionalArrowLength(), ((LineOfBearingGeometry)derived).getRenderProperties().getDirectionalArrowLength(), 0f); Assert.assertEquals(geom.getLineOrientation(), ((LineOfBearingGeometry)derived).getLineOrientation(), 0f); Assert.assertEquals(geom.isDisplayArrow(), ((LineOfBearingGeometry)derived).isDisplayArrow()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: PolylineGeometry extends AbstractColorGeometry { @Override public PolylineGeometry clone() { return (PolylineGeometry)super.clone(); } PolylineGeometry(PolylineGeometry.Builder<?> builder, PolylineRenderProperties renderProperties, Constraints constraints); protected PolylineGeometry(AbstractGeometry.Builder builder, PolylineRenderProperties renderProperties, Constraints constraints, boolean smooth, LineType type); boolean areAnyCoordinatesOverlappingOrIntersecting(List<Polygon> polygons, GeometryFactory geomFactory, Coordinate[] coords); @Override PolylineGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override PolylineGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); LineType getLineType(); @Override Class<? extends Position> getPositionType(); @Override Position getReferencePoint(); @Override PolylineRenderProperties getRenderProperties(); List<? extends Position> getVertices(); boolean isLineSmoothing(); @Override boolean jtsIntersectionTests(JTSIntersectionTests test, List<Polygon> polygons, GeometryFactory geomFactory); @SuppressWarnings("unchecked") @Override boolean overlaps(BoundingBox<T> boundingBox, double tolerance); @Override String toString(); }### Answer: @Test public void testClone() { PolylineGeometry.Builder<GeographicPosition> builder = new PolylineGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); builder.setLineSmoothing(true); builder.setLineType(LineType.GREAT_CIRCLE); builder.setVertices(Arrays.asList(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.)), new GeographicPosition(LatLonAlt.createFromDegrees(35., 57.)))); PolylineRenderProperties renderProperties1 = new DefaultPolylineRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); PolylineGeometry geom = new PolylineGeometry(builder, renderProperties1, constraints1); PolylineGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertEquals(geom.isLineSmoothing(), clone.isLineSmoothing()); Assert.assertEquals(geom.getLineType(), clone.getLineType()); Assert.assertEquals(geom.getVertices(), clone.getVertices()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), clone.getConstraints()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); }
### Question: PolylineGeometry extends AbstractColorGeometry { @Override public PolylineGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new PolylineGeometry(createBuilder(), (PolylineRenderProperties)renderProperties, constraints); } PolylineGeometry(PolylineGeometry.Builder<?> builder, PolylineRenderProperties renderProperties, Constraints constraints); protected PolylineGeometry(AbstractGeometry.Builder builder, PolylineRenderProperties renderProperties, Constraints constraints, boolean smooth, LineType type); boolean areAnyCoordinatesOverlappingOrIntersecting(List<Polygon> polygons, GeometryFactory geomFactory, Coordinate[] coords); @Override PolylineGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override PolylineGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); LineType getLineType(); @Override Class<? extends Position> getPositionType(); @Override Position getReferencePoint(); @Override PolylineRenderProperties getRenderProperties(); List<? extends Position> getVertices(); boolean isLineSmoothing(); @Override boolean jtsIntersectionTests(JTSIntersectionTests test, List<Polygon> polygons, GeometryFactory geomFactory); @SuppressWarnings("unchecked") @Override boolean overlaps(BoundingBox<T> boundingBox, double tolerance); @Override String toString(); }### Answer: @Test public void testDerive() { PolylineGeometry.Builder<GeographicPosition> builder = new PolylineGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); builder.setLineSmoothing(true); builder.setLineType(LineType.GREAT_CIRCLE); builder.setVertices(Arrays.asList(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.)), new GeographicPosition(LatLonAlt.createFromDegrees(35., 57.)))); PolylineRenderProperties renderProperties1 = new DefaultPolylineRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); PolylineGeometry geom = new PolylineGeometry(builder, renderProperties1, constraints1); AbstractRenderableGeometry absGeom = geom; PolylineRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); AbstractRenderableGeometry derived = absGeom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertEquals(geom.isLineSmoothing(), ((PolylineGeometry)derived).isLineSmoothing()); Assert.assertEquals(geom.getLineType(), ((PolylineGeometry)derived).getLineType()); Assert.assertEquals(geom.getVertices(), ((PolylineGeometry)derived).getVertices()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: EllipsoidGeometryBuilder extends AbstractGeometry.Builder { protected PolygonMeshGeometry.Builder<Position> generatePolygonMeshBuilder() { PolygonMeshGeometry.Builder<Position> builder = new PolygonMeshGeometry.Builder<>(); List<List<Position>> vertices = myVertexGenerator.generateVertices(myQuality, myAxisAMeters, myAxisBMeters, myAxisCMeters); List<List<Vector3d>> normals = myNormalsGenerator.calculateNormals(vertices); List<Position> allVertices = New.list(); for (List<Position> strip : vertices) { allVertices.addAll(strip); } List<Vector3d> allNormals = New.list(); for (List<Vector3d> stripNormals : normals) { allNormals.addAll(stripNormals); } List<Color> colors = New.list(); for (int i = 0; i < allNormals.size(); i++) { colors.add(myColor); } builder.setColors(colors); builder.setNormals(allNormals); builder.setPolygonVertexCount(AbstractRenderer.TRIANGLE_STRIP_VERTEX_COUNT); builder.setPositions(allVertices); builder.setDataModelId(getDataModelId()); return builder; } EllipsoidGeometryBuilder(MapManager mapManager); double getAxisAMeters(); double getAxisBMeters(); double getAxisCMeters(); Color getColor(); double getHeading(); T getLocation(); MapManager getMapManager(); double getPitch(); int getQuality(); double getRoll(); void setAxisAMeters(double axisAMeters); void setAxisBMeters(double axisBMeters); void setAxisCMeters(double axisCMeters); void setColor(Color color); void setHeading(double heading); void setLocation(T location); void setPitch(double pitch); void setQuality(int quality); void setRoll(double roll); }### Answer: @Test public void testGeneratePolygonMeshBuilder() { EasyMockSupport support = new EasyMockSupport(); MapManager mapManager = support.createMock(MapManager.class); support.replayAll(); EllipsoidGeometryBuilder<GeographicPosition> builder = new EllipsoidGeometryBuilder<>(mapManager); builder.setAxisAMeters(EllipsoidTestUtils.AXIS_A); builder.setAxisBMeters(EllipsoidTestUtils.AXIS_B); builder.setAxisCMeters(EllipsoidTestUtils.AXIS_C); builder.setQuality(EllipsoidTestUtils.QUALITY); builder.setColor(Color.RED); List<List<Position>> expectedPositions = EllipsoidTestUtils.getExpectedPositions(); List<Position> combinedExpected = New.list(); for (List<Position> strip : expectedPositions) { combinedExpected.addAll(strip); } Builder<Position> meshBuilder = builder.generatePolygonMeshBuilder(); List<? extends Color> colors = meshBuilder.getColors(); assertEquals(combinedExpected.size(), colors.size()); for (Color color : colors) { assertEquals(Color.RED, color); } assertEquals(AbstractRenderer.TRIANGLE_STRIP_VERTEX_COUNT, meshBuilder.getPolygonVertexCount()); List<? extends Position> positions = meshBuilder.getPositions(); assertEquals(combinedExpected.size(), positions.size()); int index = 0; for (Position position : positions) { assertEquals(combinedExpected.get(index).asVector3d(), position.asVector3d()); index++; } List<Vector3d> expectedNormals = EllipsoidTestUtils.calculateExpectedNormals(expectedPositions); assertEquals(combinedExpected.size(), expectedNormals.size()); List<? extends Vector3d> actualNormals = meshBuilder.getNormals(); assertEquals(combinedExpected.size(), actualNormals.size()); assertEquals(expectedNormals, actualNormals); support.verifyAll(); }
### Question: EllipsoidGeometryBuilder extends AbstractGeometry.Builder { protected Matrix4d generateTransform() { Matrix4d transform = null; if (myLocation instanceof GeographicPosition) { transform = myTransformProvider.provideTransform(((GeographicPosition)myLocation).getLatLonAlt(), myHeading, myPitch, myRoll); } else { transform = myTransformProvider.provideTransform(myLocation.asVector3d(), myHeading, myPitch, myRoll); } return transform; } EllipsoidGeometryBuilder(MapManager mapManager); double getAxisAMeters(); double getAxisBMeters(); double getAxisCMeters(); Color getColor(); double getHeading(); T getLocation(); MapManager getMapManager(); double getPitch(); int getQuality(); double getRoll(); void setAxisAMeters(double axisAMeters); void setAxisBMeters(double axisBMeters); void setAxisCMeters(double axisCMeters); void setColor(Color color); void setHeading(double heading); void setLocation(T location); void setPitch(double pitch); void setQuality(int quality); void setRoll(double roll); }### Answer: @Test public void testGenerateTransform() { EasyMockSupport support = new EasyMockSupport(); MapManager mapManager = EllipsoidTestUtils.createMapManager(support); support.replayAll(); LatLonAlt location = LatLonAlt.createFromDegreesMeters(10, 11, 5280, ReferenceLevel.TERRAIN); EllipsoidGeometryBuilder<GeographicPosition> builder = new EllipsoidGeometryBuilder<>(mapManager); builder.setLocation(new GeographicPosition(location)); builder.setHeading(14); builder.setPitch(15); builder.setRoll(16); Matrix4d transform = builder.generateTransform(); Matrix4d expected = new Matrix4d(new double[] { -0.5187182308412952, 0.8122809550672292, -.26670404389125235, 0.0, -0.8501440620567355, -0.45705076232245867, 0.2614568308729626, 0.0, 0.0904791177153618, 0.36235928399246203, 0.9276363935087497, 0.0, 11.0, 10.0, 5280.0, 1.0 }); assertEquals(expected, transform); EllipsoidGeometryBuilder<ModelPosition> modelBuilder = new EllipsoidGeometryBuilder<>(mapManager); modelBuilder.setLocation(new ModelPosition(11, 10, 5280)); modelBuilder.setHeading(14); modelBuilder.setPitch(15); modelBuilder.setRoll(16); transform = modelBuilder.generateTransform(); assertEquals(expected, transform); support.verifyAll(); }
### Question: PointGeometry extends AbstractColorGeometry implements PointRenderPropertiesGeometry { @Override public PointGeometry clone() { return (PointGeometry)super.clone(); } PointGeometry(PointGeometry.Builder<?> builder, PointRenderProperties renderProperties, Constraints constraints); @Override PointGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override PointGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); final Position getPosition(); @Override Class<? extends Position> getPositionType(); @Override Position getReferencePoint(); @Override PointRenderProperties getRenderProperties(); @Override boolean jtsIntersectionTests(JTSIntersectionTests test, List<Polygon> polygons, GeometryFactory geomFactory); @Override boolean overlaps(BoundingBox<T> boundingBox, double tolerance); @Override String toString(); }### Answer: @Test public void testClone() { PointGeometry.Builder<GeographicPosition> builder = new PointGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); GeographicPosition position = new GeographicPosition(LatLonAlt.createFromDegrees(23., 56.)); builder.setPosition(position); builder.setRapidUpdate(true); PointRenderProperties renderProperties1 = new DefaultPointRenderProperties(65763, false, true, false); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); PointGeometry geom = new PointGeometry(builder, renderProperties1, constraints1); PointGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.getPosition(), clone.getPosition()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), clone.getConstraints()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); }
### Question: PointGeometry extends AbstractColorGeometry implements PointRenderPropertiesGeometry { @Override public PointGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new PointGeometry(createBuilder(), (PointRenderProperties)renderProperties, constraints); } PointGeometry(PointGeometry.Builder<?> builder, PointRenderProperties renderProperties, Constraints constraints); @Override PointGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override PointGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); final Position getPosition(); @Override Class<? extends Position> getPositionType(); @Override Position getReferencePoint(); @Override PointRenderProperties getRenderProperties(); @Override boolean jtsIntersectionTests(JTSIntersectionTests test, List<Polygon> polygons, GeometryFactory geomFactory); @Override boolean overlaps(BoundingBox<T> boundingBox, double tolerance); @Override String toString(); }### Answer: @Test public void testDerive() { PointGeometry.Builder<GeographicPosition> builder = new PointGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); GeographicPosition position = new GeographicPosition(LatLonAlt.createFromDegrees(23., 56.)); builder.setPosition(position); builder.setRapidUpdate(true); PointRenderProperties renderProperties1 = new DefaultPointRenderProperties(65763, false, true, false); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); PointGeometry geom = new PointGeometry(builder, renderProperties1, constraints1); AbstractRenderableGeometry absGeom = geom; PointRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); AbstractRenderableGeometry derived = absGeom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.getPosition(), ((PointGeometry)derived).getPosition()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: EllipseScalableGeometry extends AbstractScalableGeometry { @Override public EllipseScalableGeometry clone() { return (EllipseScalableGeometry)super.clone(); } EllipseScalableGeometry(EllipseScalableGeometry.Builder builder, ScalableRenderProperties renderProperties, Constraints constraints); @Override EllipseScalableGeometry clone(); @Override Builder createBuilder(); @Override EllipseScalableGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); float getAngle(); int getPointsNumber(); Projection getProjection(); float getSemiMajorAxis(); float getSemiMinorAxis(); }### Answer: @Test public void testClone() { EllipseScalableGeometry.Builder builder = new EllipseScalableGeometry.Builder(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); builder.setAngleDegrees(.8f); builder.setPointsNumber(21); builder.setSemiMajorAxis(.02f); builder.setSemiMinorAxis(.01f); builder.setPosition(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.))); ScalableRenderProperties renderProperties1 = new DefaultScalableRenderProperties(65763, false, true, false); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); EllipseScalableGeometry geom = new EllipseScalableGeometry(builder, renderProperties1, constraints1); EllipseScalableGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.getAngle(), clone.getAngle(), 0.f); Assert.assertEquals(geom.getSemiMajorAxis(), clone.getSemiMajorAxis(), 0.f); Assert.assertEquals(geom.getSemiMinorAxis(), clone.getSemiMinorAxis(), 0.f); Assert.assertEquals(geom.getPointsNumber(), clone.getPointsNumber()); Assert.assertEquals(geom.getPolygonVertexCount(), clone.getPolygonVertexCount()); Assert.assertEquals(geom.getPosition(), clone.getPosition()); Assert.assertEquals(geom.getColors(), clone.getColors()); Assert.assertEquals(geom.getNormals(), clone.getNormals()); Assert.assertEquals(geom.getPositions(), clone.getPositions()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), clone.getConstraints()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); }
### Question: EllipseScalableGeometry extends AbstractScalableGeometry { @Override public EllipseScalableGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new EllipseScalableGeometry(createBuilder(), (ScalableRenderProperties)renderProperties, constraints); } EllipseScalableGeometry(EllipseScalableGeometry.Builder builder, ScalableRenderProperties renderProperties, Constraints constraints); @Override EllipseScalableGeometry clone(); @Override Builder createBuilder(); @Override EllipseScalableGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); float getAngle(); int getPointsNumber(); Projection getProjection(); float getSemiMajorAxis(); float getSemiMinorAxis(); }### Answer: @Test public void testDerive() { EllipseScalableGeometry.Builder builder = new EllipseScalableGeometry.Builder(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); builder.setAngleDegrees(.8f); builder.setPointsNumber(21); builder.setSemiMajorAxis(.02f); builder.setSemiMinorAxis(.01f); builder.setPosition(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.))); ScalableRenderProperties renderProperties1 = new DefaultScalableRenderProperties(65763, false, true, false); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); EllipseScalableGeometry geom = new EllipseScalableGeometry(builder, renderProperties1, constraints1); AbstractRenderableGeometry absGeom = geom; BaseRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); AbstractRenderableGeometry derived = absGeom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.getAngle(), ((EllipseScalableGeometry)derived).getAngle(), 0.f); Assert.assertEquals(geom.getSemiMajorAxis(), ((EllipseScalableGeometry)derived).getSemiMajorAxis(), 0.f); Assert.assertEquals(geom.getSemiMinorAxis(), ((EllipseScalableGeometry)derived).getSemiMinorAxis(), 0.f); Assert.assertEquals(geom.getPointsNumber(), ((EllipseScalableGeometry)derived).getPointsNumber()); Assert.assertEquals(geom.getPolygonVertexCount(), ((EllipseScalableGeometry)derived).getPolygonVertexCount()); Assert.assertEquals(geom.getPosition(), ((EllipseScalableGeometry)derived).getPosition()); Assert.assertEquals(geom.getColors(), ((EllipseScalableGeometry)derived).getColors()); Assert.assertEquals(geom.getNormals(), ((EllipseScalableGeometry)derived).getNormals()); Assert.assertEquals(geom.getPositions(), ((EllipseScalableGeometry)derived).getPositions()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: PolygonGeometry extends PolylineGeometry { @Override public PolygonGeometry clone() { return (PolygonGeometry)super.clone(); } PolygonGeometry(PolygonGeometry.Builder<?> builder, PolygonRenderProperties renderProperties, Constraints constraints); protected PolygonGeometry(PolygonGeometry.Builder<?> builder, PolygonRenderProperties renderProperties, Constraints constraints, boolean smooth, LineType type); @Override PolygonGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override PolygonGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); Collection<? extends List<? extends Position>> getHoles(); @Override PolygonRenderProperties getRenderProperties(); @Override boolean jtsIntersectionTests(JTSIntersectionTests test, List<Polygon> polygons, GeometryFactory geomFactory); }### Answer: @Test public void testClone() { PolygonGeometry.Builder<GeographicPosition> builder = new PolygonGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setLineSmoothing(true); builder.setLineType(LineType.GREAT_CIRCLE); builder.setRapidUpdate(true); builder.setVertices(Arrays.asList(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.)), new GeographicPosition(LatLonAlt.createFromDegrees(35., 57.)))); PolygonRenderProperties renderProperties1 = new DefaultPolygonRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); PolygonGeometry geom = new PolygonGeometry(builder, renderProperties1, constraints1); PolygonGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.isLineSmoothing(), ((PolylineGeometry)clone).isLineSmoothing()); Assert.assertEquals(geom.getLineType(), ((PolylineGeometry)clone).getLineType()); Assert.assertEquals(geom.getVertices(), ((PolylineGeometry)clone).getVertices()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), clone.getConstraints()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); }
### Question: PolygonGeometry extends PolylineGeometry { @Override public PolygonGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new PolygonGeometry(createBuilder(), (PolygonRenderProperties)renderProperties, constraints); } PolygonGeometry(PolygonGeometry.Builder<?> builder, PolygonRenderProperties renderProperties, Constraints constraints); protected PolygonGeometry(PolygonGeometry.Builder<?> builder, PolygonRenderProperties renderProperties, Constraints constraints, boolean smooth, LineType type); @Override PolygonGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override PolygonGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); Collection<? extends List<? extends Position>> getHoles(); @Override PolygonRenderProperties getRenderProperties(); @Override boolean jtsIntersectionTests(JTSIntersectionTests test, List<Polygon> polygons, GeometryFactory geomFactory); }### Answer: @Test public void testDerive() { PolygonGeometry.Builder<GeographicPosition> builder = new PolygonGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setLineSmoothing(true); builder.setLineType(LineType.GREAT_CIRCLE); builder.setRapidUpdate(true); builder.setVertices(Arrays.asList(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.)), new GeographicPosition(LatLonAlt.createFromDegrees(35., 57.)))); PolygonRenderProperties renderProperties1 = new DefaultPolygonRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); PolygonGeometry geom = new PolygonGeometry(builder, renderProperties1, constraints1); AbstractRenderableGeometry absGeom = geom; ColorRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); AbstractRenderableGeometry derived = absGeom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.isLineSmoothing(), ((PolylineGeometry)derived).isLineSmoothing()); Assert.assertEquals(geom.getLineType(), ((PolylineGeometry)derived).getLineType()); Assert.assertEquals(geom.getVertices(), ((PolylineGeometry)derived).getVertices()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: PointSpriteGeometry extends PointGeometry implements ImageProvidingGeometry<PointSpriteGeometry> { @Override public PointSpriteGeometry clone() { return (PointSpriteGeometry)super.clone(); } PointSpriteGeometry(Builder<?> builder, PointRenderProperties renderProperties, Constraints constraints); @Override void addObserver(io.opensphere.core.geometry.ImageProvidingGeometry.Observer<PointSpriteGeometry> observer); @Override PointSpriteGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override PointSpriteGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); @Override DataRequestAgent getDataRequestAgent(); @Override ImageManager getImageManager(); @Override void removeObserver(io.opensphere.core.geometry.ImageProvidingGeometry.Observer<PointSpriteGeometry> observer); @Override final void requestImageData(); @Override final void requestImageData(Comparator<? super PointSpriteGeometry> comparator, TimeBudget timeBudget); @Override boolean sharesImage(); boolean isProjectionSensitive(); }### Answer: @Test public void testClone() { PointSpriteGeometry.Builder<GeographicPosition> builder = new PointSpriteGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); GeographicPosition position = new GeographicPosition(LatLonAlt.createFromDegrees(23., 56.)); builder.setPosition(position); builder.setImageManager(new ImageManager(null, null)); builder.setRapidUpdate(true); PointRenderProperties renderProperties1 = new DefaultPointRenderProperties(65763, false, true, false); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); PointSpriteGeometry geom = new PointSpriteGeometry(builder, renderProperties1, constraints1); PointSpriteGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.getImageManager(), clone.getImageManager()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), clone.getConstraints()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); }
### Question: PointSpriteGeometry extends PointGeometry implements ImageProvidingGeometry<PointSpriteGeometry> { @Override public PointSpriteGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new PointSpriteGeometry(createBuilder(), (PointRenderProperties)renderProperties, constraints); } PointSpriteGeometry(Builder<?> builder, PointRenderProperties renderProperties, Constraints constraints); @Override void addObserver(io.opensphere.core.geometry.ImageProvidingGeometry.Observer<PointSpriteGeometry> observer); @Override PointSpriteGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override PointSpriteGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); @Override DataRequestAgent getDataRequestAgent(); @Override ImageManager getImageManager(); @Override void removeObserver(io.opensphere.core.geometry.ImageProvidingGeometry.Observer<PointSpriteGeometry> observer); @Override final void requestImageData(); @Override final void requestImageData(Comparator<? super PointSpriteGeometry> comparator, TimeBudget timeBudget); @Override boolean sharesImage(); boolean isProjectionSensitive(); }### Answer: @Test public void testDerive() { PointSpriteGeometry.Builder<GeographicPosition> builder = new PointSpriteGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); GeographicPosition position = new GeographicPosition(LatLonAlt.createFromDegrees(23., 56.)); builder.setPosition(position); builder.setImageManager(new ImageManager(null, null)); builder.setRapidUpdate(true); PointRenderProperties renderProperties1 = new DefaultPointRenderProperties(65763, false, true, false); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); PointSpriteGeometry geom = new PointSpriteGeometry(builder, renderProperties1, constraints1); AbstractRenderableGeometry absGeom = geom; ColorRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); AbstractRenderableGeometry derived = absGeom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.getImageManager(), ((PointSpriteGeometry)derived).getImageManager()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: FrustumGeometry extends AbstractScalableMeshGeometry { @Override public FrustumGeometry clone() { return (FrustumGeometry)super.clone(); } FrustumGeometry(FrustumGeometry.Builder<?> builder, ScalableMeshRenderProperties renderProperties, Constraints constraints); @Override FrustumGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override FrustumGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); final float getBaseRadius(); final int getCircularPoints(); final float getTopRadius(); }### Answer: @Test public void testClone() { FrustumGeometry.Builder<GeographicPosition> builder = new FrustumGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); builder.setBaseRadius(.123f); builder.setTopRadius(.0321f); builder.setCircularPoints(13); builder.setPosition(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.))); ScalableMeshRenderProperties renderProperties1 = new DefaultMeshScalableRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); FrustumGeometry geom = new FrustumGeometry(builder, renderProperties1, constraints1); FrustumGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.getBaseRadius(), clone.getBaseRadius(), 0.f); Assert.assertEquals(geom.getTopRadius(), clone.getTopRadius(), 0.f); Assert.assertEquals(geom.getCircularPoints(), clone.getCircularPoints()); Assert.assertEquals(geom.getPolygonVertexCount(), clone.getPolygonVertexCount()); Assert.assertEquals(geom.getPosition(), clone.getPosition()); Assert.assertEquals(geom.getColors(), clone.getColors()); Assert.assertEquals(geom.getNormals(), clone.getNormals()); Assert.assertEquals(geom.getPositions(), clone.getPositions()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), clone.getConstraints()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); }
### Question: FrustumGeometry extends AbstractScalableMeshGeometry { @Override public FrustumGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new FrustumGeometry(createBuilder(), (ScalableMeshRenderProperties)renderProperties, constraints); } FrustumGeometry(FrustumGeometry.Builder<?> builder, ScalableMeshRenderProperties renderProperties, Constraints constraints); @Override FrustumGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override FrustumGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); final float getBaseRadius(); final int getCircularPoints(); final float getTopRadius(); }### Answer: @Test public void testDerive() { FrustumGeometry.Builder<GeographicPosition> builder = new FrustumGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); builder.setBaseRadius(.123f); builder.setTopRadius(.0321f); builder.setCircularPoints(13); builder.setPosition(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.))); ScalableMeshRenderProperties renderProperties1 = new DefaultMeshScalableRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); FrustumGeometry geom = new FrustumGeometry(builder, renderProperties1, constraints1); AbstractRenderableGeometry absGeom = geom; BaseRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); AbstractRenderableGeometry derived = absGeom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.getBaseRadius(), ((FrustumGeometry)derived).getBaseRadius(), 0.f); Assert.assertEquals(geom.getTopRadius(), ((FrustumGeometry)derived).getTopRadius(), 0.f); Assert.assertEquals(geom.getCircularPoints(), ((FrustumGeometry)derived).getCircularPoints()); Assert.assertEquals(geom.getPolygonVertexCount(), ((FrustumGeometry)derived).getPolygonVertexCount()); Assert.assertEquals(geom.getPosition(), ((FrustumGeometry)derived).getPosition()); Assert.assertEquals(geom.getColors(), ((FrustumGeometry)derived).getColors()); Assert.assertEquals(geom.getNormals(), ((FrustumGeometry)derived).getNormals()); Assert.assertEquals(geom.getPositions(), ((FrustumGeometry)derived).getPositions()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: CircularMeshGeometry extends PolygonMeshGeometry { @Override public CircularMeshGeometry clone() { return (CircularMeshGeometry)super.clone(); } CircularMeshGeometry(Builder<?> builder, PolygonMeshRenderProperties renderProperties, Constraints constraints); @Override CircularMeshGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override CircularMeshGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); Position getCenter(); double getRadius(); int getVertexCount(); double getWarpFactor(); }### Answer: @Test public void testClone() { CircularMeshGeometry.Builder<GeographicPosition> builder = new CircularMeshGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); builder.setNumVertices(13); builder.setRadius(.123f); builder.setWarpFactor(.0321); builder.setCenter(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.))); PolygonMeshRenderProperties renderProperties1 = new DefaultPolygonMeshRenderProperties(65763, true, true, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); CircularMeshGeometry geom = new CircularMeshGeometry(builder, renderProperties1, constraints1); CircularMeshGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.getRadius(), clone.getRadius(), 0.f); Assert.assertEquals(geom.getCenter(), clone.getCenter()); Assert.assertEquals(geom.getVertexCount(), clone.getVertexCount()); Assert.assertEquals(geom.getPolygonVertexCount(), clone.getPolygonVertexCount()); Assert.assertEquals(geom.getColors(), clone.getColors()); Assert.assertEquals(geom.getNormals(), clone.getNormals()); Assert.assertEquals(geom.getPositions(), clone.getPositions()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); }
### Question: CircularMeshGeometry extends PolygonMeshGeometry { @Override public CircularMeshGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new CircularMeshGeometry(createBuilder(), (PolygonMeshRenderProperties)renderProperties, constraints); } CircularMeshGeometry(Builder<?> builder, PolygonMeshRenderProperties renderProperties, Constraints constraints); @Override CircularMeshGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override CircularMeshGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); Position getCenter(); double getRadius(); int getVertexCount(); double getWarpFactor(); }### Answer: @Test public void testDerive() { CircularMeshGeometry.Builder<GeographicPosition> builder = new CircularMeshGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); builder.setNumVertices(13); builder.setRadius(.123f); builder.setWarpFactor(.0321); builder.setCenter(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.))); PolygonMeshRenderProperties renderProperties1 = new DefaultPolygonMeshRenderProperties(65763, true, true, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); CircularMeshGeometry geom = new CircularMeshGeometry(builder, renderProperties1, constraints1); AbstractRenderableGeometry absGeom = geom; ColorRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); AbstractRenderableGeometry derived = absGeom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.getRadius(), ((CircularMeshGeometry)derived).getRadius(), 0.f); Assert.assertEquals(geom.getCenter(), ((CircularMeshGeometry)derived).getCenter()); Assert.assertEquals(geom.getVertexCount(), ((CircularMeshGeometry)derived).getVertexCount()); Assert.assertEquals(geom.getPolygonVertexCount(), ((CircularMeshGeometry)derived).getPolygonVertexCount()); Assert.assertEquals(geom.getColors(), ((CircularMeshGeometry)derived).getColors()); Assert.assertEquals(geom.getNormals(), ((CircularMeshGeometry)derived).getNormals()); Assert.assertEquals(geom.getPositions(), ((CircularMeshGeometry)derived).getPositions()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: EllipsoidGeometry extends PolygonMeshGeometry { @Override public EllipsoidGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new EllipsoidGeometry(myBuilder, (PolygonMeshRenderProperties)renderProperties, constraints); } EllipsoidGeometry(EllipsoidGeometryBuilder<? extends Position> builder, PolygonMeshRenderProperties renderProperties, Constraints constraints); @Override EllipsoidGeometry clone(); @Override EllipsoidGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); void handleProjectionChanged(); }### Answer: @Test public void testDerive() { EasyMockSupport support = new EasyMockSupport(); MapManager mapManager = EllipsoidTestUtils.createMapManager(support); EasyMock.expectLastCall().times(2); support.replayAll(); EllipsoidGeometryBuilder<GeographicPosition> builder = new EllipsoidGeometryBuilder<>(mapManager); builder.setAxisAMeters(EllipsoidTestUtils.AXIS_A); builder.setAxisBMeters(EllipsoidTestUtils.AXIS_B); builder.setAxisCMeters(EllipsoidTestUtils.AXIS_C); builder.setQuality(EllipsoidTestUtils.QUALITY); builder.setColor(Color.RED); LatLonAlt location = LatLonAlt.createFromDegreesMeters(10, 11, 5280, ReferenceLevel.TERRAIN); builder.setLocation(new GeographicPosition(location)); builder.setHeading(14); builder.setPitch(15); builder.setRoll(16); builder.setDataModelId(76); List<List<Position>> expectedPositions = EllipsoidTestUtils.getExpectedPositions(); List<Position> combinedExpected = New.list(); for (List<Position> strip : expectedPositions) { combinedExpected.addAll(strip); } DefaultPolygonMeshRenderProperties renderProperties = new DefaultPolygonMeshRenderProperties(0, true, true, false); Constraints constraints = Constraints.createTimeOnlyConstraint(TimeSpan.get()); EllipsoidGeometry first = new EllipsoidGeometry(builder, renderProperties, constraints); EllipsoidGeometry geometry = first.derive(renderProperties, constraints); assertNotSame(first, geometry); List<? extends Color> colors = geometry.getColors(); assertEquals(combinedExpected.size(), colors.size()); for (Color color : colors) { assertEquals(Color.RED, color); } assertEquals(AbstractRenderer.TRIANGLE_STRIP_VERTEX_COUNT, geometry.getPolygonVertexCount()); List<? extends Position> positions = geometry.getPositions(); assertEquals(combinedExpected.size(), positions.size()); int index = 0; for (Position position : positions) { assertEquals(combinedExpected.get(index).asVector3d(), position.asVector3d()); index++; } List<Vector3d> expectedNormals = EllipsoidTestUtils.calculateExpectedNormals(expectedPositions); assertEquals(combinedExpected.size(), expectedNormals.size()); List<? extends Vector3d> actualNormals = geometry.getNormals(); assertEquals(combinedExpected.size(), actualNormals.size()); assertEquals(expectedNormals, actualNormals); Matrix4d transform = geometry.getRenderProperties().getTransform(); Matrix4d expected = new Matrix4d(new double[] { -0.5187182308412952, 0.8122809550672292, -.26670404389125235, 0.0, -0.8501440620567355, -0.45705076232245867, 0.2614568308729626, 0.0, 0.0904791177153618, 0.36235928399246203, 0.9276363935087497, 0.0, 11.0, 10.0, 5280.0, 1.0 }); assertEquals(expected, transform); assertEquals(76, geometry.getDataModelId()); support.verifyAll(); }
### Question: PointSetGeometry extends AbstractColorGeometry implements PointRenderPropertiesGeometry { @Override public PointSetGeometry clone() { return (PointSetGeometry)super.clone(); } PointSetGeometry(PointSetGeometry.Builder<?> builder, PointRenderProperties renderProperties, Constraints constraints); @Override PointSetGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override PointSetGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); List<? extends Color> getColors(); final List<? extends Position> getPositions(); @Override Class<? extends Position> getPositionType(); @Override Position getReferencePoint(); @Override PointRenderProperties getRenderProperties(); @Override boolean jtsIntersectionTests(JTSIntersectionTests test, List<Polygon> polygons, GeometryFactory geomFactory); @Override boolean overlaps(BoundingBox<T> boundingBox, double tolerance); @Override String toString(); }### Answer: @Test public void testClone() { PointSetGeometry.Builder<GeographicPosition> builder = new PointSetGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); List<GeographicPosition> positions = new ArrayList<>(); positions.add(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.))); positions.add(new GeographicPosition(LatLonAlt.createFromDegrees(35., 55.))); positions.add(new GeographicPosition(LatLonAlt.createFromDegrees(36., 54.))); List<Color> colors = new ArrayList<>(); colors.add(Color.BLACK); colors.add(Color.BLUE); colors.add(Color.GRAY); builder.setPositions(positions); builder.setColors(colors); PointRenderProperties renderProperties1 = new DefaultPointRenderProperties(65763, false, true, true); PointSetGeometry geom = new PointSetGeometry(builder, renderProperties1, null); PointSetGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getPositions(), clone.getPositions()); Assert.assertEquals(geom.getColors(), clone.getColors()); Assert.assertEquals(geom.getPositionType(), clone.getPositionType()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); }
### Question: PointSetGeometry extends AbstractColorGeometry implements PointRenderPropertiesGeometry { @Override public PointSetGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new PointSetGeometry(createBuilder(), (PointRenderProperties)renderProperties, constraints); } PointSetGeometry(PointSetGeometry.Builder<?> builder, PointRenderProperties renderProperties, Constraints constraints); @Override PointSetGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override PointSetGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); List<? extends Color> getColors(); final List<? extends Position> getPositions(); @Override Class<? extends Position> getPositionType(); @Override Position getReferencePoint(); @Override PointRenderProperties getRenderProperties(); @Override boolean jtsIntersectionTests(JTSIntersectionTests test, List<Polygon> polygons, GeometryFactory geomFactory); @Override boolean overlaps(BoundingBox<T> boundingBox, double tolerance); @Override String toString(); }### Answer: @Test public void testDerive() { PointSetGeometry.Builder<GeographicPosition> builder = new PointSetGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); List<GeographicPosition> positions = new ArrayList<>(); positions.add(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.))); positions.add(new GeographicPosition(LatLonAlt.createFromDegrees(35., 55.))); positions.add(new GeographicPosition(LatLonAlt.createFromDegrees(36., 54.))); List<Color> colors = new ArrayList<>(); colors.add(Color.BLACK); colors.add(Color.BLUE); colors.add(Color.GRAY); builder.setPositions(positions); builder.setColors(colors); PointRenderProperties renderProperties1 = new DefaultPointRenderProperties(65763, false, true, true); PointSetGeometry geom = new PointSetGeometry(builder, renderProperties1, null); AbstractRenderableGeometry absGeom = geom; BaseRenderProperties renderProperties2 = renderProperties1.clone(); PointSetGeometry derived = (PointSetGeometry)absGeom.derive(renderProperties2, null); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertEquals(geom.getPositions(), derived.getPositions()); Assert.assertEquals(geom.getColors(), derived.getColors()); Assert.assertEquals(geom.getPositionType(), derived.getPositionType()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); }
### Question: TriangleScalableGeometry extends AbstractScalableMeshGeometry { @Override public TriangleScalableGeometry clone() { return (TriangleScalableGeometry)super.clone(); } TriangleScalableGeometry(AbstractScalableGeometry.Builder<?> builder, ScalableMeshRenderProperties renderProperties, Constraints constraints); @Override TriangleScalableGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override TriangleScalableGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); }### Answer: @Test public void testClone() { TriangleScalableGeometry.Builder<GeographicPosition> builder = new TriangleScalableGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); builder.setPosition(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.))); ScalableMeshRenderProperties renderProperties1 = new DefaultMeshScalableRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); TriangleScalableGeometry geom = new TriangleScalableGeometry(builder, renderProperties1, constraints1); TriangleScalableGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getPolygonVertexCount(), clone.getPolygonVertexCount()); Assert.assertEquals(geom.getPosition(), clone.getPosition()); Assert.assertEquals(geom.getColors(), clone.getColors()); Assert.assertEquals(geom.getNormals(), clone.getNormals()); Assert.assertEquals(geom.getPositions(), clone.getPositions()); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), clone.getConstraints()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); }
### Question: TriangleScalableGeometry extends AbstractScalableMeshGeometry { @Override public TriangleScalableGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new TriangleScalableGeometry(createBuilder(), (ScalableMeshRenderProperties)renderProperties, constraints); } TriangleScalableGeometry(AbstractScalableGeometry.Builder<?> builder, ScalableMeshRenderProperties renderProperties, Constraints constraints); @Override TriangleScalableGeometry clone(); @Override Builder<? extends Position> createBuilder(); @Override TriangleScalableGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); }### Answer: @Test public void testDerive() { TriangleScalableGeometry.Builder<GeographicPosition> builder = new TriangleScalableGeometry.Builder<GeographicPosition>(); builder.setDataModelId(3423L); builder.setRapidUpdate(true); builder.setPosition(new GeographicPosition(LatLonAlt.createFromDegrees(34., 56.))); ScalableMeshRenderProperties renderProperties1 = new DefaultMeshScalableRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); TriangleScalableGeometry geom = new TriangleScalableGeometry(builder, renderProperties1, constraints1); AbstractRenderableGeometry absGeom = geom; BaseRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); AbstractRenderableGeometry derived = absGeom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.getRenderProperties(), ((TriangleScalableGeometry)derived).getRenderProperties()); Assert.assertEquals(geom.getPolygonVertexCount(), ((TriangleScalableGeometry)derived).getPolygonVertexCount()); Assert.assertEquals(geom.getPosition(), ((TriangleScalableGeometry)derived).getPosition()); Assert.assertEquals(geom.getColors(), ((TriangleScalableGeometry)derived).getColors()); Assert.assertEquals(geom.getNormals(), ((TriangleScalableGeometry)derived).getNormals()); Assert.assertEquals(geom.getPositions(), ((TriangleScalableGeometry)derived).getPositions()); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: GeoScreenBubbleGeometry extends GeoScreenPolygonGeometry { @Override public GeoScreenBubbleGeometry clone() { return (GeoScreenBubbleGeometry)super.clone(); } GeoScreenBubbleGeometry(Builder builder, PolygonRenderProperties renderProperties, Constraints constraints); @Override GeoScreenBubbleGeometry clone(); @Override Builder createBuilder(); @Override GeoScreenBubbleGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); final double getBorderBuffer(); final GeoScreenBoundingBox getBoundingBox(); final double getCornerRadius(); final int getCornerVertexCount(); final double getGapPercent(); }### Answer: @Test public void testClone() { GeographicPosition position = new GeographicPosition(LatLonAlt.createFromDegrees(23., 56.)); GeographicBoxAnchor gba = new GeographicBoxAnchor(position, null, 0, 0); ScreenPosition sPos1 = new ScreenPosition(0, 0); ScreenPosition sPos2 = new ScreenPosition(15, 15); GeoScreenBoundingBox gsbb = new GeoScreenBoundingBox(sPos1, sPos2, gba); GeoScreenBubbleGeometry.Builder builder = new GeoScreenBubbleGeometry.Builder(); builder.setBoundingBox(gsbb); builder.setDataModelId(3423L); builder.setAttachment(position); builder.setBorderBuffer(3.); builder.setCornerRadius(.75); builder.setCornerVertexCount(5); builder.setGapPercent(15); builder.setLineSmoothing(true); builder.setLineType(LineType.GREAT_CIRCLE); builder.setRapidUpdate(true); PolygonRenderProperties renderProperties1 = new DefaultPolygonRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); GeoScreenBubbleGeometry geom = new GeoScreenBubbleGeometry(builder, renderProperties1, constraints1); GeoScreenBubbleGeometry clone = geom.clone(); Assert.assertNotSame(geom, clone); Assert.assertEquals(geom.getBoundingBox(), clone.getBoundingBox()); Assert.assertEquals(geom.getDataModelId(), clone.getDataModelId()); Assert.assertEquals(geom.isLineSmoothing(), clone.isLineSmoothing()); Assert.assertEquals(geom.getLineType(), clone.getLineType()); Assert.assertEquals(geom.getAttachment(), clone.getAttachment()); Assert.assertEquals(geom.getBorderBuffer(), clone.getBorderBuffer(), 0.); Assert.assertEquals(geom.getCornerRadius(), clone.getCornerRadius(), 0.); Assert.assertEquals(geom.getCornerVertexCount(), clone.getCornerVertexCount()); Assert.assertEquals(geom.getGapPercent(), clone.getGapPercent(), 0.); Assert.assertEquals(geom.isRapidUpdate(), clone.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertEquals(geom.getRenderProperties(), clone.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), clone.getConstraints()); Assert.assertEquals(geom.getConstraints(), clone.getConstraints()); }
### Question: GeoScreenBubbleGeometry extends GeoScreenPolygonGeometry { @Override public GeoScreenBubbleGeometry derive(BaseRenderProperties renderProperties, Constraints constraints) throws ClassCastException { return new GeoScreenBubbleGeometry(createBuilder(), (PolygonRenderProperties)renderProperties, constraints); } GeoScreenBubbleGeometry(Builder builder, PolygonRenderProperties renderProperties, Constraints constraints); @Override GeoScreenBubbleGeometry clone(); @Override Builder createBuilder(); @Override GeoScreenBubbleGeometry derive(BaseRenderProperties renderProperties, Constraints constraints); final double getBorderBuffer(); final GeoScreenBoundingBox getBoundingBox(); final double getCornerRadius(); final int getCornerVertexCount(); final double getGapPercent(); }### Answer: @Test public void testDerive() { GeographicPosition position = new GeographicPosition(LatLonAlt.createFromDegrees(23., 56.)); GeographicBoxAnchor gba = new GeographicBoxAnchor(position, null, 0, 0); ScreenPosition sPos1 = new ScreenPosition(0, 0); ScreenPosition sPos2 = new ScreenPosition(15, 15); GeoScreenBoundingBox gsbb = new GeoScreenBoundingBox(sPos1, sPos2, gba); GeoScreenBubbleGeometry.Builder builder = new GeoScreenBubbleGeometry.Builder(); builder.setBoundingBox(gsbb); builder.setDataModelId(3423L); builder.setAttachment(position); builder.setBorderBuffer(3.); builder.setCornerRadius(.75); builder.setCornerVertexCount(5); builder.setGapPercent(15); builder.setLineSmoothing(true); builder.setLineType(LineType.GREAT_CIRCLE); builder.setRapidUpdate(true); PolygonRenderProperties renderProperties1 = new DefaultPolygonRenderProperties(65763, false, true); TimeConstraint timeConstraint = TimeConstraint.getTimeConstraint(TimeSpan.get(10L, 20L)); Constraints constraints1 = new Constraints(timeConstraint); GeoScreenBubbleGeometry geom = new GeoScreenBubbleGeometry(builder, renderProperties1, constraints1); ColorRenderProperties renderProperties2 = renderProperties1.clone(); Constraints constraints2 = new Constraints(timeConstraint); GeoScreenBubbleGeometry derived = geom.derive(renderProperties2, constraints2); Assert.assertNotSame(geom, derived); Assert.assertEquals(geom.getBoundingBox(), derived.getBoundingBox()); Assert.assertEquals(geom.getDataModelId(), derived.getDataModelId()); Assert.assertEquals(geom.isLineSmoothing(), derived.isLineSmoothing()); Assert.assertEquals(geom.getLineType(), derived.getLineType()); Assert.assertEquals(geom.getAttachment(), derived.getAttachment()); Assert.assertEquals(geom.getBorderBuffer(), derived.getBorderBuffer(), 0.); Assert.assertEquals(geom.getCornerRadius(), derived.getCornerRadius(), 0.); Assert.assertEquals(geom.getCornerVertexCount(), derived.getCornerVertexCount()); Assert.assertEquals(geom.getGapPercent(), derived.getGapPercent(), 0.); Assert.assertEquals(geom.isRapidUpdate(), derived.isRapidUpdate()); Assert.assertNotSame(geom.getRenderProperties(), derived.getRenderProperties()); Assert.assertSame(renderProperties2, derived.getRenderProperties()); Assert.assertNotSame(geom.getConstraints(), derived.getConstraints()); Assert.assertSame(constraints2, derived.getConstraints()); }
### Question: EllipsoidNormalsGenerator { public List<List<Vector3d>> calculateNormals(List<List<Position>> positions) { List<List<Vector3d>> normals = New.list(); for (List<? extends Position> triangleStrip : positions) { List<Vector3d> stripsNormals = New.list(); for (Position position : triangleStrip) { stripsNormals.add(position.asVector3d().getNormalized()); } normals.add(stripsNormals); } return normals; } List<List<Vector3d>> calculateNormals(List<List<Position>> positions); }### Answer: @Test public void test() { List<List<Position>> positions = New.list(); List<Position> strip1 = New.list(new ModelPosition(0, 0, 0), new ModelPosition(1, 0, 0), new ModelPosition(1, 1, 0)); List<Position> strip2 = New.list(new ModelPosition(0, 0, 1), new ModelPosition(1, 0, 1), new ModelPosition(1, 1, 1)); positions.add(strip1); positions.add(strip2); List<Vector3d> expectedNormals1 = New.list(strip1.get(0).asVector3d().getNormalized(), strip1.get(1).asVector3d().getNormalized(), strip1.get(2).asVector3d().getNormalized()); List<Vector3d> expectedNormals2 = New.list(strip2.get(0).asVector3d().getNormalized(), strip2.get(1).asVector3d().getNormalized(), strip2.get(2).asVector3d().getNormalized()); EllipsoidNormalsGenerator normalsGenerator = new EllipsoidNormalsGenerator(); List<List<Vector3d>> normals = normalsGenerator.calculateNormals(positions); assertEquals(2, normals.size()); assertEquals(expectedNormals1, normals.get(0)); assertEquals(expectedNormals2, normals.get(1)); }
### Question: ProxyTileRenderProperties implements TileRenderProperties { @Override public void opacitizeColor(float opacity) { myCloned.opacitizeColor(opacity); myOriginal.notifyChanged(); } ProxyTileRenderProperties(DefaultTileRenderProperties renderProperties); @Override void addListener(RenderPropertyChangeListener listen); @Override ProxyTileRenderProperties clone(); @Override BlendingConfigGL getBlending(); @Override Color getColor(); @Override int getColorARGB(); @Override Color getHighlightColor(); @Override int getHighlightColorARGB(); @Override LightingModelConfigGL getLighting(); @Override float getOpacity(); @Override int getRenderingOrder(); @Override FragmentShaderProperties getShaderProperties(); @Override Collection<? extends RenderProperties> getThisPlusDescendants(); @Override int getZOrder(); @Override boolean isDrawable(); @Override boolean isHidden(); @Override boolean isObscurant(); @Override boolean isPickable(); @Override void opacitizeColor(float opacity); @Override void removeListener(RenderPropertyChangeListener listen); @Override void resetShaderPropertiesToDefault(); @Override void setBlending(BlendingConfigGL blend); @Override void setColor(Color color); @Override void setColorARGB(int color); @Override void setHidden(boolean hidden); @Override void setHighlightColor(Color color); @Override void setHighlightColorARGB(int color); @Override void setLighting(LightingModelConfigGL lighting); @Override void setObscurant(boolean obscurant); @Override void setOpacity(float opacity); @Override void setRenderingOrder(int order); }### Answer: @Test public void testOpacitizeColor() { EasyMockSupport support = new EasyMockSupport(); RenderPropertyChangeListener listener = createListener(support); DefaultTileRenderProperties props = new DefaultTileRenderProperties(10, true, true); props.setOpacity(.9f); props.addListener(listener); support.replayAll(); ProxyTileRenderProperties proxyProps = new ProxyTileRenderProperties(props); assertEquals(10, proxyProps.getZOrder()); assertTrue(proxyProps.isDrawable()); assertTrue(proxyProps.isPickable()); assertEquals(230f, proxyProps.getOpacity(), 0f); proxyProps.opacitizeColor(.5f); assertEquals(128f, proxyProps.getOpacity(), 0f); assertEquals(230f, props.getOpacity(), 0f); support.verifyAll(); }
### Question: ProxyTileRenderProperties implements TileRenderProperties { @Override public void setBlending(BlendingConfigGL blend) { myCloned.setBlending(blend); myOriginal.notifyChanged(); } ProxyTileRenderProperties(DefaultTileRenderProperties renderProperties); @Override void addListener(RenderPropertyChangeListener listen); @Override ProxyTileRenderProperties clone(); @Override BlendingConfigGL getBlending(); @Override Color getColor(); @Override int getColorARGB(); @Override Color getHighlightColor(); @Override int getHighlightColorARGB(); @Override LightingModelConfigGL getLighting(); @Override float getOpacity(); @Override int getRenderingOrder(); @Override FragmentShaderProperties getShaderProperties(); @Override Collection<? extends RenderProperties> getThisPlusDescendants(); @Override int getZOrder(); @Override boolean isDrawable(); @Override boolean isHidden(); @Override boolean isObscurant(); @Override boolean isPickable(); @Override void opacitizeColor(float opacity); @Override void removeListener(RenderPropertyChangeListener listen); @Override void resetShaderPropertiesToDefault(); @Override void setBlending(BlendingConfigGL blend); @Override void setColor(Color color); @Override void setColorARGB(int color); @Override void setHidden(boolean hidden); @Override void setHighlightColor(Color color); @Override void setHighlightColorARGB(int color); @Override void setLighting(LightingModelConfigGL lighting); @Override void setObscurant(boolean obscurant); @Override void setOpacity(float opacity); @Override void setRenderingOrder(int order); }### Answer: @Test public void testSetBlending() { EasyMockSupport support = new EasyMockSupport(); RenderPropertyChangeListener listener = createListener(support); DefaultTileRenderProperties props = new DefaultTileRenderProperties(10, true, true); props.setBlending(BlendingConfigGL.getDefaultBlending()); props.addListener(listener); support.replayAll(); ProxyTileRenderProperties proxyProps = new ProxyTileRenderProperties(props); assertEquals(BlendingConfigGL.getDefaultBlending(), proxyProps.getBlending()); proxyProps.setBlending(null); assertEquals(null, proxyProps.getBlending()); assertEquals(BlendingConfigGL.getDefaultBlending(), props.getBlending()); support.verifyAll(); }
### Question: ProxyTileRenderProperties implements TileRenderProperties { @Override public void setColor(Color color) { myCloned.setColor(color); myOriginal.notifyChanged(); } ProxyTileRenderProperties(DefaultTileRenderProperties renderProperties); @Override void addListener(RenderPropertyChangeListener listen); @Override ProxyTileRenderProperties clone(); @Override BlendingConfigGL getBlending(); @Override Color getColor(); @Override int getColorARGB(); @Override Color getHighlightColor(); @Override int getHighlightColorARGB(); @Override LightingModelConfigGL getLighting(); @Override float getOpacity(); @Override int getRenderingOrder(); @Override FragmentShaderProperties getShaderProperties(); @Override Collection<? extends RenderProperties> getThisPlusDescendants(); @Override int getZOrder(); @Override boolean isDrawable(); @Override boolean isHidden(); @Override boolean isObscurant(); @Override boolean isPickable(); @Override void opacitizeColor(float opacity); @Override void removeListener(RenderPropertyChangeListener listen); @Override void resetShaderPropertiesToDefault(); @Override void setBlending(BlendingConfigGL blend); @Override void setColor(Color color); @Override void setColorARGB(int color); @Override void setHidden(boolean hidden); @Override void setHighlightColor(Color color); @Override void setHighlightColorARGB(int color); @Override void setLighting(LightingModelConfigGL lighting); @Override void setObscurant(boolean obscurant); @Override void setOpacity(float opacity); @Override void setRenderingOrder(int order); }### Answer: @Test public void testSetColor() { EasyMockSupport support = new EasyMockSupport(); RenderPropertyChangeListener listener = createListener(support); DefaultTileRenderProperties props = new DefaultTileRenderProperties(10, true, true); props.setColor(Color.RED); props.addListener(listener); support.replayAll(); ProxyTileRenderProperties proxyProps = new ProxyTileRenderProperties(props); assertEquals(Color.RED, proxyProps.getColor()); proxyProps.setColor(Color.BLUE); assertEquals(Color.BLUE, proxyProps.getColor()); assertEquals(Color.RED, props.getColor()); support.verifyAll(); }
### Question: ProxyTileRenderProperties implements TileRenderProperties { @Override public void setColorARGB(int color) { myCloned.setColorARGB(color); myOriginal.notifyChanged(); } ProxyTileRenderProperties(DefaultTileRenderProperties renderProperties); @Override void addListener(RenderPropertyChangeListener listen); @Override ProxyTileRenderProperties clone(); @Override BlendingConfigGL getBlending(); @Override Color getColor(); @Override int getColorARGB(); @Override Color getHighlightColor(); @Override int getHighlightColorARGB(); @Override LightingModelConfigGL getLighting(); @Override float getOpacity(); @Override int getRenderingOrder(); @Override FragmentShaderProperties getShaderProperties(); @Override Collection<? extends RenderProperties> getThisPlusDescendants(); @Override int getZOrder(); @Override boolean isDrawable(); @Override boolean isHidden(); @Override boolean isObscurant(); @Override boolean isPickable(); @Override void opacitizeColor(float opacity); @Override void removeListener(RenderPropertyChangeListener listen); @Override void resetShaderPropertiesToDefault(); @Override void setBlending(BlendingConfigGL blend); @Override void setColor(Color color); @Override void setColorARGB(int color); @Override void setHidden(boolean hidden); @Override void setHighlightColor(Color color); @Override void setHighlightColorARGB(int color); @Override void setLighting(LightingModelConfigGL lighting); @Override void setObscurant(boolean obscurant); @Override void setOpacity(float opacity); @Override void setRenderingOrder(int order); }### Answer: @Test public void testSetColorARGB() { EasyMockSupport support = new EasyMockSupport(); RenderPropertyChangeListener listener = createListener(support); DefaultTileRenderProperties props = new DefaultTileRenderProperties(10, true, true); props.setColorARGB(2); props.addListener(listener); support.replayAll(); ProxyTileRenderProperties proxyProps = new ProxyTileRenderProperties(props); assertEquals(2, proxyProps.getColorARGB()); proxyProps.setColorARGB(4); assertEquals(4, proxyProps.getColorARGB()); assertEquals(2, props.getColorARGB()); support.verifyAll(); }
### Question: ProxyTileRenderProperties implements TileRenderProperties { @Override public void setHidden(boolean hidden) { myOriginal.setHidden(hidden); } ProxyTileRenderProperties(DefaultTileRenderProperties renderProperties); @Override void addListener(RenderPropertyChangeListener listen); @Override ProxyTileRenderProperties clone(); @Override BlendingConfigGL getBlending(); @Override Color getColor(); @Override int getColorARGB(); @Override Color getHighlightColor(); @Override int getHighlightColorARGB(); @Override LightingModelConfigGL getLighting(); @Override float getOpacity(); @Override int getRenderingOrder(); @Override FragmentShaderProperties getShaderProperties(); @Override Collection<? extends RenderProperties> getThisPlusDescendants(); @Override int getZOrder(); @Override boolean isDrawable(); @Override boolean isHidden(); @Override boolean isObscurant(); @Override boolean isPickable(); @Override void opacitizeColor(float opacity); @Override void removeListener(RenderPropertyChangeListener listen); @Override void resetShaderPropertiesToDefault(); @Override void setBlending(BlendingConfigGL blend); @Override void setColor(Color color); @Override void setColorARGB(int color); @Override void setHidden(boolean hidden); @Override void setHighlightColor(Color color); @Override void setHighlightColorARGB(int color); @Override void setLighting(LightingModelConfigGL lighting); @Override void setObscurant(boolean obscurant); @Override void setOpacity(float opacity); @Override void setRenderingOrder(int order); }### Answer: @Test public void testSetHidden() { EasyMockSupport support = new EasyMockSupport(); RenderPropertyChangeListener listener = createListener(support); EasyMock.expectLastCall().times(2); DefaultTileRenderProperties props = new DefaultTileRenderProperties(10, true, true); props.setHidden(true); props.addListener(listener); support.replayAll(); ProxyTileRenderProperties proxyProps = new ProxyTileRenderProperties(props); assertTrue(proxyProps.isHidden()); proxyProps.setHidden(false); assertFalse(proxyProps.isHidden()); assertFalse(props.isHidden()); props.setHidden(true); assertTrue(proxyProps.isHidden()); support.verifyAll(); }
### Question: ProxyTileRenderProperties implements TileRenderProperties { @Override public void setHighlightColor(Color color) { myCloned.setHighlightColor(color); myOriginal.notifyChanged(); } ProxyTileRenderProperties(DefaultTileRenderProperties renderProperties); @Override void addListener(RenderPropertyChangeListener listen); @Override ProxyTileRenderProperties clone(); @Override BlendingConfigGL getBlending(); @Override Color getColor(); @Override int getColorARGB(); @Override Color getHighlightColor(); @Override int getHighlightColorARGB(); @Override LightingModelConfigGL getLighting(); @Override float getOpacity(); @Override int getRenderingOrder(); @Override FragmentShaderProperties getShaderProperties(); @Override Collection<? extends RenderProperties> getThisPlusDescendants(); @Override int getZOrder(); @Override boolean isDrawable(); @Override boolean isHidden(); @Override boolean isObscurant(); @Override boolean isPickable(); @Override void opacitizeColor(float opacity); @Override void removeListener(RenderPropertyChangeListener listen); @Override void resetShaderPropertiesToDefault(); @Override void setBlending(BlendingConfigGL blend); @Override void setColor(Color color); @Override void setColorARGB(int color); @Override void setHidden(boolean hidden); @Override void setHighlightColor(Color color); @Override void setHighlightColorARGB(int color); @Override void setLighting(LightingModelConfigGL lighting); @Override void setObscurant(boolean obscurant); @Override void setOpacity(float opacity); @Override void setRenderingOrder(int order); }### Answer: @Test public void testSetHighlightColor() { EasyMockSupport support = new EasyMockSupport(); RenderPropertyChangeListener listener = createListener(support); DefaultTileRenderProperties props = new DefaultTileRenderProperties(10, true, true); props.setHighlightColor(Color.RED); props.addListener(listener); support.replayAll(); ProxyTileRenderProperties proxyProps = new ProxyTileRenderProperties(props); assertEquals(Color.RED, proxyProps.getHighlightColor()); proxyProps.setHighlightColor(Color.BLUE); assertEquals(Color.BLUE, proxyProps.getHighlightColor()); assertEquals(Color.RED, props.getHighlightColor()); support.verifyAll(); }
### Question: ProxyTileRenderProperties implements TileRenderProperties { @Override public void setHighlightColorARGB(int color) { myCloned.setHighlightColorARGB(color); myOriginal.notifyChanged(); } ProxyTileRenderProperties(DefaultTileRenderProperties renderProperties); @Override void addListener(RenderPropertyChangeListener listen); @Override ProxyTileRenderProperties clone(); @Override BlendingConfigGL getBlending(); @Override Color getColor(); @Override int getColorARGB(); @Override Color getHighlightColor(); @Override int getHighlightColorARGB(); @Override LightingModelConfigGL getLighting(); @Override float getOpacity(); @Override int getRenderingOrder(); @Override FragmentShaderProperties getShaderProperties(); @Override Collection<? extends RenderProperties> getThisPlusDescendants(); @Override int getZOrder(); @Override boolean isDrawable(); @Override boolean isHidden(); @Override boolean isObscurant(); @Override boolean isPickable(); @Override void opacitizeColor(float opacity); @Override void removeListener(RenderPropertyChangeListener listen); @Override void resetShaderPropertiesToDefault(); @Override void setBlending(BlendingConfigGL blend); @Override void setColor(Color color); @Override void setColorARGB(int color); @Override void setHidden(boolean hidden); @Override void setHighlightColor(Color color); @Override void setHighlightColorARGB(int color); @Override void setLighting(LightingModelConfigGL lighting); @Override void setObscurant(boolean obscurant); @Override void setOpacity(float opacity); @Override void setRenderingOrder(int order); }### Answer: @Test public void testSetHighlightColorARGB() { EasyMockSupport support = new EasyMockSupport(); RenderPropertyChangeListener listener = createListener(support); DefaultTileRenderProperties props = new DefaultTileRenderProperties(10, true, true); props.setHighlightColorARGB(2); props.addListener(listener); support.replayAll(); ProxyTileRenderProperties proxyProps = new ProxyTileRenderProperties(props); assertEquals(2, proxyProps.getHighlightColorARGB()); proxyProps.setHighlightColorARGB(4); assertEquals(4, proxyProps.getHighlightColorARGB()); assertEquals(2, props.getHighlightColorARGB()); support.verifyAll(); }
### Question: ProxyTileRenderProperties implements TileRenderProperties { @Override public void setLighting(LightingModelConfigGL lighting) { myCloned.setLighting(lighting); myOriginal.notifyChanged(); } ProxyTileRenderProperties(DefaultTileRenderProperties renderProperties); @Override void addListener(RenderPropertyChangeListener listen); @Override ProxyTileRenderProperties clone(); @Override BlendingConfigGL getBlending(); @Override Color getColor(); @Override int getColorARGB(); @Override Color getHighlightColor(); @Override int getHighlightColorARGB(); @Override LightingModelConfigGL getLighting(); @Override float getOpacity(); @Override int getRenderingOrder(); @Override FragmentShaderProperties getShaderProperties(); @Override Collection<? extends RenderProperties> getThisPlusDescendants(); @Override int getZOrder(); @Override boolean isDrawable(); @Override boolean isHidden(); @Override boolean isObscurant(); @Override boolean isPickable(); @Override void opacitizeColor(float opacity); @Override void removeListener(RenderPropertyChangeListener listen); @Override void resetShaderPropertiesToDefault(); @Override void setBlending(BlendingConfigGL blend); @Override void setColor(Color color); @Override void setColorARGB(int color); @Override void setHidden(boolean hidden); @Override void setHighlightColor(Color color); @Override void setHighlightColorARGB(int color); @Override void setLighting(LightingModelConfigGL lighting); @Override void setObscurant(boolean obscurant); @Override void setOpacity(float opacity); @Override void setRenderingOrder(int order); }### Answer: @Test public void testSetLighting() { EasyMockSupport support = new EasyMockSupport(); RenderPropertyChangeListener listener = createListener(support); DefaultTileRenderProperties props = new DefaultTileRenderProperties(10, true, true); props.setLighting(LightingModelConfigGL.getDefaultLight()); props.addListener(listener); support.replayAll(); ProxyTileRenderProperties proxyProps = new ProxyTileRenderProperties(props); assertEquals(LightingModelConfigGL.getDefaultLight(), proxyProps.getLighting()); proxyProps.setLighting(null); assertEquals(null, proxyProps.getLighting()); assertEquals(LightingModelConfigGL.getDefaultLight(), props.getLighting()); support.verifyAll(); }
### Question: ProxyTileRenderProperties implements TileRenderProperties { @Override public void setObscurant(boolean obscurant) { myCloned.setObscurant(obscurant); myOriginal.notifyChanged(); } ProxyTileRenderProperties(DefaultTileRenderProperties renderProperties); @Override void addListener(RenderPropertyChangeListener listen); @Override ProxyTileRenderProperties clone(); @Override BlendingConfigGL getBlending(); @Override Color getColor(); @Override int getColorARGB(); @Override Color getHighlightColor(); @Override int getHighlightColorARGB(); @Override LightingModelConfigGL getLighting(); @Override float getOpacity(); @Override int getRenderingOrder(); @Override FragmentShaderProperties getShaderProperties(); @Override Collection<? extends RenderProperties> getThisPlusDescendants(); @Override int getZOrder(); @Override boolean isDrawable(); @Override boolean isHidden(); @Override boolean isObscurant(); @Override boolean isPickable(); @Override void opacitizeColor(float opacity); @Override void removeListener(RenderPropertyChangeListener listen); @Override void resetShaderPropertiesToDefault(); @Override void setBlending(BlendingConfigGL blend); @Override void setColor(Color color); @Override void setColorARGB(int color); @Override void setHidden(boolean hidden); @Override void setHighlightColor(Color color); @Override void setHighlightColorARGB(int color); @Override void setLighting(LightingModelConfigGL lighting); @Override void setObscurant(boolean obscurant); @Override void setOpacity(float opacity); @Override void setRenderingOrder(int order); }### Answer: @Test public void testSetObscurant() { EasyMockSupport support = new EasyMockSupport(); RenderPropertyChangeListener listener = createListener(support); DefaultTileRenderProperties props = new DefaultTileRenderProperties(10, true, true); props.setObscurant(true); props.addListener(listener); support.replayAll(); ProxyTileRenderProperties proxyProps = new ProxyTileRenderProperties(props); assertTrue(proxyProps.isObscurant()); proxyProps.setObscurant(false); assertFalse(proxyProps.isObscurant()); assertTrue(props.isObscurant()); support.verifyAll(); }
### Question: ProxyTileRenderProperties implements TileRenderProperties { @Override public void setOpacity(float opacity) { myCloned.setOpacity(opacity); myOriginal.notifyChanged(); } ProxyTileRenderProperties(DefaultTileRenderProperties renderProperties); @Override void addListener(RenderPropertyChangeListener listen); @Override ProxyTileRenderProperties clone(); @Override BlendingConfigGL getBlending(); @Override Color getColor(); @Override int getColorARGB(); @Override Color getHighlightColor(); @Override int getHighlightColorARGB(); @Override LightingModelConfigGL getLighting(); @Override float getOpacity(); @Override int getRenderingOrder(); @Override FragmentShaderProperties getShaderProperties(); @Override Collection<? extends RenderProperties> getThisPlusDescendants(); @Override int getZOrder(); @Override boolean isDrawable(); @Override boolean isHidden(); @Override boolean isObscurant(); @Override boolean isPickable(); @Override void opacitizeColor(float opacity); @Override void removeListener(RenderPropertyChangeListener listen); @Override void resetShaderPropertiesToDefault(); @Override void setBlending(BlendingConfigGL blend); @Override void setColor(Color color); @Override void setColorARGB(int color); @Override void setHidden(boolean hidden); @Override void setHighlightColor(Color color); @Override void setHighlightColorARGB(int color); @Override void setLighting(LightingModelConfigGL lighting); @Override void setObscurant(boolean obscurant); @Override void setOpacity(float opacity); @Override void setRenderingOrder(int order); }### Answer: @Test public void testSetOpacity() { EasyMockSupport support = new EasyMockSupport(); RenderPropertyChangeListener listener = createListener(support); DefaultTileRenderProperties props = new DefaultTileRenderProperties(10, true, true); props.setOpacity(.9f); props.addListener(listener); support.replayAll(); ProxyTileRenderProperties proxyProps = new ProxyTileRenderProperties(props); assertEquals(230f, proxyProps.getOpacity(), 0f); proxyProps.setOpacity(.5f); assertEquals(128f, proxyProps.getOpacity(), 0f); assertEquals(230f, props.getOpacity(), 0f); support.verifyAll(); }
### Question: PopoutModels { public Map<UUID, PopoutModel> getModels() { return myModels; } Map<UUID, PopoutModel> getModels(); }### Answer: @Test public void test() throws JAXBException { PopoutModels models = new PopoutModels(); PopoutModel model1 = new PopoutModel(); model1.setHeight(1); model1.setWidth(2); model1.setX(3); model1.setY(4); model1.setTitle("model1"); model1.getDataGroupInfoKeys().add("key1"); model1.getDataGroupInfoKeys().add("key2"); model1.getDataGroupInfoKeys().add("key3"); models.getModels().put(model1.getId(), model1); PopoutModel model2 = new PopoutModel(); model2.setHeight(21); model2.setWidth(22); model2.setX(23); model2.setY(24); model2.setTitle("model2"); model2.getDataGroupInfoKeys().add("key21"); model2.getDataGroupInfoKeys().add("key22"); model2.getDataGroupInfoKeys().add("key23"); models.getModels().put(model2.getId(), model2); JAXBContext context = JAXBContext.newInstance(PopoutModels.class); Marshaller marshaller = context.createMarshaller(); StringWriter stringWriter = new StringWriter(); marshaller.marshal(models, stringWriter); StringReader stringReader = new StringReader(stringWriter.getBuffer().toString()); Unmarshaller unmarshaller = context.createUnmarshaller(); PopoutModels actualModels = (PopoutModels)unmarshaller.unmarshal(stringReader); PopoutModel actualModel1 = actualModels.getModels().get(model1.getId()); assertEquals(model1.getHeight(), actualModel1.getHeight()); assertEquals(model1.getWidth(), actualModel1.getWidth()); assertEquals(model1.getX(), actualModel1.getX()); assertEquals(model1.getY(), actualModel1.getY()); assertEquals(model1.getTitle(), actualModel1.getTitle()); assertTrue(actualModel1.getDataGroupInfoKeys().contains("key1")); assertTrue(actualModel1.getDataGroupInfoKeys().contains("key2")); assertTrue(actualModel1.getDataGroupInfoKeys().contains("key3")); PopoutModel actualModel2 = actualModels.getModels().get(model2.getId()); assertEquals(model2.getHeight(), actualModel2.getHeight()); assertEquals(model2.getWidth(), actualModel2.getWidth()); assertEquals(model2.getX(), actualModel2.getX()); assertEquals(model2.getY(), actualModel2.getY()); assertEquals(model2.getTitle(), actualModel2.getTitle()); assertTrue(actualModel2.getDataGroupInfoKeys().contains("key21")); assertTrue(actualModel2.getDataGroupInfoKeys().contains("key22")); assertTrue(actualModel2.getDataGroupInfoKeys().contains("key23")); }
### Question: ProxyTileRenderProperties implements TileRenderProperties { @Override public void setRenderingOrder(int order) { myCloned.setRenderingOrder(order); myOriginal.notifyChanged(); } ProxyTileRenderProperties(DefaultTileRenderProperties renderProperties); @Override void addListener(RenderPropertyChangeListener listen); @Override ProxyTileRenderProperties clone(); @Override BlendingConfigGL getBlending(); @Override Color getColor(); @Override int getColorARGB(); @Override Color getHighlightColor(); @Override int getHighlightColorARGB(); @Override LightingModelConfigGL getLighting(); @Override float getOpacity(); @Override int getRenderingOrder(); @Override FragmentShaderProperties getShaderProperties(); @Override Collection<? extends RenderProperties> getThisPlusDescendants(); @Override int getZOrder(); @Override boolean isDrawable(); @Override boolean isHidden(); @Override boolean isObscurant(); @Override boolean isPickable(); @Override void opacitizeColor(float opacity); @Override void removeListener(RenderPropertyChangeListener listen); @Override void resetShaderPropertiesToDefault(); @Override void setBlending(BlendingConfigGL blend); @Override void setColor(Color color); @Override void setColorARGB(int color); @Override void setHidden(boolean hidden); @Override void setHighlightColor(Color color); @Override void setHighlightColorARGB(int color); @Override void setLighting(LightingModelConfigGL lighting); @Override void setObscurant(boolean obscurant); @Override void setOpacity(float opacity); @Override void setRenderingOrder(int order); }### Answer: @Test public void testSetRenderingOrder() { EasyMockSupport support = new EasyMockSupport(); RenderPropertyChangeListener listener = createListener(support); DefaultTileRenderProperties props = new DefaultTileRenderProperties(10, true, true); props.setRenderingOrder(2); props.addListener(listener); support.replayAll(); ProxyTileRenderProperties proxyProps = new ProxyTileRenderProperties(props); assertEquals(2, proxyProps.getRenderingOrder()); proxyProps.setRenderingOrder(4); assertEquals(4, proxyProps.getRenderingOrder()); assertEquals(2, props.getRenderingOrder()); support.verifyAll(); }