method2testcases
stringlengths 118
3.08k
|
|---|
### 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:
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 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 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 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(); }
|
### Question:
DefaultBaseRenderProperties extends DefaultZOrderRenderProperties implements BaseRenderProperties { @Override public DefaultBaseRenderProperties clone() { return (DefaultBaseRenderProperties)super.clone(); } DefaultBaseRenderProperties(int zOrder, boolean drawable, boolean pickable, boolean obscurant); @Override DefaultBaseRenderProperties clone(); @Override boolean equals(Object obj); @Override BlendingConfigGL getBlending(); @Override LightingModelConfigGL getLighting(); @Override int hashCode(); @Override boolean isDrawable(); @Override boolean isHidden(); @Override boolean isPickable(); @Override void setBlending(BlendingConfigGL blend); @Override void setHidden(boolean hidden); @Override void setLighting(LightingModelConfigGL lighting); }### Answer:
@Test public void testClone() { final BaseRenderProperties props = new DefaultBaseRenderProperties(0, true, true, true); boolean hidden = true; props.setHidden(hidden); LightingModelConfigGL.Builder builder = new LightingModelConfigGL.Builder(); ColorMaterialModeParameterType colorMaterialMode = ColorMaterialModeParameterType.AMBIENT_AND_DIFFUSE; builder.setColorMaterialMode(colorMaterialMode); LightingModelConfigGL lighting = new LightingModelConfigGL(builder); props.setLighting(lighting); RenderPropertyChangeListener listener = EasyMock.createMock(RenderPropertyChangeListener.class); EasyMock.replay(listener); props.addListener(listener); BaseRenderProperties clone = props.clone(); Assert.assertNotSame(props, clone); clone.setHidden(false); EasyMock.verify(listener); }
|
### Question:
TitlePopulator { public void populateTitle(PopoutModel model, String nodeLabel) { Matcher matcher = Pattern.compile("(.+?)\\s*\\(\\d+\\)$").matcher(nodeLabel); model.setTitle(matcher.matches() ? matcher.group(1) : nodeLabel); } void populateTitle(PopoutModel model, String nodeLabel); }### Answer:
@Test public void testPopulateTitle() { String nodeLabel = "Layer (35)"; String nodeLabel2 = "Layer (35) Four"; String nodeLabel3 = "Layer (Trunk)"; String nodeLabel4 = "(35) (36)"; String nodeLabel5 = "Layer"; String nodeLabel6 = "(36)"; String nodeLabel7 = "Layer )"; PopoutModel model = new PopoutModel(); TitlePopulator titlePopulator = new TitlePopulator(); titlePopulator.populateTitle(model, nodeLabel); assertEquals("Layer", model.getTitle()); titlePopulator.populateTitle(model, nodeLabel2); assertEquals("Layer (35) Four", model.getTitle()); titlePopulator.populateTitle(model, nodeLabel3); assertEquals("Layer (Trunk)", model.getTitle()); titlePopulator.populateTitle(model, nodeLabel4); assertEquals("(35)", model.getTitle()); titlePopulator.populateTitle(model, nodeLabel5); assertEquals("Layer", model.getTitle()); titlePopulator.populateTitle(model, nodeLabel6); assertEquals("(36)", model.getTitle()); titlePopulator.populateTitle(model, nodeLabel7); assertEquals("Layer )", model.getTitle()); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { @Override public int hashCode() { final int prime = 31; int result = 1; long temp; temp = Double.doubleToLongBits(myX); result = prime * result + (int)(temp ^ temp >>> 32); temp = Double.doubleToLongBits(myY); result = prime * result + (int)(temp ^ temp >>> 32); return result; } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testHashCode() { Assert.assertEquals(new Vector2d(1., 2.).hashCode(), new Vector2d(1., 2.).hashCode()); Assert.assertFalse(new Vector2d(1., 2.).hashCode() == new Vector2d(1., 3.).hashCode()); Assert.assertFalse(new Vector2d(1., 2.).hashCode() == new Vector2d(3., 2.).hashCode()); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { @Override public double distanceSquared(AbstractVector vec) { if (vec instanceof Vector2d) { Vector2d vec2 = (Vector2d)vec; double dx = myX - vec2.myX; double dy = myY - vec2.myY; return dx * dx + dy * dy; } return 0; } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testDistanceSquared() { Assert.assertEquals(25, new Vector2d(4., 5.).distanceSquared(new Vector2d(1., 1.)), 0.); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { @Override public double getLengthSquared() { return myX * myX + myY * myY; } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testGetLengthSquared() { Assert.assertEquals(25, new Vector2d(3., 4.).getLengthSquared(), 0.); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public Vector2d add(Vector2d vec) { return new Vector2d(myX + vec.myX, myY + vec.myY); } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testAddVector2d() { Assert.assertEquals(new Vector2d(4., 5.), new Vector2d(3., 4.).add(new Vector2d(1., 1.))); }
@Test public void testAddDoubleDouble() { Assert.assertEquals(new Vector2d(4., 5.), new Vector2d(3., 4.).add(1., 1.)); }
|
### Question:
OpacityColorAdapter extends IntegerModel implements Service { private static int toOpacityPercent(int alpha) { return Math.round(alpha / OPACITY_FACTOR); } OpacityColorAdapter(ColorModel colorModel); @Override void open(); @Override void close(); @Override boolean set(Integer value, boolean forceFire); }### Answer:
@Test public void testToOpacityPercent() { ColorModel colorModel = new ColorModel(); colorModel.set(Color.BLACK); try (OpacityColorAdapter opacityModel = new OpacityColorAdapter(colorModel)) { Assert.assertEquals(100, opacityModel.get().intValue()); opacityModel.open(); colorModel.set(Color.WHITE); Assert.assertEquals(100, opacityModel.get().intValue()); colorModel.set(new Color(255, 255, 255, 0)); Assert.assertEquals(0, opacityModel.get().intValue()); colorModel.set(new Color(255, 255, 255, 127)); Assert.assertEquals(50, opacityModel.get().intValue()); opacityModel.set(Integer.valueOf(75)); Assert.assertEquals(191, colorModel.get().getAlpha()); } }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public double angleBetween(Vector2d otherVector) { return Math.atan2(otherVector.myY, otherVector.myX) - Math.atan2(myY, myX); } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testAngleBetween() { Assert.assertEquals(Math.PI * .5, new Vector2d(1., 0.).angleBetween(new Vector2d(0., 1.)), 0.); Assert.assertEquals(Math.PI * -.5, new Vector2d(0., 1.).angleBetween(new Vector2d(1., 0.)), 0.); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public double determinant(Vector2d vec) { return myX * vec.myY - myY * vec.myX; } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testDeterminant() { Assert.assertEquals(1., new Vector2d(1., 0.).determinant(new Vector2d(0., 1.)), 0.); Assert.assertEquals(-1., new Vector2d(1., 1.).determinant(new Vector2d(-1., -2.)), 0.); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public Vector2d divide(double scalar) { return new Vector2d(myX / scalar, myY / scalar); } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testDivide() { Assert.assertEquals(new Vector2d(1., 2.), new Vector2d(4., 8.).divide(4.)); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public double dot(Vector2d vec) { return myX * vec.myX + myY * vec.myY; } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testDot() { Assert.assertEquals(0., new Vector2d(1., 0.).dot(new Vector2d(0., 1.)), 0.); Assert.assertEquals(1., new Vector2d(1., 0.).dot(new Vector2d(1., 1.)), 0.); Assert.assertEquals(.5, new Vector2d(1., 0.).dot(new Vector2d(.5, 1.)), 0.); Assert.assertEquals(.5, new Vector2d(1., 0.).dot(new Vector2d(.5, -1.)), 0.); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { @Override public boolean equals(Object o) { if (!(o instanceof Vector2d)) { return false; } if (this == o) { return true; } Vector2d comp = (Vector2d)o; return MathUtil.isZero(myX - comp.myX) && MathUtil.isZero(myY - comp.myY); } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testEqualsObject() { Assert.assertTrue(new Vector2d(1., 2.).equals(new Vector2d(1., 2.))); Assert.assertFalse(new Vector2d(1., 2.).equals(new Vector2d(1., 3.))); Assert.assertFalse(new Vector2d(1., 2.).equals(new Vector2d(3., 2.))); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public double getAngle() { return Math.atan2(myY, myX); } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testGetAngle() { Assert.assertEquals(Math.PI * .25, new Vector2d(1., 1.).getAngle(), 0.); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public Vector2d getNormalized() { double length = getLength(); return length == 1. ? this : new Vector2d(myX / length, myY / length); } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testGetNormalized() { Assert.assertEquals(new Vector2d(-.5 * Math.sqrt(2.), -.5 * Math.sqrt(2.)), new Vector2d(-2., -2.).getNormalized()); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public Vector2d getPerpendicular() { return new Vector2d(myY, -myX); } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testGetPerpendicular() { Assert.assertEquals(new Vector2d(0., -1.), new Vector2d(1., 0.).getPerpendicular()); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public Vector2d interpolate(Vector2d vec, double fraction) { return multiply(1. - fraction).add(vec.multiply(fraction)); } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testInterpolate() { Assert.assertEquals(new Vector2d(.2, 1.), new Vector2d(0., 1.).interpolate(new Vector2d(1., 1.), .2)); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public Vector2d multiply(double scalar) { return new Vector2d(myX * scalar, myY * scalar); } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testMultiply() { Assert.assertEquals(new Vector2d(4., 8.), new Vector2d(1., 2.).multiply(4.)); }
|
### Question:
AvroTimeHelper { public TimeSpan span(GenericRecord rec) { Date start = parseDate(valNonNull(rec, startKey)); Date end = parseDate(valNonNull(rec, endKey)); return TimeSpan.spanOrPt(start, end); } AvroTimeHelper(DataTypeInfo dti); DataTypeInfo getType(); TimeSpan span(GenericRecord rec); }### Answer:
@Test public void test() { EasyMockSupport support = new EasyMockSupport(); DataTypeInfo type = createDataType(support); long startTime = System.currentTimeMillis() - 1000; long endTime = System.currentTimeMillis(); GenericRecord record = createRecord(support, startTime, endTime); support.replayAll(); AvroTimeHelper helper = new AvroTimeHelper(type); TimeSpan span = helper.span(record); assertEquals(startTime, span.getStart()); assertEquals(endTime, span.getEnd()); support.verifyAll(); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public Vector2d rotateAroundOrigin(double angle) { double newX = Math.cos(angle) * myX - Math.sin(angle) * myY; double newY = Math.sin(angle) * myX + Math.cos(angle) * myY; return new Vector2d(newX, newY); } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testRotateAroundOrigin() { Assert.assertEquals(new Vector2d(-1., 1.), new Vector2d(1., 1.).rotateAroundOrigin(Math.PI * .5)); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public double smallestAngleBetween(Vector2d otherVector) { double dotProduct = dot(otherVector); return Math.acos(dotProduct); } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testSmallestAngleBetween() { Assert.assertEquals(Math.PI * .5, new Vector2d(1., 0.).smallestAngleBetween(new Vector2d(0., 1.)), 0.); Assert.assertEquals(Math.PI * .5, new Vector2d(0., 1.).smallestAngleBetween(new Vector2d(1., 0.)), 0.); Assert.assertEquals(Math.PI, new Vector2d(1., 0.).smallestAngleBetween(new Vector2d(-1., 0.)), 0.); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public Vector2d subtract(Vector2d vec) { return new Vector2d(myX - vec.myX, myY - vec.myY); } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testSubtract() { Assert.assertEquals(new Vector2d(1., 1.), new Vector2d(4., 5.).subtract(new Vector2d(3., 4.))); }
|
### Question:
Vector2d extends AbstractVector implements Serializable { public double[] toArray(double[] doubles) { double[] result = doubles == null ? new double[2] : doubles; result[0] = myX; result[1] = myY; return result; } Vector2d(double x, double y); Vector2d(Vector2d vec); Vector2d(Vector2i vec); static int counterClockwise(Vector2d p0, Vector2d p1, Vector2d p2); Vector2d add(Vector2d vec); Vector2d add(double x, double y); double angleBetween(Vector2d otherVector); double determinant(Vector2d vec); @Override double distanceSquared(AbstractVector vec); Vector2d divide(double scalar); double dot(Vector2d vec); @Override boolean equals(Object o); double getAngle(); @Override double getLengthSquared(); Vector2d getNormalized(); Vector2d getPerpendicular(); double getX(); double getY(); @Override int hashCode(); Vector2d interpolate(Vector2d vec, double fraction); boolean isFinite(); Vector2d multiply(double scalar); Vector2d rotateAroundOrigin(double angle); double smallestAngleBetween(Vector2d otherVector); Vector2d subtract(Vector2d vec); double[] toArray(double[] doubles); @Override String toString(); static final Comparator<Vector2d> LENGTH_COMPARATOR; static final Vector2d ORIGIN; static final int SIZE_BYTES; }### Answer:
@Test public void testToArray() { Assert.assertArrayEquals(new double[] { 3., 4. }, new Vector2d(3., 4.).toArray(new double[2]), 0.); }
|
### Question:
DefaultEllipsoid extends AbstractShape3D implements Ellipsoid { @Override public Vector3d directionToLocal(Vector3d direction) { return getInverseTransform().mult(direction); } DefaultEllipsoid(); DefaultEllipsoid(double radius, double radius2, double radius3); DefaultEllipsoid(Vector3d center, double radius, double radius2, double radius3); DefaultEllipsoid(Vector3d center, Vector3d xAxis, Vector3d yAxis, Vector3d zAxis); @Override Vector3d directionToLocal(Vector3d direction); @Override Vector3d directionToModel(Vector3d direction); @Override double getBoundingRadius(); @Override Vector3d getCenter(); @Override double getHeading(Vector3d location, Vector3d direction); @Override Vector3d getIntersection(Ray3d ray); @Override long getSizeBytes(); @Override Vector3d getTangent(Vector3d normal); @Override Vector3d getXAxis(); @Override Vector3d getYAxis(); @Override Vector3d getZAxis(); @Override boolean isSphere(); @Override Vector3d localToModel(Vector3d position); @Override Vector3d modelToLocal(Vector3d position); @Override Vector3d normalToLocal(Vector3d normal); @Override String toString(); }### Answer:
@Test public void testDirectionToLocal() { Vector3d center = new Vector3d(3., 4., 13.); Vector3d xAxis = new Vector3d(7., 0., 0.); Vector3d yAxis = new Vector3d(0., 11., 0.); Vector3d zAxis = new Vector3d(0., 0., 13.); Ellipsoid ell = new DefaultEllipsoid(center, xAxis, yAxis, zAxis); Assert.assertEquals(new Vector3d(2., 3., 5.), ell.directionToLocal(new Vector3d(14., 33., 65.))); }
|
### Question:
DefaultEllipsoid extends AbstractShape3D implements Ellipsoid { @Override public Vector3d directionToModel(Vector3d direction) { return myTransform.mult(direction); } DefaultEllipsoid(); DefaultEllipsoid(double radius, double radius2, double radius3); DefaultEllipsoid(Vector3d center, double radius, double radius2, double radius3); DefaultEllipsoid(Vector3d center, Vector3d xAxis, Vector3d yAxis, Vector3d zAxis); @Override Vector3d directionToLocal(Vector3d direction); @Override Vector3d directionToModel(Vector3d direction); @Override double getBoundingRadius(); @Override Vector3d getCenter(); @Override double getHeading(Vector3d location, Vector3d direction); @Override Vector3d getIntersection(Ray3d ray); @Override long getSizeBytes(); @Override Vector3d getTangent(Vector3d normal); @Override Vector3d getXAxis(); @Override Vector3d getYAxis(); @Override Vector3d getZAxis(); @Override boolean isSphere(); @Override Vector3d localToModel(Vector3d position); @Override Vector3d modelToLocal(Vector3d position); @Override Vector3d normalToLocal(Vector3d normal); @Override String toString(); }### Answer:
@Test public void testDirectionToModel() { Vector3d center = new Vector3d(3., 4., 13.); Vector3d xAxis = new Vector3d(7., 0., 0.); Vector3d yAxis = new Vector3d(0., 11., 0.); Vector3d zAxis = new Vector3d(0., 0., 13.); Ellipsoid ell = new DefaultEllipsoid(center, xAxis, yAxis, zAxis); Assert.assertEquals(new Vector3d(14., 33., 65.), ell.directionToModel(new Vector3d(2., 3., 5.))); }
|
### Question:
DefaultEllipsoid extends AbstractShape3D implements Ellipsoid { @Override public Vector3d localToModel(Vector3d position) { return myTransform.mult(position).add(myCenter); } DefaultEllipsoid(); DefaultEllipsoid(double radius, double radius2, double radius3); DefaultEllipsoid(Vector3d center, double radius, double radius2, double radius3); DefaultEllipsoid(Vector3d center, Vector3d xAxis, Vector3d yAxis, Vector3d zAxis); @Override Vector3d directionToLocal(Vector3d direction); @Override Vector3d directionToModel(Vector3d direction); @Override double getBoundingRadius(); @Override Vector3d getCenter(); @Override double getHeading(Vector3d location, Vector3d direction); @Override Vector3d getIntersection(Ray3d ray); @Override long getSizeBytes(); @Override Vector3d getTangent(Vector3d normal); @Override Vector3d getXAxis(); @Override Vector3d getYAxis(); @Override Vector3d getZAxis(); @Override boolean isSphere(); @Override Vector3d localToModel(Vector3d position); @Override Vector3d modelToLocal(Vector3d position); @Override Vector3d normalToLocal(Vector3d normal); @Override String toString(); }### Answer:
@Test public void testLocalToModel() { Vector3d center = new Vector3d(3., 4., 13.); Vector3d xAxis = new Vector3d(7., 0., 0.); Vector3d yAxis = new Vector3d(0., 11., 0.); Vector3d zAxis = new Vector3d(0., 0., 13.); Ellipsoid ell = new DefaultEllipsoid(center, xAxis, yAxis, zAxis); Assert.assertEquals(new Vector3d(17., 37., 78.), ell.localToModel(new Vector3d(2., 3., 5.))); }
|
### Question:
DefaultEllipsoid extends AbstractShape3D implements Ellipsoid { @Override public Vector3d normalToLocal(Vector3d normal) { return getInverseNormalTransform().mult(normal); } DefaultEllipsoid(); DefaultEllipsoid(double radius, double radius2, double radius3); DefaultEllipsoid(Vector3d center, double radius, double radius2, double radius3); DefaultEllipsoid(Vector3d center, Vector3d xAxis, Vector3d yAxis, Vector3d zAxis); @Override Vector3d directionToLocal(Vector3d direction); @Override Vector3d directionToModel(Vector3d direction); @Override double getBoundingRadius(); @Override Vector3d getCenter(); @Override double getHeading(Vector3d location, Vector3d direction); @Override Vector3d getIntersection(Ray3d ray); @Override long getSizeBytes(); @Override Vector3d getTangent(Vector3d normal); @Override Vector3d getXAxis(); @Override Vector3d getYAxis(); @Override Vector3d getZAxis(); @Override boolean isSphere(); @Override Vector3d localToModel(Vector3d position); @Override Vector3d modelToLocal(Vector3d position); @Override Vector3d normalToLocal(Vector3d normal); @Override String toString(); }### Answer:
@Test public void testNormalToLocal() { Vector3d center = new Vector3d(3., 4., 13.); Vector3d xAxis = new Vector3d(2., 0., 0.); Vector3d yAxis = new Vector3d(0., 3., 0.); Vector3d zAxis = new Vector3d(0., 0., 5.); Ellipsoid ell = new DefaultEllipsoid(center, xAxis, yAxis, zAxis); Assert.assertEquals(new Vector3d(2., 3., 5.), ell.normalToLocal(new Vector3d(1., 1., 1.))); }
|
### Question:
Line2d { public Vector2d getIntersection(Ray2d ray, boolean allowNegative) { double dist = getDistance(ray); if (Double.isNaN(dist) || dist < 0. && !allowNegative) { return null; } return ray.getPosition().add(ray.getDirection().multiply(dist)); } Line2d(Vector2d point, Vector2d normal); double distance(Vector2d pos); double getDistance(Ray2d ray); Vector2d getIntersection(Ray2d ray, boolean allowNegative); Vector2d getIntersection(Vector2d ptA, Vector2d ptB); Vector2d getNormal(); Vector2d getPoint(); List<? extends Vector2d> getSegmentIntersection(Vector2d ptA, Vector2d ptB); boolean hasIntersection(Vector2d ptA, Vector2d ptB); boolean isInFront(Vector2d position, double distance); boolean onSameSide(Vector2d ptA, Vector2d ptB); Vector2d project(Vector2d pos); }### Answer:
@Test public void testIntersectionRay2d() { Line2d line = new Line2d(new Vector2d(0., 0.), new Vector2d(0., 1.)); Ray2d parallelRay = new Ray2d(new Vector2d(0., 1.), new Vector2d(2., 0.)); Assert.assertNull(line.getIntersection(parallelRay, true)); Ray2d ray = new Ray2d(new Vector2d(0., 1.), new Vector2d(4., -1.)); Assert.assertEquals(new Vector2d(4., 0.), line.getIntersection(ray, true)); }
|
### Question:
JAXBDuration implements JAXBWrapper<Duration> { @Override public Duration getWrappedObject() { return Duration.create((Class<? extends Duration>)myUnits, myUnscaledMagnitude, myScale); } JAXBDuration(Duration dur); protected JAXBDuration(); @Override boolean equals(Object obj); @Override Duration getWrappedObject(); @Override int hashCode(); void setDuration(Duration duration); }### Answer:
@Test public void test() throws JAXBException, ClassNotFoundException { Duration result; Element el; Duration testSeconds = new Seconds(new BigDecimal("3324.352")); ByteArrayOutputStream baos = new ByteArrayOutputStream(); XMLUtilities.writeXMLObject(new JAXBDuration(testSeconds), baos); result = XMLUtilities.readXMLObject(new ByteArrayInputStream(baos.toByteArray()), JAXBDuration.class).getWrappedObject(); Assert.assertEquals(result, testSeconds); el = XMLUtilities.marshalJAXBableToElement(testSeconds); result = XMLUtilities.readJAXBableObject(el, Duration.class); Assert.assertEquals(result, testSeconds); Duration testMonths = new Months(new BigDecimal("3324.352")); baos.reset(); XMLUtilities.writeXMLObject(new JAXBDuration(testMonths), baos); result = XMLUtilities.readXMLObject(new ByteArrayInputStream(baos.toByteArray()), JAXBDuration.class).getWrappedObject(); Assert.assertEquals(result, testMonths); el = XMLUtilities.marshalJAXBableToElement(testMonths); result = XMLUtilities.readJAXBableObject(el, Duration.class); Assert.assertEquals(result, testMonths); }
|
### Question:
DurationUnitsProvider extends AbstractUnitsProvider<Duration> { @Override public <T extends Duration> T convert(Class<T> desiredType, Duration from) throws InvalidUnitsException { return Duration.create(desiredType, from); } DurationUnitsProvider(); @SuppressWarnings("PMD.PreserveStackTrace") void add(Calendar cal, Duration dur); @Override T convert(Class<T> desiredType, Duration from); @Override T fromUnitsAndMagnitude(Class<T> type, Number magnitude); @Override Class<? extends Duration> getDisplayClass(Duration value); Duration getLargestIntegerUnitType(Duration input); @Override String getLongLabel(Class<? extends Duration> type, boolean plural); @Override String getSelectionLabel(Class<? extends Duration> type); @Override String getShortLabel(Class<? extends Duration> type, boolean plural); @Override Class<Duration> getSuperType(); @Override String toShortLabelString(Duration obj); }### Answer:
@Test public void testConvert() { Seconds oneHourInSeconds = new Seconds(3600L); Assert.assertSame(oneHourInSeconds, new DurationUnitsProvider().convert(Seconds.class, oneHourInSeconds)); Assert.assertEquals(oneHourInSeconds, new DurationUnitsProvider().convert(Seconds.class, new Hours(1L))); }
|
### Question:
DurationUnitsProvider extends AbstractUnitsProvider<Duration> { @Override public <T extends Duration> T fromUnitsAndMagnitude(Class<T> type, Number magnitude) throws InvalidUnitsException { return Duration.create(type, new BigDecimal(magnitude.toString())); } DurationUnitsProvider(); @SuppressWarnings("PMD.PreserveStackTrace") void add(Calendar cal, Duration dur); @Override T convert(Class<T> desiredType, Duration from); @Override T fromUnitsAndMagnitude(Class<T> type, Number magnitude); @Override Class<? extends Duration> getDisplayClass(Duration value); Duration getLargestIntegerUnitType(Duration input); @Override String getLongLabel(Class<? extends Duration> type, boolean plural); @Override String getSelectionLabel(Class<? extends Duration> type); @Override String getShortLabel(Class<? extends Duration> type, boolean plural); @Override Class<Duration> getSuperType(); @Override String toShortLabelString(Duration obj); }### Answer:
@Test public void testFromTypeAndMagnitude() { Assert.assertEquals(new Seconds(3600L), new DurationUnitsProvider().fromUnitsAndMagnitude(Seconds.class, Integer.valueOf(3600))); }
|
### Question:
DurationUnitsProvider extends AbstractUnitsProvider<Duration> { @Override public String toShortLabelString(Duration obj) { return obj.toShortLabelString(); } DurationUnitsProvider(); @SuppressWarnings("PMD.PreserveStackTrace") void add(Calendar cal, Duration dur); @Override T convert(Class<T> desiredType, Duration from); @Override T fromUnitsAndMagnitude(Class<T> type, Number magnitude); @Override Class<? extends Duration> getDisplayClass(Duration value); Duration getLargestIntegerUnitType(Duration input); @Override String getLongLabel(Class<? extends Duration> type, boolean plural); @Override String getSelectionLabel(Class<? extends Duration> type); @Override String getShortLabel(Class<? extends Duration> type, boolean plural); @Override Class<Duration> getSuperType(); @Override String toShortLabelString(Duration obj); }### Answer:
@Test public void testToFromShortLabelString() { DurationUnitsProvider units = new DurationUnitsProvider(); Duration input = new Seconds(BigDecimal.valueOf(827893745.34785384e45)); String str = units.toShortLabelString(input); Duration output = units.fromShortLabelString(str); Assert.assertEquals(input, output); }
|
### Question:
RefreshTreeController { public void refresh(final DataGroupInfo dataGroup) { if (dataGroup instanceof RefreshableDataGroupInfo) { ThreadUtilities.runBackground(new Runnable() { @Override public void run() { ((RefreshableDataGroupInfo)dataGroup).refresh(); } }); } } void refresh(final DataGroupInfo dataGroup); }### Answer:
@Test public void testRefresh() throws InterruptedException { EasyMockSupport support = new EasyMockSupport(); DataGroupInfo group = support.createMock(DataGroupInfo.class); support.replayAll(); RefreshTreeController controller = new RefreshTreeController(); controller.refresh(group); CountDownLatch latch = new CountDownLatch(1); controller.refresh(new RefreshableGroupMock(latch)); latch.await(); support.verifyAll(); }
|
### Question:
JAXBLength implements JAXBWrapper<Length> { @Override public Length getWrappedObject() { return Length.create(myUnits, myMagnitude); } JAXBLength(Length length); protected JAXBLength(); @Override boolean equals(Object obj); @Override Length getWrappedObject(); @Override int hashCode(); }### Answer:
@Test public void test() throws JAXBException, ClassNotFoundException { Length result; Element el; Length testMeters = new Meters(3324.352); ByteArrayOutputStream baos = new ByteArrayOutputStream(); XMLUtilities.writeXMLObject(new JAXBLength(testMeters), baos); result = XMLUtilities.readXMLObject(new ByteArrayInputStream(baos.toByteArray()), JAXBLength.class).getWrappedObject(); Assert.assertEquals(result, testMeters); baos.reset(); el = XMLUtilities.marshalJAXBableToElement(testMeters); result = XMLUtilities.readJAXBableObject(el, Length.class); Assert.assertEquals(result, testMeters); Length testFeet = new Feet(3324.352); baos.reset(); XMLUtilities.writeXMLObject(new JAXBLength(testFeet), baos); result = XMLUtilities.readXMLObject(new ByteArrayInputStream(baos.toByteArray()), JAXBLength.class).getWrappedObject(); Assert.assertEquals(result, testFeet); baos.reset(); el = XMLUtilities.marshalJAXBableToElement(testFeet); result = XMLUtilities.readJAXBableObject(el, Length.class); Assert.assertEquals(result, testFeet); }
|
### Question:
LayerSelectionUtilities { public static List<Object> filter(Collection<?> layers) { List<Object> filtered = New.list(layers); for (Object layer : layers) { if (layer instanceof DataGroupInfo) { DataGroupInfo group = (DataGroupInfo)layer; filtered.removeAll(group.getMembers(true)); filtered.removeAll(getAllChildren(group)); } } return filtered; } private LayerSelectionUtilities(); static List<Object> filter(Collection<?> layers); static Collection<DataGroupInfo> getAllChildren(DataGroupInfo group); }### Answer:
@Test public void testFilter() { DataGroupInfo a = createDataGroup("A"); DataGroupInfo b = createDataGroup("B"); DataTypeInfo c = createDataType("C"); DataTypeInfo d = createDataType("D"); DataGroupInfo e = createDataGroup("E"); DataTypeInfo f = createDataType("F"); DataTypeInfo g = createDataType("G"); a.addChild(b, this); b.addMember(c, this); b.addMember(d, this); a.addChild(e, this); a.addMember(f, this); a.addMember(g, this); List<?> input; List<?> expected; input = New.list(a, b, c, d, e, f, g); expected = New.list(a); Assert.assertEquals(expected, LayerSelectionUtilities.filter(input)); input = New.list(b, d); expected = New.list(b); Assert.assertEquals(expected, LayerSelectionUtilities.filter(input)); input = New.list(c, d, f, g); expected = New.list(c, d, f, g); Assert.assertEquals(expected, LayerSelectionUtilities.filter(input)); input = New.list(b, c, d, e, f, g); expected = New.list(b, e, f, g); Assert.assertEquals(expected, LayerSelectionUtilities.filter(input)); }
|
### Question:
Feet extends Length { @Override public Feet clone() { return (Feet)super.clone(); } Feet(double feet); Feet(Length dist); @Override Feet clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inFeet(); static final String FEET_LONG_LABEL1; static final String FEET_LONG_LABEL2; static final String FEET_SHORT_LABEL; }### Answer:
@Test public void testClone() { Length dist = new Feet(5280.); Assert.assertEquals(dist.getMagnitude(), dist.clone().getMagnitude(), 0.); }
|
### Question:
Feet extends Length { @Override public double inFeet() { return getMagnitude(); } Feet(double feet); Feet(Length dist); @Override Feet clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inFeet(); static final String FEET_LONG_LABEL1; static final String FEET_LONG_LABEL2; static final String FEET_SHORT_LABEL; }### Answer:
@Test public void testUnits() { Length dist = new Feet(5280.); Assert.assertEquals(5280., dist.inFeet(), 0.); Assert.assertEquals(1609.344, dist.inMeters(), 0.); Assert.assertEquals(5280., new Feet(dist).getMagnitude(), 0.); Assert.assertEquals(63360., new Inches(dist).getMagnitude(), 0.); Assert.assertEquals(0.86897624190064794816414686825054, new NauticalMiles(dist).getMagnitude(), 0.); Assert.assertEquals(1609.344, new Meters(dist).getMagnitude(), 0.); Assert.assertEquals(1.609344, new Kilometers(dist).getMagnitude(), 0.); Assert.assertEquals(1., new StatuteMiles(dist).getMagnitude(), 0.); Assert.assertEquals(1760., new Yards(dist).getMagnitude(), 0.); }
|
### Question:
Inches extends Length { @Override public Inches clone() { return (Inches)super.clone(); } Inches(double in); Inches(Length dist); @Override Inches clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inFeet(); static final int INCHES_PER_FOOT; static final String INCHES_LONG_LABEL; static final String INCHES_SHORT_LABEL; }### Answer:
@Test public void testClone() { Length dist = new Inches(63360.); Assert.assertEquals(dist.getMagnitude(), dist.clone().getMagnitude(), 0.); }
|
### Question:
Inches extends Length { @Override public double inFeet() { return getMagnitude() / INCHES_PER_FOOT; } Inches(double in); Inches(Length dist); @Override Inches clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inFeet(); static final int INCHES_PER_FOOT; static final String INCHES_LONG_LABEL; static final String INCHES_SHORT_LABEL; }### Answer:
@Test public void testUnits() { Length dist = new Inches(63360.); Assert.assertEquals(5280., dist.inFeet(), 0.); Assert.assertEquals(1609.344, dist.inMeters(), 0.); Assert.assertEquals(5280., new Feet(dist).getMagnitude(), 0.); Assert.assertEquals(63360., new Inches(dist).getMagnitude(), 0.); Assert.assertEquals(0.86897624190064794816414686825054, new NauticalMiles(dist).getMagnitude(), 0.); Assert.assertEquals(1609.344, new Meters(dist).getMagnitude(), 0.); Assert.assertEquals(1.609344, new Kilometers(dist).getMagnitude(), 0.); Assert.assertEquals(1., new StatuteMiles(dist).getMagnitude(), 0.); Assert.assertEquals(1760., new Yards(dist).getMagnitude(), 0.); }
|
### Question:
StatuteMiles extends Length { @Override public StatuteMiles clone() { return (StatuteMiles)super.clone(); } StatuteMiles(double mi); StatuteMiles(Length dist); static double fromFeet(double feet); static double toFeet(double miles); @Override StatuteMiles clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inFeet(); static final int FEET_PER_STATUTE_MILE; static final String MILES_LONG_LABEL; static final String MILES_SHORT_LABEL; }### Answer:
@Test public void testClone() { Length dist = new StatuteMiles(1.); Assert.assertEquals(dist.getMagnitude(), dist.clone().getMagnitude(), 0.); }
|
### Question:
StatuteMiles extends Length { @Override public double inFeet() { return getMagnitude() * FEET_PER_STATUTE_MILE; } StatuteMiles(double mi); StatuteMiles(Length dist); static double fromFeet(double feet); static double toFeet(double miles); @Override StatuteMiles clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inFeet(); static final int FEET_PER_STATUTE_MILE; static final String MILES_LONG_LABEL; static final String MILES_SHORT_LABEL; }### Answer:
@Test public void testUnits() { Length dist = new StatuteMiles(1.); Assert.assertEquals(5280., dist.inFeet(), 0.); Assert.assertEquals(1609.344, dist.inMeters(), 0.); Assert.assertEquals(5280., new Feet(dist).getMagnitude(), 0.); Assert.assertEquals(63360., new Inches(dist).getMagnitude(), 0.); Assert.assertEquals(0.86897624190064794816414686825054, new NauticalMiles(dist).getMagnitude(), 0.); Assert.assertEquals(1609.344, new Meters(dist).getMagnitude(), 0.); Assert.assertEquals(1.609344, new Kilometers(dist).getMagnitude(), 0.); Assert.assertEquals(1., new StatuteMiles(dist).getMagnitude(), 0.); Assert.assertEquals(1760., new Yards(dist).getMagnitude(), 0.); }
|
### Question:
Yards extends Length { @Override public Yards clone() { return (Yards)super.clone(); } Yards(double yards); Yards(Length dist); @Override Yards clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inFeet(); static final int FEET_PER_YARD; static final String YARDS_LONG_LABEL; static final String YARDS_SHORT_LABEL; }### Answer:
@Test public void testClone() { Length dist = new Yards(1760.); Assert.assertEquals(dist.getMagnitude(), dist.clone().getMagnitude(), 0.); }
|
### Question:
Yards extends Length { @Override public double inFeet() { return getMagnitude() * FEET_PER_YARD; } Yards(double yards); Yards(Length dist); @Override Yards clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inFeet(); static final int FEET_PER_YARD; static final String YARDS_LONG_LABEL; static final String YARDS_SHORT_LABEL; }### Answer:
@Test public void testUnits() { Length dist = new Yards(1760.); Assert.assertEquals(5280., dist.inFeet(), 0.); Assert.assertEquals(1609.344, dist.inMeters(), 0.); Assert.assertEquals(5280., new Feet(dist).getMagnitude(), 0.); Assert.assertEquals(63360., new Inches(dist).getMagnitude(), 0.); Assert.assertEquals(0.86897624190064794816414686825054, new NauticalMiles(dist).getMagnitude(), 0.); Assert.assertEquals(1609.344, new Meters(dist).getMagnitude(), 0.); Assert.assertEquals(1.609344, new Kilometers(dist).getMagnitude(), 0.); Assert.assertEquals(1., new StatuteMiles(dist).getMagnitude(), 0.); Assert.assertEquals(1760., new Yards(dist).getMagnitude(), 0.); }
|
### Question:
Kilometers extends Length { @Override public Kilometers clone() { return (Kilometers)super.clone(); } Kilometers(double kilometers); Kilometers(Length dist); static double fromMeters(double meters); static double toMeters(double kilometers); @Override Kilometers clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inMeters(); static final String KILOMETERS_LONG_LABEL; static final String KILOMETERS_SHORT_LABEL; static final Kilometers ONE; static final Kilometers ZERO; }### Answer:
@Test public void testClone() { Length dist = new Kilometers(1.852); Assert.assertEquals(dist.getMagnitude(), dist.clone().getMagnitude(), 0.); }
|
### Question:
Meters extends Length { @Override public Meters clone() { return (Meters)super.clone(); } Meters(double meters); Meters(Length dist); static Meters get(Length length); @Override Meters clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inMeters(); static final String METERS_LONG_LABEL; static final String METERS_SHORT_LABEL; static final Meters ONE; static final Meters ZERO; }### Answer:
@Test public void testClone() { Length dist = new Meters(1852.); Assert.assertEquals(dist.getMagnitude(), dist.clone().getMagnitude(), 0.); }
|
### Question:
Meters extends Length { @Override public double inMeters() { return getMagnitude(); } Meters(double meters); Meters(Length dist); static Meters get(Length length); @Override Meters clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inMeters(); static final String METERS_LONG_LABEL; static final String METERS_SHORT_LABEL; static final Meters ONE; static final Meters ZERO; }### Answer:
@Test public void testUnits() { Length dist = new Meters(1852.); Assert.assertEquals(6076.1154855643044619422572178515, dist.inFeet(), 0.); Assert.assertEquals(1852., dist.inMeters(), 0.); Assert.assertEquals(6076.1154855643044619422572178515, new Feet(dist).getMagnitude(), 0.); Assert.assertEquals(72913.385826771653543307086614219, new Inches(dist).getMagnitude(), 0.); Assert.assertEquals(1., new NauticalMiles(dist).getMagnitude(), 0.); Assert.assertEquals(1852., new Meters(dist).getMagnitude(), 0.); Assert.assertEquals(1.852, new Kilometers(dist).getMagnitude(), 0.); Assert.assertEquals(1.1507794480235425117314881094416, new StatuteMiles(dist).getMagnitude(), 0.); Assert.assertEquals(2025.3718285214348206474190726172, new Yards(dist).getMagnitude(), 0.); }
|
### Question:
NauticalMiles extends Length { @Override public NauticalMiles clone() { return (NauticalMiles)super.clone(); } NauticalMiles(double nm); NauticalMiles(Length dist); static double fromKilometers(double km); static double fromMeters(double meters); static double toKilometers(double nm); static double toMeters(double nm); @Override NauticalMiles clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inMeters(); static final int METERS_PER_NAUTICAL_MILE; static final String NM_LONG_LABEL; static final String NM_SHORT_LABEL; }### Answer:
@Test public void testClone() { Length dist = new NauticalMiles(1.); Assert.assertEquals(dist.getMagnitude(), dist.clone().getMagnitude(), 0.); }
|
### Question:
NauticalMiles extends Length { public static double fromKilometers(double km) { return km / METERS_PER_NAUTICAL_MILE * Constants.UNIT_PER_KILO; } NauticalMiles(double nm); NauticalMiles(Length dist); static double fromKilometers(double km); static double fromMeters(double meters); static double toKilometers(double nm); static double toMeters(double nm); @Override NauticalMiles clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inMeters(); static final int METERS_PER_NAUTICAL_MILE; static final String NM_LONG_LABEL; static final String NM_SHORT_LABEL; }### Answer:
@Test public void testFromKilometers() { Assert.assertEquals(1000., NauticalMiles.fromKilometers(1852.), 0.); }
|
### Question:
NauticalMiles extends Length { public static double toKilometers(double nm) { return nm / Constants.UNIT_PER_KILO * METERS_PER_NAUTICAL_MILE; } NauticalMiles(double nm); NauticalMiles(Length dist); static double fromKilometers(double km); static double fromMeters(double meters); static double toKilometers(double nm); static double toMeters(double nm); @Override NauticalMiles clone(); @Override String getLongLabel(boolean plural); @Override String getShortLabel(boolean plural); @Override double inMeters(); static final int METERS_PER_NAUTICAL_MILE; static final String NM_LONG_LABEL; static final String NM_SHORT_LABEL; }### Answer:
@Test public void testToKilometers() { Assert.assertEquals(1., NauticalMiles.toKilometers(1000 / 1852.), 1e-14); }
|
### Question:
LengthUnitsProvider extends AbstractUnitsProvider<Length> { @Override public <T extends Length> T convert(Class<T> desiredType, Length source) throws InvalidUnitsException { return Length.create(desiredType, source); } LengthUnitsProvider(); @Override T convert(Class<T> desiredType, Length source); @Override T fromUnitsAndMagnitude(Class<T> type, Number magnitude); @Override Class<? extends Length> getDisplayClass(Length value); @Override String getLongLabel(Class<? extends Length> type, boolean plural); @Override String getSelectionLabel(Class<? extends Length> type); @Override String getShortLabel(Class<? extends Length> type, boolean plural); @Override Class<Length> getSuperType(); @Override String toShortLabelString(Length obj); }### Answer:
@Test public void testConvert() { NauticalMiles oneNauticalMile = new NauticalMiles(1.); Assert.assertSame(oneNauticalMile, new LengthUnitsProvider().convert(NauticalMiles.class, oneNauticalMile)); Assert.assertEquals(oneNauticalMile, new LengthUnitsProvider().convert(NauticalMiles.class, new Meters(1852.))); }
|
### Question:
LengthUnitsProvider extends AbstractUnitsProvider<Length> { @Override public <T extends Length> T fromUnitsAndMagnitude(Class<T> type, Number magnitude) throws InvalidUnitsException { return Length.create(type, magnitude.doubleValue()); } LengthUnitsProvider(); @Override T convert(Class<T> desiredType, Length source); @Override T fromUnitsAndMagnitude(Class<T> type, Number magnitude); @Override Class<? extends Length> getDisplayClass(Length value); @Override String getLongLabel(Class<? extends Length> type, boolean plural); @Override String getSelectionLabel(Class<? extends Length> type); @Override String getShortLabel(Class<? extends Length> type, boolean plural); @Override Class<Length> getSuperType(); @Override String toShortLabelString(Length obj); }### Answer:
@Test public void testFromUnitsAndMagnitude() { Assert.assertEquals(new NauticalMiles(1.), new LengthUnitsProvider().fromUnitsAndMagnitude(NauticalMiles.class, Double.valueOf(1.))); }
|
### Question:
LengthUnitsProvider extends AbstractUnitsProvider<Length> { @Override public Class<? extends Length> getDisplayClass(Length value) { return value.getDisplayClass(); } LengthUnitsProvider(); @Override T convert(Class<T> desiredType, Length source); @Override T fromUnitsAndMagnitude(Class<T> type, Number magnitude); @Override Class<? extends Length> getDisplayClass(Length value); @Override String getLongLabel(Class<? extends Length> type, boolean plural); @Override String getSelectionLabel(Class<? extends Length> type); @Override String getShortLabel(Class<? extends Length> type, boolean plural); @Override Class<Length> getSuperType(); @Override String toShortLabelString(Length obj); }### Answer:
@Test public void testGetDisplayClass() { LengthUnitsProvider units = new LengthUnitsProvider(); Assert.assertEquals(Meters.class, units.getDisplayClass(new AutoscaleMetric(1.))); Assert.assertEquals(Kilometers.class, units.getDisplayClass(new AutoscaleMetric(50000.))); }
|
### Question:
LengthUnitsProvider extends AbstractUnitsProvider<Length> { @Override public String toShortLabelString(Length obj) { return obj.toShortLabelString(); } LengthUnitsProvider(); @Override T convert(Class<T> desiredType, Length source); @Override T fromUnitsAndMagnitude(Class<T> type, Number magnitude); @Override Class<? extends Length> getDisplayClass(Length value); @Override String getLongLabel(Class<? extends Length> type, boolean plural); @Override String getSelectionLabel(Class<? extends Length> type); @Override String getShortLabel(Class<? extends Length> type, boolean plural); @Override Class<Length> getSuperType(); @Override String toShortLabelString(Length obj); }### Answer:
@Test public void testToFromShortLabelString() { LengthUnitsProvider units = new LengthUnitsProvider(); Meters input = new Meters(827893745.34785384e45); String str = units.toShortLabelString(input); Length output = units.fromShortLabelString(str); Assert.assertEquals(input, output); }
|
### Question:
DecimalDegrees extends Coordinates { @Override public DecimalDegrees clone() { return (DecimalDegrees)super.clone(); } DecimalDegrees(Coordinates ang); DecimalDegrees(double degrees); @Override DecimalDegrees clone(); @Override String getLongLabel(); @Override String getShortLabel(); @Override String toShortLabelString(); @Override String toShortLabelString(char positive, char negative); @Override String toShortLabelString(int width, int precision); @Override String toShortLabelString(int width, int precision, char positive, char negative); static final String DEGREES_LONG_LABEL; static final String DEGREES_SHORT_LABEL; }### Answer:
@Test public void testClone() { Coordinates ang = new DecimalDegrees(34.54512); Assert.assertEquals(ang.getMagnitude(), ang.clone().getMagnitude(), 0.); }
|
### Question:
AngleUnitsProvider extends AbstractUnitsProvider<Coordinates> { @Override public <T extends Coordinates> T convert(Class<T> desiredType, Coordinates source) throws InvalidUnitsException { return Coordinates.create(desiredType, source); } AngleUnitsProvider(); @Override T convert(Class<T> desiredType, Coordinates source); @Override T fromUnitsAndMagnitude(Class<T> type, Number magnitude); @Override Class<? extends Coordinates> getDisplayClass(Coordinates value); @Override String getLongLabel(Class<? extends Coordinates> type, boolean plural); @Override String getSelectionLabel(Class<? extends Coordinates> type); @Override String getShortLabel(Class<? extends Coordinates> type, boolean plural); @Override Class<Coordinates> getSuperType(); @Override Class<? extends Coordinates> getUnitsWithLongLabel(String label); @Override String toShortLabelString(Coordinates obj); }### Answer:
@Test public void testConvert() { DecimalDegrees dd = new DecimalDegrees(34.5451235); Assert.assertSame(dd, new AngleUnitsProvider().convert(DecimalDegrees.class, dd)); Assert.assertEquals(dd, new AngleUnitsProvider().convert(DecimalDegrees.class, new DegreesMinutesSeconds(34.5451235))); }
|
### Question:
AngleUnitsProvider extends AbstractUnitsProvider<Coordinates> { @Override public <T extends Coordinates> T fromUnitsAndMagnitude(Class<T> type, Number magnitude) throws InvalidUnitsException { return Coordinates.create(type, magnitude.doubleValue()); } AngleUnitsProvider(); @Override T convert(Class<T> desiredType, Coordinates source); @Override T fromUnitsAndMagnitude(Class<T> type, Number magnitude); @Override Class<? extends Coordinates> getDisplayClass(Coordinates value); @Override String getLongLabel(Class<? extends Coordinates> type, boolean plural); @Override String getSelectionLabel(Class<? extends Coordinates> type); @Override String getShortLabel(Class<? extends Coordinates> type, boolean plural); @Override Class<Coordinates> getSuperType(); @Override Class<? extends Coordinates> getUnitsWithLongLabel(String label); @Override String toShortLabelString(Coordinates obj); }### Answer:
@Test public void testFromTypeAndMagnitude() { Assert.assertEquals(new DecimalDegrees(1.), new AngleUnitsProvider().fromUnitsAndMagnitude(DecimalDegrees.class, Double.valueOf(1.))); }
|
### Question:
AngleUnitsProvider extends AbstractUnitsProvider<Coordinates> { @Override public Class<? extends Coordinates> getUnitsWithLongLabel(String label) { Lock lock = getLock(); lock.lock(); try { for (Class<? extends Coordinates> type : getAvailableUnitsUnsync()) { try { if (Coordinates.getLongLabel(type).equalsIgnoreCase(label) || Coordinates.getLongLabel(type).equalsIgnoreCase(label)) { return type; } } catch (InvalidUnitsException e) { throw new ImpossibleException(e); } } return null; } finally { lock.unlock(); } } AngleUnitsProvider(); @Override T convert(Class<T> desiredType, Coordinates source); @Override T fromUnitsAndMagnitude(Class<T> type, Number magnitude); @Override Class<? extends Coordinates> getDisplayClass(Coordinates value); @Override String getLongLabel(Class<? extends Coordinates> type, boolean plural); @Override String getSelectionLabel(Class<? extends Coordinates> type); @Override String getShortLabel(Class<? extends Coordinates> type, boolean plural); @Override Class<Coordinates> getSuperType(); @Override Class<? extends Coordinates> getUnitsWithLongLabel(String label); @Override String toShortLabelString(Coordinates obj); }### Answer:
@Test public void testGetAngleWithLongLabel() { Assert.assertEquals(DecimalDegrees.class, new AngleUnitsProvider().getUnitsWithLongLabel(DecimalDegrees.DEGREES_LONG_LABEL)); Assert.assertEquals(DegreesMinutesSeconds.class, new AngleUnitsProvider().getUnitsWithLongLabel(DegreesMinutesSeconds.DMS_LONG_LABEL)); }
|
### Question:
AngleUnitsProvider extends AbstractUnitsProvider<Coordinates> { @Override public String toShortLabelString(Coordinates obj) { return obj.toShortLabelString(); } AngleUnitsProvider(); @Override T convert(Class<T> desiredType, Coordinates source); @Override T fromUnitsAndMagnitude(Class<T> type, Number magnitude); @Override Class<? extends Coordinates> getDisplayClass(Coordinates value); @Override String getLongLabel(Class<? extends Coordinates> type, boolean plural); @Override String getSelectionLabel(Class<? extends Coordinates> type); @Override String getShortLabel(Class<? extends Coordinates> type, boolean plural); @Override Class<Coordinates> getSuperType(); @Override Class<? extends Coordinates> getUnitsWithLongLabel(String label); @Override String toShortLabelString(Coordinates obj); }### Answer:
@Test public void testToFromShortLabelString() { AngleUnitsProvider units = new AngleUnitsProvider(); DecimalDegrees input = new DecimalDegrees(34.545124); String str = units.toShortLabelString(input); Coordinates output = units.fromShortLabelString(str); Assert.assertEquals(input, output); }
|
### Question:
JAXBAngle implements JAXBWrapper<Coordinates> { @Override public Coordinates getWrappedObject() { return Coordinates.create(myUnits, myMagnitude); } JAXBAngle(Coordinates angle); protected JAXBAngle(); @Override boolean equals(Object obj); @Override Coordinates getWrappedObject(); @Override int hashCode(); }### Answer:
@Test public void test() throws JAXBException, ClassNotFoundException { Coordinates result; Element el; Coordinates testDD = new DecimalDegrees(24.352); ByteArrayOutputStream baos = new ByteArrayOutputStream(); XMLUtilities.writeXMLObject(new JAXBAngle(testDD), baos); result = XMLUtilities.readXMLObject(new ByteArrayInputStream(baos.toByteArray()), JAXBAngle.class).getWrappedObject(); Assert.assertEquals(result, testDD); baos.reset(); el = XMLUtilities.marshalJAXBableToElement(testDD); result = XMLUtilities.readJAXBableObject(el, Coordinates.class); Assert.assertEquals(result, testDD); Coordinates testDMS = new DegreesMinutesSeconds(24.352); baos.reset(); XMLUtilities.writeXMLObject(new JAXBAngle(testDMS), baos); result = XMLUtilities.readXMLObject(new ByteArrayInputStream(baos.toByteArray()), JAXBAngle.class).getWrappedObject(); Assert.assertEquals(result, testDMS); baos.reset(); el = XMLUtilities.marshalJAXBableToElement(testDMS); result = XMLUtilities.readJAXBableObject(el, Coordinates.class); Assert.assertEquals(result, testDMS); }
|
### Question:
DegreesMinutesSeconds extends Coordinates { @Override public DegreesMinutesSeconds clone() { return (DegreesMinutesSeconds)super.clone(); } DegreesMinutesSeconds(Coordinates ang); DegreesMinutesSeconds(double degrees); static int getDegrees(double angle); static int getMinutes(double angle); static double getSeconds(double angle); static String getShortLabelString(double angle, int width, int precision, char positive, char negative); @Override DegreesMinutesSeconds clone(); @Override String getLongLabel(); @Override String getShortLabel(); @Override String toShortLabelString(); @Override String toShortLabelString(char positive, char negative); @Override String toShortLabelString(int width, int precision); @Override String toShortLabelString(int width, int precision, char positive, char negative); static final String DMS_LONG_LABEL; static final String DMS_SHORT_LABEL; }### Answer:
@Test public void testClone() { Coordinates ang = new DegreesMinutesSeconds(34.54512); Assert.assertEquals(ang.getMagnitude(), ang.clone().getMagnitude(), 0.); }
|
### Question:
SystemLogTree extends FormatterPriorityTree { @Override protected void log(int priority, String tag, @NotNull String message, Throwable t) { if (skipLog(priority, tag, message, t)) { return; } System.out.print(format(priority, tag, message)); if (t != null) { t.printStackTrace(); } } SystemLogTree(); SystemLogTree(int priority); }### Answer:
@Test public void log() { SystemLogTree tree = new SystemLogTree(); tree.setFormatter(LogcatFormatter.INSTANCE); LogcatFormatter.INSTANCE.setTimeStamper(new TimeStamper("MM-dd HH:mm:ss:SSS", TimeZone.getTimeZone("GMT+2"))); }
|
### Question:
PriorityTree extends Timber.DebugTree { @Override protected boolean isLoggable(int priority) { return isLoggable("", priority); } PriorityTree(int priority); PriorityTree withFilter(@NotNull Filter f); @Override boolean isLoggable(String tag, int priority); PriorityFilter getPriorityFilter(); Filter getFilter(); }### Answer:
@Test public void testAssert() { tree = new PriorityTree(Log.ASSERT); assertThat(tree.isLoggable("", Log.VERBOSE), is(false)); assertThat(tree.isLoggable("", Log.DEBUG), is(false)); assertThat(tree.isLoggable("", Log.INFO), is(false)); assertThat(tree.isLoggable("", Log.WARN), is(false)); assertThat(tree.isLoggable("", Log.ERROR), is(false)); assertThat(tree.isLoggable("", Log.ASSERT), is(true)); }
@Test public void testVerbose() { tree = new PriorityTree(Log.VERBOSE); assertThat(tree.isLoggable("", Log.VERBOSE), is(true)); assertThat(tree.isLoggable("", Log.DEBUG), is(true)); assertThat(tree.isLoggable("", Log.INFO), is(true)); assertThat(tree.isLoggable("", Log.WARN), is(true)); assertThat(tree.isLoggable("", Log.ERROR), is(true)); assertThat(tree.isLoggable("", Log.ASSERT), is(true)); }
|
### Question:
ThrowErrorTree extends PriorityTree { @Override protected void log(int priority, String tag, @NotNull String message, Throwable t) { if (skipLog(priority, tag, message, t)) { return; } if (t != null) { throw new LogPriorityExceededError(priority, getPriorityFilter().getMinPriority(), t); } else { throw new LogPriorityExceededError(priority, getPriorityFilter().getMinPriority()); } } ThrowErrorTree(); ThrowErrorTree(int logPriority); }### Answer:
@Test public void testLog() throws Exception { ThrowErrorTree tree = new ThrowErrorTree(); Throwable testThrowable = new Throwable("test"); try { tree.log(Log.INFO, "tag", "message", testThrowable); fail("Expected LogPriorityExceededError"); } catch (LogPriorityExceededError e) { assertEquals(testThrowable, e.getCause()); } }
|
### Question:
DefaultLogFormatter implements Formatter { @Override public String format(int priority, String tag, @NotNull String message) { String prio = prioPrefixes.get(priority); if (prio == null) { prio = ""; } return prio + (tag == null ? "" : tag + " : ") + message + "\n"; } private DefaultLogFormatter(); @Override String format(int priority, String tag, @NotNull String message); static final DefaultLogFormatter INSTANCE; }### Answer:
@Test public void test() { assertThat(defaultLogFormatter.format(1, "tag", "message"), is("tag : message\n")); assertThat(defaultLogFormatter.format(2, "tag", "message"), is("V/tag : message\n")); assertThat(defaultLogFormatter.format(3, "tag", "message"), is("D/tag : message\n")); assertThat(defaultLogFormatter.format(4, "tag", "message"), is("I/tag : message\n")); assertThat(defaultLogFormatter.format(5, "tag", "message"), is("W/tag : message\n")); assertThat(defaultLogFormatter.format(6, "tag", "message"), is("E/tag : message\n")); assertThat(defaultLogFormatter.format(7, "tag", "message"), is("WTF/tag : message\n")); assertThat(defaultLogFormatter.format(8, "tag", "message"), is("tag : message\n")); }
|
### Question:
StackTraceRecorder extends Throwable { @Override public Throwable fillInStackTrace() { super.fillInStackTrace(); StackTraceElement[] original = getStackTrace(); Iterator<StackTraceElement> iterator = Arrays.asList(original).iterator(); List<StackTraceElement> filtered = new ArrayList<>(); while (iterator.hasNext()) { StackTraceElement stackTraceElement = iterator.next(); if (isTimber(stackTraceElement)) { break; } } boolean isReachedApp = false; while (iterator.hasNext()) { StackTraceElement stackTraceElement = iterator.next(); if (!isReachedApp && isTimber(stackTraceElement)) { continue; } isReachedApp = true; filtered.add(stackTraceElement); } setStackTrace(filtered.toArray(new StackTraceElement[filtered.size()])); return this; } StackTraceRecorder(String detailMessage); @Override Throwable fillInStackTrace(); }### Answer:
@Test public void testFillInStackTrace() throws Exception { final StackTraceRecorder[] stackTraceRecorderArray = new StackTraceRecorder[1]; mTestRecorderTree = new TestRecorderTree(stackTraceRecorderArray); Timber.plant(mTestRecorderTree); Timber.e("hoge"); StackTraceRecorder stackTraceRecorder = stackTraceRecorderArray[0]; assertNotNull(stackTraceRecorder); assertEquals("fr.bipi.tressence.common.StackTraceRecorderTest", stackTraceRecorder.getStackTrace()[0].getClassName()); assertEquals("testFillInStackTrace", stackTraceRecorder.getStackTrace()[0].getMethodName()); }
@Test public void testFillInStackTrace() throws Exception { final StackTraceRecorder[] stackTraceRecorderArray = new StackTraceRecorder[1]; mTestRecorderTree = new TestRecorderTree(stackTraceRecorderArray); Timber.plant(mTestRecorderTree); Timber.e("hoge"); StackTraceRecorder stackTraceRecorder = stackTraceRecorderArray[0]; assertNotNull(stackTraceRecorder); assertEquals("net.ypresto.timbertreeutils.StackTraceRecorderTest", stackTraceRecorder.getStackTrace()[0].getClassName()); assertEquals("testFillInStackTrace", stackTraceRecorder.getStackTrace()[0].getMethodName()); }
|
### Question:
TimeUtils { @Deprecated public static String timestampToDateString(long milli, String format) { Date date = new Date(milli); SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.US); sdf.setTimeZone(TimeZone.getDefault()); return sdf.format(date); } private TimeUtils(); @Deprecated static String timestampToDateString(long milli, String format); }### Answer:
@Test public void timestampToDate() { TimeZone.setDefault(TimeZone.getTimeZone("UTC")); String date = TimeUtils.timestampToDateString(1571991195000L, "yyyyMMddHHmmss"); assertThat(date, is("20191025081315")); }
|
### Question:
TagFilter implements Filter { @Override public boolean skipLog(int priority, String tag, String message, Throwable t) { return !pattern.matcher(tag).matches(); } TagFilter(String tagRegex); TagFilter(Pattern pattern); @Override boolean skipLog(int priority, String tag, String message, Throwable t); @Override boolean isLoggable(int priority, String tag); String getTagRegex(); Pattern getPattern(); }### Answer:
@Test public void skipLog() { filter = new TagFilter("Filter.*"); assertThat(filter.skipLog(0, "prout", "pouet", null), is(true)); assertThat(filter.skipLog(0, "Filter", "pouet", null), is(false)); assertThat(filter.skipLog(0, "FilterProut", "pouet", null), is(false)); filter = new TagFilter(Pattern.compile("Filter.*")); assertThat(filter.skipLog(0, "prout", "pouet", null), is(true)); assertThat(filter.skipLog(0, "Filter", "pouet", null), is(false)); assertThat(filter.skipLog(0, "FilterProut", "pouet", null), is(false)); }
|
### Question:
TagFilter implements Filter { @Override public boolean isLoggable(int priority, String tag) { return pattern.matcher(tag).matches(); } TagFilter(String tagRegex); TagFilter(Pattern pattern); @Override boolean skipLog(int priority, String tag, String message, Throwable t); @Override boolean isLoggable(int priority, String tag); String getTagRegex(); Pattern getPattern(); }### Answer:
@Test public void isLoggable() { filter = new TagFilter("Filter.*"); assertThat(filter.isLoggable(0, "prout"), is(false)); assertThat(filter.isLoggable(0, "Filter"), is(true)); assertThat(filter.isLoggable(0, "FilterProut"), is(true)); filter = new TagFilter(Pattern.compile("Filter.*")); assertThat(filter.isLoggable(0, "prout"), is(false)); assertThat(filter.isLoggable(0, "Filter"), is(true)); assertThat(filter.isLoggable(0, "FilterProut"), is(true)); }
|
### Question:
TagFilter implements Filter { public String getTagRegex() { return tagRegex; } TagFilter(String tagRegex); TagFilter(Pattern pattern); @Override boolean skipLog(int priority, String tag, String message, Throwable t); @Override boolean isLoggable(int priority, String tag); String getTagRegex(); Pattern getPattern(); }### Answer:
@Test public void getTagRegex() { filter = new TagFilter("Filter.*"); assertThat(filter.getTagRegex(), is("Filter.*")); filter = new TagFilter(Pattern.compile("Filter.*")); assertThat(filter.getTagRegex(), is("Filter.*")); }
|
### Question:
ReservoirRowSampler implements RowSampler { @Override public RelationalInputGenerator[] createSample(RelationalInputGenerator[] fileInputGenerators) throws AlgorithmConfigurationException { RelationalInputGenerator[] sampleGenerators = new RelationalInputGenerator[fileInputGenerators.length]; int i = 0; for(RelationalInputGenerator generator: fileInputGenerators){ try { ReservoirRowSample sample = new ReservoirRowSample(generator.generateNewCopy(), sampleSize); sampleGenerators[i++] = new SampleGenerator(sample); } catch (InputGenerationException e) { e.printStackTrace(); } } return sampleGenerators; } ReservoirRowSampler(int sampleSize); @Override RelationalInputGenerator[] createSample(RelationalInputGenerator[] fileInputGenerators); }### Answer:
@Test public void testCreateSample() throws Exception { RelationalInputGenerator[] inputs = new RelationalInputGenerator[1]; RelationalInputBuilder builder = new RelationalInputBuilder("testTable") .setHeader("c0", "c1", "c2"); for(int i=0; i<20; i++){ builder.addRow("a", "b", i+""); } inputs[0] = builder.build(); int sampleSize = 10; ReservoirRowSampler sampler = new ReservoirRowSampler(sampleSize); RelationalInput samples = sampler.createSample(inputs)[0].generateNewCopy(); HashSet<List<String>> set = new HashSet<>(); while(samples.hasNext()){ List<String> sample = samples.next(); assertFalse(set.contains(sample)); set.add(sample); } assertEquals(set.size(), sampleSize); }
|
### Question:
Optionals { public static <T> Optional<Collection<T>> of(Collection<T> collection) { return collection.isEmpty() ? Optional.empty() : Optional.of(collection); } static Optional<Collection<T>> of(Collection<T> collection); static Stream<T> stream(Optional<T> optional); }### Answer:
@Test public void testOfEmptyCollection() { assertThat(Optionals.of(Collections.emptyList())).isEmpty(); }
@Test public void testOfCollection() { Assert.assertThat(Optionals.of(Arrays.asList(1, 2)), isPresentAnd(hasSize(2))); Assert.assertThat(Optionals.of(Arrays.asList(1, 2)), isPresentAnd(hasItems(1, 2))); }
|
### Question:
Optionals { public static <T> Stream<T> stream(Optional<T> optional) { return optional.map(Stream::of) .orElseGet(Stream::empty); } static Optional<Collection<T>> of(Collection<T> collection); static Stream<T> stream(Optional<T> optional); }### Answer:
@Test public void testStream() { assertThat(Optionals.stream(Optional.of("foo")).count()).isEqualTo(1L); assertThat(Optionals.stream(Optional.of("foo")).findFirst()).hasValue("foo"); }
@Test public void testEmptyStream() { assertThat(Optionals.stream(Optional.empty()).count()).isEqualTo(0L); }
|
### Question:
LazyArray implements LazyMap<Integer, T> { @Deprecated @Override public Optional<T> get(Integer key) { int k = key.intValue(); return get(k); } void forEach(IntObjectBiConsumer<T> action); @Deprecated @Override void forEach(BiConsumer<Integer, T> action); @Deprecated @Override Optional<T> get(Integer key); Optional<T> get(int id); @Deprecated @Override T getOrCreate(Integer key); T getOrCreate(int id); int size(); }### Answer:
@Test(expected = IndexOutOfBoundsException.class) public void testGetElementOutOfBounds() { LazyMap<Integer, String> array = create(() -> null, 3); array.get(4); fail(); }
|
### Question:
LazyArray implements LazyMap<Integer, T> { @Deprecated @Override public T getOrCreate(Integer key) { int k = key.intValue(); return getOrCreate(k); } void forEach(IntObjectBiConsumer<T> action); @Deprecated @Override void forEach(BiConsumer<Integer, T> action); @Deprecated @Override Optional<T> get(Integer key); Optional<T> get(int id); @Deprecated @Override T getOrCreate(Integer key); T getOrCreate(int id); int size(); }### Answer:
@Test(expected = IndexOutOfBoundsException.class) public void testGetOrCreateElementOutOfBounds() { LazyMap<Integer, String> array = create(() -> null, 3); array.getOrCreate(4); fail(); }
|
### Question:
Hasher { public Hasher put(Hashable hashable) { Optional.ofNullable(hashable) .ifPresent(this::hash); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPut() { assertThat(Hasher.of(HASH_FUNCTION) .put(new TestHashable(0)) .put(new TestHashable(1)) .hash()).isEqualTo(HASH_FUNCTION.newHasher().putInt(0).putInt(1).hash()); }
|
### Question:
Hasher { public Hasher putAll(Iterable<? extends Hashable> hashables) { Optional.ofNullable(hashables) .ifPresent(this::hashAll); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPutAll() { assertThat(Hasher.of(HASH_FUNCTION) .putAll(Arrays.asList(new TestHashable(0), new TestHashable(1))) .putAll(Collections.singletonList(new TestHashable(2))) .hash()).isEqualTo(HASH_FUNCTION.newHasher().putInt(0).putInt(1).putInt(2).hash()); }
|
### Question:
Hasher { public Hasher putBoolean(boolean b) { hasher.putBoolean(b); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPutBoolean() { assertThat(Hasher.of(HASH_FUNCTION).putBoolean(true).putBoolean(false).hash()) .isEqualTo(HASH_FUNCTION.newHasher().putBoolean(true).putBoolean(false).hash()); }
|
### Question:
Hasher { public Hasher putByte(byte b) { hasher.putByte(b); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPutByte() { assertThat(Hasher.of(HASH_FUNCTION).putByte((byte) 0).putByte((byte) 1).hash()) .isEqualTo(HASH_FUNCTION.newHasher().putByte((byte) 0).putByte((byte) 1).hash()); }
|
### Question:
Hasher { public Hasher putBytes(byte[] bytes) { Optional.ofNullable(bytes) .ifPresent(hasher::putBytes); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPutBytes() { assertThat(Hasher.of(HASH_FUNCTION) .putBytes(new byte[]{0, 1}) .putBytes(new byte[]{2}) .hash()) .isEqualTo(HASH_FUNCTION.newHasher().putBytes(new byte[]{0, 1}).putBytes(new byte[]{2}) .hash()); }
|
### Question:
Hasher { public Hasher putChar(char c) { hasher.putChar(c); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPutChar() { assertThat(Hasher.of(HASH_FUNCTION).putChar('a').putChar('b').hash()) .isEqualTo(HASH_FUNCTION.newHasher().putChar('a').putChar('b').hash()); }
|
### Question:
Hasher { public Hasher putClass(Class<?> type) { Optional.ofNullable(type) .map(Class::getName) .ifPresent(hasher::putUnencodedChars); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPutClass() { assertThat(Hasher.of(HASH_FUNCTION) .putClass(HasherTest.class) .putClass(Hasher.class) .hash()) .isEqualTo(HASH_FUNCTION.newHasher().putUnencodedChars(HasherTest.class.getName()) .putUnencodedChars(Hasher.class.getName()).hash()); }
|
### Question:
Hasher { public Hasher putDouble(double d) { hasher.putDouble(d); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPutDouble() { assertThat(Hasher.of(HASH_FUNCTION).putDouble(0.0).putDouble(1.0).hash()) .isEqualTo(HASH_FUNCTION.newHasher().putDouble(0.0).putDouble(1.0).hash()); }
|
### Question:
Hasher { public Hasher putFloat(float f) { hasher.putFloat(f); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPutFloat() { assertThat(Hasher.of(HASH_FUNCTION).putFloat(0.0f).putFloat(1.0f).hash()) .isEqualTo(HASH_FUNCTION.newHasher().putFloat(0.0f).putFloat(1.0f).hash()); }
|
### Question:
Hasher { public Hasher putInt(int i) { hasher.putInt(i); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPutInt() { assertThat(Hasher.of(HASH_FUNCTION).putInt(0).putInt(1).hash()) .isEqualTo(HASH_FUNCTION.newHasher().putInt(0).putInt(1).hash()); }
|
### Question:
Hasher { public Hasher putLong(long l) { hasher.putLong(l); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPutLong() { assertThat(Hasher.of(HASH_FUNCTION).putLong(0L).putLong(1L).hash()) .isEqualTo(HASH_FUNCTION.newHasher().putLong(0L).putLong(1L).hash()); }
|
### Question:
Hasher { public Hasher putShort(short s) { hasher.putShort(s); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPutShort() { assertThat(Hasher.of(HASH_FUNCTION).putShort((short) 0).putShort((short) 1).hash()) .isEqualTo(HASH_FUNCTION.newHasher().putShort((short) 0).putShort((short) 1).hash()); }
|
### Question:
SimpleColumnCombination implements Comparable<SimpleColumnCombination> { public int getTable() { return table; } SimpleColumnCombination(int table, int[] columns); private SimpleColumnCombination(int table, int[] columns, int additionalColumn); boolean isActive(); void setActive(boolean active); long getDistinctCount(); static SimpleColumnCombination create(int table, int... columns); SimpleColumnCombination flipOff(int position); int getTable(); int getColumn(int index); int[] getColumns(); boolean startsWith(SimpleColumnCombination other); SimpleColumnCombination combineWith(SimpleColumnCombination other, Map<SimpleColumnCombination, SimpleColumnCombination> columnCombinations); int lastColumn(); @Override int hashCode(); @Override boolean equals(Object obj); @Override int compareTo(SimpleColumnCombination o); @Override String toString(); int setIndex(); void setIndex(int index); }### Answer:
@Test public void testGetTable() throws Exception { SimpleColumnCombination a = SimpleColumnCombination.create(TABLE, 2,3,4); assertThat(a.getTable(), equalTo(TABLE)); }
|
### Question:
Hasher { public Hasher putUnencodedChars(CharSequence charSequence) { Optional.ofNullable(charSequence) .ifPresent(hasher::putUnencodedChars); return this; } static Hasher of(HashFunction function); HashCode hash(); Hasher put(Hashable hashable); Hasher putAll(Iterable<? extends Hashable> hashables); Hasher putBoolean(boolean b); Hasher putByte(byte b); Hasher putBytes(byte[] bytes); Hasher putChar(char c); Hasher putClass(Class<?> type); Hasher putDouble(double d); Hasher putFloat(float f); Hasher putInt(int i); Hasher putLong(long l); Hasher putShort(short s); Hasher putUnencodedChars(CharSequence charSequence); }### Answer:
@Test public void testPutUnencodedChars() { assertThat(Hasher.of(HASH_FUNCTION) .putUnencodedChars("foo") .putUnencodedChars("bar") .hash()).isEqualTo( HASH_FUNCTION.newHasher().putUnencodedChars("foo").putUnencodedChars("bar").hash()); }
|
### Question:
JdbcUtils { public static Optional<Class<?>> getColumnClass(ResultSetMetaData metaData, int column) throws SQLException { String className = metaData.getColumnClassName(column); try { Class<?> clazz = Class.forName(className); return Optional.of(clazz); } catch (ClassNotFoundException e) { return Optional.empty(); } } static Optional<Class<?>> getColumnClass(ResultSetMetaData metaData, int column); }### Answer:
@Test public void testGetColumnClass() throws SQLException { String notExistingClassName = "foo.bar.MyClass"; doReturn(String.class.getName()).when(metaData).getColumnClassName(0); doReturn(notExistingClassName).when(metaData).getColumnClassName(1); assertThat(JdbcUtils.getColumnClass(metaData, 0)).hasValue(String.class); assertThat(JdbcUtils.getColumnClass(metaData, 1)).isEmpty(); }
|
### Question:
MathUtils { public static double divide(double dividend, double divisor) { return divisor == 0.0 ? 0.0 : dividend / divisor; } static double divide(double dividend, double divisor); static long increment(long l); static double[] max(double[] d1, double[] d2); static long multiply(long factor1, long factor2); static int roundToInt(double d); }### Answer:
@Test public void testDivide() { assertThat(MathUtils.divide(8.0, 2.0)).isEqualTo(4.0); assertThat(MathUtils.divide(0.0, 2.0)).isEqualTo(0.0); assertThat(MathUtils.divide(8.0, 0.0)).isEqualTo(0.0); }
|
### Question:
MathUtils { public static long increment(long l) { return l + 1; } static double divide(double dividend, double divisor); static long increment(long l); static double[] max(double[] d1, double[] d2); static long multiply(long factor1, long factor2); static int roundToInt(double d); }### Answer:
@Test public void testIncrement() { assertThat(MathUtils.increment(8L)).isEqualTo(9L); assertThat(MathUtils.increment(0L)).isEqualTo(1L); assertThat(MathUtils.increment(-8L)).isEqualTo(-7L); }
|
### Question:
MathUtils { public static long multiply(long factor1, long factor2) { return factor1 * factor2; } static double divide(double dividend, double divisor); static long increment(long l); static double[] max(double[] d1, double[] d2); static long multiply(long factor1, long factor2); static int roundToInt(double d); }### Answer:
@Test public void testMultiply() { assertThat(MathUtils.multiply(8L, 2L)).isEqualTo(16L); assertThat(MathUtils.multiply(0L, 2L)).isEqualTo(0L); assertThat(MathUtils.multiply(8L, 0L)).isEqualTo(0L); }
|
### Question:
NullComparator implements Comparator<T> { @Override public int compare(T o1, T o2) { if (o1 == null) { return o2 == null ? 0 : -1; } if (o2 == null) { return 1; } return underlying.compare(o1, o2); } @Override int compare(T o1, T o2); }### Answer:
@Test public void test() { Comparator<Integer> comparator = new NullComparator<>(Integer::compare); assertThat(comparator.compare(1, 2)).isEqualTo(Integer.compare(1, 2)); assertThat(comparator.compare(null, null)).isEqualTo(0); assertThat(comparator.compare(null, 1)).isLessThan(0); assertThat(comparator.compare(1, null)).isGreaterThan(0); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.