Datasets:
Minata
/
512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files
xet
Community
method2testcases
stringlengths
118
3.08k
### Question: MapTileCollisionModel extends FeatureAbstract implements MapTileCollision { @Override public CollisionGroup getCollisionGroup(String name) { return loader.getCollisionGroup(name); } MapTileCollisionModel(); @Override void prepare(FeatureProvider provider); @Override void loadCollisions(Media collisionFormulas, Media collisionGroups); @Override void loadCollisions(CollisionFormulaConfig formulasConfig, CollisionGroupConfig groupsConfig); @Override void saveCollisions(); @Override CollisionResult computeCollision(Transformable transformable, CollisionCategory category); @Override CollisionFormula getCollisionFormula(String name); @Override CollisionGroup getCollisionGroup(String name); @Override Collection<CollisionFormula> getCollisionFormulas(Tile tile); @Override Collection<CollisionFormula> getCollisionFormulas(); @Override Collection<CollisionGroup> getCollisionGroups(); @Override Media getFormulasConfig(); @Override Media getCollisionsConfig(); }### Answer: @Test void testUnknownGroup() { assertThrows(() -> mapCollision.getCollisionGroup("void"), MapTileCollisionLoader.ERROR_FORMULA + "void"); }
### Question: CollisionCategory extends NameableAbstract { @Override public String toString() { return new StringBuilder(MINIMUM_LENGTH).append(getClass().getSimpleName()) .append(" (name=") .append(getName()) .append(", axis=") .append(axis) .append(", x=") .append(x) .append(", y=") .append(y) .append(", glue=") .append(glue) .append(")") .append(System.lineSeparator()) .append(Constant.TAB) .append(groups) .toString(); } CollisionCategory(String name, Axis axis, int x, int y, boolean glue, Collection<CollisionGroup> groups); Collection<CollisionGroup> getGroups(); Collection<CollisionFormula> getFormulas(); Axis getAxis(); int getOffsetX(); int getOffsetY(); boolean isGlue(); @Override String toString(); }### Answer: @Test void testToString() { assertEquals("CollisionCategory (name=name, axis=X, x=1, y=2, glue=true)" + System.lineSeparator() + Constant.TAB + "[CollisionGroup (name=group)" + System.lineSeparator() + Constant.TAB + "[CollisionFormula (name=formula)" + System.lineSeparator() + Constant.TAB + "CollisionRange (output=X, minX=0, maxX=1, minY=2, maxY=3)" + System.lineSeparator() + Constant.TAB + "CollisionFunctionLinear (a=1.0, b=2.0)" + System.lineSeparator() + Constant.TAB + "CollisionConstraint{NORTH=[], NORTH_EAST=[], EAST=[], SOUTH_EAST=[], " + "SOUTH=[], SOUTH_WEST=[], WEST=[], NORTH_WEST=[]}" + System.lineSeparator() + "]]", category.toString()); }
### Question: TileCollidableListenerVoid { public static TileCollidableListener getInstance() { return INSTANCE; } private TileCollidableListenerVoid(); static TileCollidableListener getInstance(); }### Answer: @Test void testGetInstance() { assertNotNull(TileCollidableListenerVoid.getInstance()); } @Test void testNotify() { TileCollidableListenerVoid.getInstance().notifyTileCollided(null, null); }
### Question: CollisionRange { @Override public boolean equals(Object object) { if (this == object) { return true; } if (object == null || object.getClass() != getClass()) { return false; } final CollisionRange other = (CollisionRange) object; final boolean sameRange = maxX == other.maxX && maxY == other.maxY && minX == other.minX && minY == other.minY; return sameRange && output == other.output; } CollisionRange(Axis output, int minX, int maxX, int minY, int maxY); Axis getOutput(); int getMinX(); int getMaxX(); int getMinY(); int getMaxY(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); }### Answer: @Test void testEquals() { assertEquals(range, range); assertEquals(range, new CollisionRange(Axis.X, 0, 1, 2, 3)); assertNotEquals(range, null); assertNotEquals(range, new Object()); assertNotEquals(range, new CollisionRange(Axis.Y, 0, 1, 2, 3)); assertNotEquals(range, new CollisionRange(Axis.X, 1, 1, 2, 3)); assertNotEquals(range, new CollisionRange(Axis.X, 0, 2, 2, 3)); assertNotEquals(range, new CollisionRange(Axis.X, 0, 1, 3, 3)); assertNotEquals(range, new CollisionRange(Axis.X, 0, 1, 2, 4)); }
### Question: Resolution { @Override public String toString() { return new StringBuilder(MIN_LENGHT).append(getClass().getSimpleName()) .append(" [width=") .append(width) .append(", height=") .append(height) .append(", rate=") .append(rate) .append("]") .toString(); } Resolution(int width, int height, int rate); Resolution get2x(); Resolution get3x(); Resolution get4x(); Resolution getScaled(double factorX, double factorY); int getWidth(); int getHeight(); int getRate(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); }### Answer: @Test void testToString() { assertEquals("Resolution [width=320, height=240, rate=60]", new Resolution(320, 240, 60).toString()); }
### Question: CollisionRange { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + maxX; result = prime * result + maxY; result = prime * result + minX; result = prime * result + minY; result = prime * result + output.hashCode(); return result; } CollisionRange(Axis output, int minX, int maxX, int minY, int maxY); Axis getOutput(); int getMinX(); int getMaxX(); int getMinY(); int getMaxY(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); }### Answer: @Test void testHashCode() { assertHashEquals(range, new CollisionRange(Axis.X, 0, 1, 2, 3)); assertHashNotEquals(range, new Object()); assertHashNotEquals(range, new CollisionRange(Axis.Y, 0, 1, 2, 3)); assertHashNotEquals(range, new CollisionRange(Axis.X, 1, 1, 2, 3)); assertHashNotEquals(range, new CollisionRange(Axis.X, 0, 2, 2, 3)); assertHashNotEquals(range, new CollisionRange(Axis.X, 0, 1, 3, 3)); assertHashNotEquals(range, new CollisionRange(Axis.X, 0, 1, 2, 4)); }
### Question: CollisionRange { @Override public String toString() { return new StringBuilder(MINIMUM_LENGTH).append(CollisionRange.class.getSimpleName()) .append(" (") .append("output=") .append(output) .append(", ") .append("minX=") .append(minX) .append(", maxX=") .append(maxX) .append(", minY=") .append(minY) .append(", maxY=") .append(maxY) .append(")") .toString(); } CollisionRange(Axis output, int minX, int maxX, int minY, int maxY); Axis getOutput(); int getMinX(); int getMaxX(); int getMinY(); int getMaxY(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); }### Answer: @Test void testToString() { assertEquals("CollisionRange (output=X, minX=0, maxX=1, minY=2, maxY=3)", range.toString()); }
### Question: CollisionFunctionLinear implements CollisionFunction { @Override public int hashCode() { final int prime = 31; int result = 1; long temp; temp = Double.doubleToLongBits(a); result = prime * result + (int) (temp ^ temp >>> 32); temp = Double.doubleToLongBits(b); result = prime * result + (int) (temp ^ temp >>> 32); return result; } CollisionFunctionLinear(double a, double b); double getA(); double getB(); @Override double compute(double input); @Override int getRenderX(double input); @Override int getRenderY(double input); @Override CollisionFunctionType getType(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); }### Answer: @Test void testHashCode() { assertHashEquals(function, new CollisionFunctionLinear(2.0, 3.0)); assertHashNotEquals(function, new Object()); assertHashNotEquals(function, new CollisionFunctionLinear(1.5, 3.0)); assertHashNotEquals(function, new CollisionFunctionLinear(2.0, 3.5)); }
### Question: CollisionFunctionLinear implements CollisionFunction { @Override public boolean equals(Object object) { if (this == object) { return true; } if (object == null || object.getClass() != getClass()) { return false; } final CollisionFunctionLinear other = (CollisionFunctionLinear) object; return Double.doubleToLongBits(a) == Double.doubleToLongBits(other.a) && Double.doubleToLongBits(b) == Double.doubleToLongBits(other.b); } CollisionFunctionLinear(double a, double b); double getA(); double getB(); @Override double compute(double input); @Override int getRenderX(double input); @Override int getRenderY(double input); @Override CollisionFunctionType getType(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); }### Answer: @Test void testEquals() { assertEquals(function, function); assertEquals(function, new CollisionFunctionLinear(2.0, 3.0)); assertNotEquals(function, null); assertNotEquals(function, new Object()); assertNotEquals(function, new CollisionFunctionLinear(1.5, 3.0)); assertNotEquals(function, new CollisionFunctionLinear(2.0, 3.5)); }
### Question: CollisionFunctionLinear implements CollisionFunction { @Override public String toString() { return new StringBuilder().append(getClass().getSimpleName()) .append(" (a=") .append(a) .append(", b=") .append(b) .append(")") .toString(); } CollisionFunctionLinear(double a, double b); double getA(); double getB(); @Override double compute(double input); @Override int getRenderX(double input); @Override int getRenderY(double input); @Override CollisionFunctionType getType(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); }### Answer: @Test void testToString() { assertEquals("CollisionFunctionLinear (a=2.0, b=3.0)", function.toString()); }
### Question: TileCollidableModel extends FeatureModel implements TileCollidable, Recyclable { @Override public void removeListener(TileCollidableListener listener) { listenable.removeListener(listener); } TileCollidableModel(Services services, Setup setup); @Override void prepare(FeatureProvider provider); @Override void checkListener(Object listener); @Override void addListener(TileCollidableListener listener); @Override void removeListener(TileCollidableListener listener); @Override void update(double extrp); @Override void apply(CollisionResult result); @Override void setEnabled(boolean enabled); @Override void setEnabled(Axis axis, boolean enabled); @Override Collection<CollisionCategory> getCategories(); @Override void recycle(); }### Answer: @Test void testRemoveListener() { final Transformable transformable = createObject(new FeaturableModel(services, setup)); final AtomicReference<Tile> collided = new AtomicReference<>(); final TileCollidableListener listener = createListener(collided); collidable.checkListener(transformable); collidable.checkListener(listener); transformable.teleport(0.0, 2.0); transformable.moveLocation(1.0, 0.0, -1.0); collidable.update(1.0); assertNotNull(collided.get()); collided.set(null); collidable.removeListener(listener); collidable.update(1.0); assertNull(collided.get()); }
### Question: UtilZip { public static Collection<ZipEntry> getEntriesByExtension(File jar, String path, String extension) { Check.notNull(jar); Check.notNull(path); Check.notNull(extension); try (ZipFile zip = new ZipFile(jar)) { return checkEntries(zip, path, extension); } catch (final IOException exception) { throw new LionEngineException(exception, ERROR_OPEN_ZIP + jar.getAbsolutePath()); } } private UtilZip(); static Collection<ZipEntry> getEntriesByExtension(File jar, String path, String extension); }### Answer: @Test void testEntriesByExtension() { final File jar = Medias.create("resources.jar").getFile(); final String path = UtilZipTest.class.getPackage().getName().replace(Constant.DOT, Medias.getSeparator()); final Collection<ZipEntry> entries = UtilZip.getEntriesByExtension(jar, path, "png"); assertEquals(path + Medias.getSeparator() + "image.png", entries.iterator().next().getName()); } @Test void testEntriesByExtensionWrongJar() { assertThrows(() -> UtilZip.getEntriesByExtension(new File("void"), Constant.EMPTY_STRING, Constant.EMPTY_STRING), UtilZip.ERROR_OPEN_ZIP + new File("void").getAbsolutePath()); }
### Question: MapTileGame extends FeaturableAbstract implements MapTile, Listenable<TileSetListener> { @Override public void setTile(int tx, int ty, int number) { mapSurface.setTile(tx, ty, number); } MapTileGame(); void create(Media levelrip, int tileWidth, int tileHeight, int horizontalTiles); void create(Media levelrip); void create(Media levelrip, Media sheetsConfig); @Override void create(int tileWidth, int tileHeight, int widthInTile, int heightInTile); @Override void loadSheets(List<SpriteTiled> sheets); @Override void loadSheets(Media sheetsConfig); @Override void clear(); @Override void addListener(TileSetListener listener); @Override void removeListener(TileSetListener listener); @Override void setTile(int tx, int ty, int number); @Override Tile getTile(int tx, int ty); @Override Tile getTile(Localizable localizable, int offsetX, int offsetY); @Override Tile getTileAt(double x, double y); @Override Collection<Tile> getNeighbors(Tile tile); @Override Collection<Tile> getTilesHit(double ox, double oy, double x, double y); @Override int getInTileX(Localizable localizable); @Override int getInTileY(Localizable localizable); @Override int getInTileWidth(Surface surface); @Override int getInTileHeight(Surface surface); @Override SpriteTiled getSheet(int sheetId); @Override int getSheetsNumber(); @Override int getTilesPerSheet(); @Override int getTilesNumber(); @Override int getTileWidth(); @Override int getTileHeight(); @Override int getInTileWidth(); @Override int getInTileHeight(); @Override int getInTileRadius(); @Override boolean isCreated(); @Override int getWidth(); @Override int getHeight(); @Override Media getMedia(); }### Answer: @Test void testSetTileError() { assertThrows(() -> map.setTile(0, 0, 0), "Invalid argument: 0 is not strictly inferior to 0"); }
### Question: MapTileGame extends FeaturableAbstract implements MapTile, Listenable<TileSetListener> { @Override public void clear() { mapSurface.clear(); } MapTileGame(); void create(Media levelrip, int tileWidth, int tileHeight, int horizontalTiles); void create(Media levelrip); void create(Media levelrip, Media sheetsConfig); @Override void create(int tileWidth, int tileHeight, int widthInTile, int heightInTile); @Override void loadSheets(List<SpriteTiled> sheets); @Override void loadSheets(Media sheetsConfig); @Override void clear(); @Override void addListener(TileSetListener listener); @Override void removeListener(TileSetListener listener); @Override void setTile(int tx, int ty, int number); @Override Tile getTile(int tx, int ty); @Override Tile getTile(Localizable localizable, int offsetX, int offsetY); @Override Tile getTileAt(double x, double y); @Override Collection<Tile> getNeighbors(Tile tile); @Override Collection<Tile> getTilesHit(double ox, double oy, double x, double y); @Override int getInTileX(Localizable localizable); @Override int getInTileY(Localizable localizable); @Override int getInTileWidth(Surface surface); @Override int getInTileHeight(Surface surface); @Override SpriteTiled getSheet(int sheetId); @Override int getSheetsNumber(); @Override int getTilesPerSheet(); @Override int getTilesNumber(); @Override int getTileWidth(); @Override int getTileHeight(); @Override int getInTileWidth(); @Override int getInTileHeight(); @Override int getInTileRadius(); @Override boolean isCreated(); @Override int getWidth(); @Override int getHeight(); @Override Media getMedia(); }### Answer: @Test void testClear() { map.create(16, 16, 2, 2); map.setTile(0, 0, 0); assertNotNull(map.getTile(0, 0)); map.clear(); assertNull(map.getTile(0, 0)); }
### Question: Minimap implements Image { @Override public void prepare() { if (surface == null) { throw new LionEngineException(ERROR_SURFACE); } final Graphic g = surface.createGraphic(); final int v = map.getInTileHeight(); final int h = map.getInTileWidth(); for (int ty = 0; ty < v; ty++) { for (int tx = 0; tx < h; tx++) { final Tile tile = map.getTile(tx, ty); final ColorRgba color = getTileColor(tile); if (!NO_TILE.equals(color)) { g.setColor(color); g.drawRect(tx, v - ty - 1, 0, 0, false); } } } g.dispose(); } Minimap(MapTile map); void loadPixelConfig(Media config); void automaticColor(); void automaticColor(Media config); @Override void load(); @Override void prepare(); @Override void dispose(); @Override void render(Graphic g); @Override void setOrigin(Origin origin); @Override void setLocation(double x, double y); @Override void setLocation(Viewer viewer, Localizable localizable); @Override double getX(); @Override double getY(); @Override int getWidth(); @Override int getHeight(); @Override ImageBuffer getSurface(); @Override boolean isLoaded(); }### Answer: @Test void testNullPrepare() { final Minimap minimap = new Minimap(new MapTileGame()); assertThrows(() -> minimap.prepare(), Minimap.ERROR_SURFACE); }
### Question: ExtractorConfig { @Override public boolean equals(Object object) { if (this == object) { return true; } if (object == null || object.getClass() != getClass()) { return false; } final ExtractorConfig other = (ExtractorConfig) object; return Double.compare(extract, other.extract) == 0 && Double.compare(dropoff, other.dropoff) == 0 && capacity == other.capacity; } ExtractorConfig(double extract, double dropoff, int capacity); static ExtractorConfig imports(Configurer configurer); static ExtractorConfig imports(Xml root); static Xml exports(ExtractorConfig config); double getExtract(); double getDropOff(); int getCapacity(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final String NODE_EXTRACTOR; static final String ATT_EXTRACT; static final String ATT_DROPOFF; static final String ATT_CAPACITY; }### Answer: @Test void testEquals() { final ExtractorConfig config = new ExtractorConfig(1.0, 2.0, 3); assertEquals(config, config); assertEquals(config, new ExtractorConfig(1.0, 2.0, 3)); assertNotEquals(config, null); assertNotEquals(config, new Object()); assertNotEquals(config, new ExtractorConfig(0.0, 2.0, 3)); assertNotEquals(config, new ExtractorConfig(1.0, 0.0, 3)); assertNotEquals(config, new ExtractorConfig(1.0, 2.0, 0)); }
### Question: ExtractorConfig { @Override public int hashCode() { final int prime = 31; int result = 1; long temp; temp = Double.doubleToLongBits(extract); result = prime * result + (int) (temp ^ temp >>> 32); temp = Double.doubleToLongBits(dropoff); result = prime * result + (int) (temp ^ temp >>> 32); result = prime * result + capacity; return result; } ExtractorConfig(double extract, double dropoff, int capacity); static ExtractorConfig imports(Configurer configurer); static ExtractorConfig imports(Xml root); static Xml exports(ExtractorConfig config); double getExtract(); double getDropOff(); int getCapacity(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final String NODE_EXTRACTOR; static final String ATT_EXTRACT; static final String ATT_DROPOFF; static final String ATT_CAPACITY; }### Answer: @Test void testHashCode() { final ExtractorConfig hash = new ExtractorConfig(1.0, 2.0, 3); assertHashEquals(hash, new ExtractorConfig(1.0, 2.0, 3)); assertHashNotEquals(hash, new ExtractorConfig(0.0, 2.0, 3)); assertHashNotEquals(hash, new ExtractorConfig(1.0, 0.0, 3)); assertHashNotEquals(hash, new ExtractorConfig(1.0, 2.0, 0)); }
### Question: ExtractorConfig { @Override public String toString() { return new StringBuilder(MIN_LENGTH).append(getClass().getSimpleName()) .append(" [extract=") .append(extract) .append(", dropoff=") .append(dropoff) .append(", capacity=") .append(capacity) .append("]") .toString(); } ExtractorConfig(double extract, double dropoff, int capacity); static ExtractorConfig imports(Configurer configurer); static ExtractorConfig imports(Xml root); static Xml exports(ExtractorConfig config); double getExtract(); double getDropOff(); int getCapacity(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final String NODE_EXTRACTOR; static final String ATT_EXTRACT; static final String ATT_DROPOFF; static final String ATT_CAPACITY; }### Answer: @Test void testToString() { final ExtractorConfig config = new ExtractorConfig(1.0, 2.0, 3); assertEquals("ExtractorConfig [extract=1.0, dropoff=2.0, capacity=3]", config.toString()); }
### Question: ExtractorModel extends FeatureModel implements Extractor, Recyclable { @Override public void checkListener(Object listener) { super.checkListener(listener); if (listener instanceof ExtractorListener) { addListener((ExtractorListener) listener); } } ExtractorModel(Services services, Setup setup); @Override void prepare(FeatureProvider provider); @Override void checkListener(Object listener); @Override void addListener(ExtractorListener listener); @Override void removeListener(ExtractorListener listener); @Override void setChecker(ExtractorChecker checker); @Override void update(double extrp); @Override void startExtraction(); @Override void stopExtraction(); @Override boolean isExtracting(); @Override void setResource(Extractable extractable); @Override void setResource(String type, Tiled tiled); @Override void setResource(String type, int tx, int ty, int tw, int th); @Override void setExtractionSpeed(double count); @Override void setDropOffSpeed(double count); @Override void setCapacity(int capacity); @Override int getExtractionCapacity(); @Override double getExtractionSpeed(); @Override double getDropOffSpeed(); @Override Tiled getResourceLocation(); @Override String getResourceType(); @Override void recycle(); }### Answer: @Test void testCheckListener() { final ObjectExtractorSelf object = new ObjectExtractorSelf(services, setup); object.addFeature(new TransformableModel(services, setup)); final AtomicBoolean add = new AtomicBoolean(); final Extractor extractor = new ExtractorModel(services, setup) { @Override public void addListener(ExtractorListener listener) { add.set(true); } }; extractor.prepare(new FeaturableModel(services, setup)); assertFalse(add.get()); extractor.checkListener(object); assertTrue(add.get()); }
### Question: ExtractorModel extends FeatureModel implements Extractor, Recyclable { @Override public void removeListener(ExtractorListener listener) { listenable.removeListener(listener); } ExtractorModel(Services services, Setup setup); @Override void prepare(FeatureProvider provider); @Override void checkListener(Object listener); @Override void addListener(ExtractorListener listener); @Override void removeListener(ExtractorListener listener); @Override void setChecker(ExtractorChecker checker); @Override void update(double extrp); @Override void startExtraction(); @Override void stopExtraction(); @Override boolean isExtracting(); @Override void setResource(Extractable extractable); @Override void setResource(String type, Tiled tiled); @Override void setResource(String type, int tx, int ty, int tw, int th); @Override void setExtractionSpeed(double count); @Override void setDropOffSpeed(double count); @Override void setCapacity(int capacity); @Override int getExtractionCapacity(); @Override double getExtractionSpeed(); @Override double getDropOffSpeed(); @Override Tiled getResourceLocation(); @Override String getResourceType(); @Override void recycle(); }### Answer: @Test void testRemoveListener() { final AtomicBoolean check = new AtomicBoolean(); final Extractor extractor = new ExtractorModel(services, setup); final ExtractorListener listener = new ExtractorListenerVoid() { @Override public void notifyStartGoToRessources(String type, Tiled resourceLocation) { check.set(true); } }; extractor.addListener(listener); extractor.prepare(new FeaturableModel(services, setup)); extractor.startExtraction(); assertTrue(check.get()); extractor.removeListener(listener); check.set(false); extractor.startExtraction(); assertFalse(check.get()); }
### Question: ExtractorModel extends FeatureModel implements Extractor, Recyclable { @Override public void update(double extrp) { switch (state) { case NONE: break; case GOTO_RESOURCES: actionGoingToResources(); break; case EXTRACTING: actionExtracting(); break; case GOTO_WAREHOUSE: actionGoingToWarehouse(); break; case DROPOFF: actionDropingOff(); break; default: throw new LionEngineException(state); } } ExtractorModel(Services services, Setup setup); @Override void prepare(FeatureProvider provider); @Override void checkListener(Object listener); @Override void addListener(ExtractorListener listener); @Override void removeListener(ExtractorListener listener); @Override void setChecker(ExtractorChecker checker); @Override void update(double extrp); @Override void startExtraction(); @Override void stopExtraction(); @Override boolean isExtracting(); @Override void setResource(Extractable extractable); @Override void setResource(String type, Tiled tiled); @Override void setResource(String type, int tx, int ty, int tw, int th); @Override void setExtractionSpeed(double count); @Override void setDropOffSpeed(double count); @Override void setCapacity(int capacity); @Override int getExtractionCapacity(); @Override double getExtractionSpeed(); @Override double getDropOffSpeed(); @Override Tiled getResourceLocation(); @Override String getResourceType(); @Override void recycle(); }### Answer: @Test void testEnumFail() throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException { final ExtractorModel extractor = new ExtractorModel(services, setup); final Field field = extractor.getClass().getDeclaredField("state"); UtilReflection.setAccessible(field, true); field.set(extractor, ExtractorState.values()[5]); assertThrows(() -> extractor.update(1.0), "Unknown enum: FAIL"); }
### Question: ExtractableConfig { @Override public boolean equals(Object object) { if (this == object) { return true; } if (object == null || object.getClass() != getClass()) { return false; } final ExtractableConfig other = (ExtractableConfig) object; return type.equals(other.type) && quantity == other.quantity; } ExtractableConfig(String type, int quantity); static ExtractableConfig imports(Configurer configurer); static ExtractableConfig imports(Xml root); static Xml exports(ExtractableConfig config); String getType(); int getQuantity(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final String NODE_EXTRACTABLE; static final String ATT_QUANTITY; static final String ATT_TYPE; }### Answer: @Test void testEquals() { final ExtractableConfig config = new ExtractableConfig("gold", 1); assertEquals(config, config); assertEquals(config, new ExtractableConfig("gold", 1)); assertNotEquals(config, null); assertNotEquals(config, new Object()); assertNotEquals(config, new ExtractableConfig("wood", 1)); assertNotEquals(config, new ExtractableConfig("gold", 0)); }
### Question: ExtractableConfig { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + type.hashCode(); result = prime * result + quantity; return result; } ExtractableConfig(String type, int quantity); static ExtractableConfig imports(Configurer configurer); static ExtractableConfig imports(Xml root); static Xml exports(ExtractableConfig config); String getType(); int getQuantity(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final String NODE_EXTRACTABLE; static final String ATT_QUANTITY; static final String ATT_TYPE; }### Answer: @Test void testHashCode() { final ExtractableConfig hash = new ExtractableConfig("gold", 1); assertHashEquals(hash, new ExtractableConfig("gold", 1)); assertHashNotEquals(hash, new ExtractableConfig("wood", 1)); assertHashNotEquals(hash, new ExtractableConfig("gold", 0)); }
### Question: ExtractableConfig { @Override public String toString() { return new StringBuilder(MIN_LENGTH).append(getClass().getSimpleName()) .append(" [type=") .append(type) .append(" quantity=") .append(quantity) .append("]") .toString(); } ExtractableConfig(String type, int quantity); static ExtractableConfig imports(Configurer configurer); static ExtractableConfig imports(Xml root); static Xml exports(ExtractableConfig config); String getType(); int getQuantity(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final String NODE_EXTRACTABLE; static final String ATT_QUANTITY; static final String ATT_TYPE; }### Answer: @Test void testToString() { final ExtractableConfig config = new ExtractableConfig("gold", 1); assertEquals("ExtractableConfig [type=gold quantity=1]", config.toString()); }
### Question: MapTilePersisterModel extends FeatureAbstract implements MapTilePersister { @Override public void prepare(FeatureProvider provider) { super.prepare(provider); map = provider.getFeature(MapTileSurface.class); } MapTilePersisterModel(); @Override void prepare(FeatureProvider provider); @Override void addListener(MapTilePersisterListener listener); @Override void removeListener(MapTilePersisterListener listener); @Override void save(FileWriting output); @Override void load(FileReading input); }### Answer: @Test void testConstructor() { final MapTile map = new MapTileGame(); final MapTilePersister mapPersister = new MapTilePersisterModel(); assertNotNull(mapPersister); mapPersister.prepare(map); }
### Question: Node implements Comparable<Node> { @Override public boolean equals(Object object) { if (this == object) { return true; } if (object == null || object.getClass() != getClass()) { return false; } final Node node = (Node) object; return x == node.x && y == node.y; } Node(int x, int y); int setParent(Node parent); void setCost(double cost); void setHeuristic(double heuristic); void setDepth(int depth); int getX(); int getY(); double getCost(); Node getParent(); double getHeuristic(); int getDepth(); @Override int compareTo(Node other); @Override boolean equals(Object object); @Override int hashCode(); @Override String toString(); String toStringCoordinates(); }### Answer: @Test void testEquals() { final Node node = new Node(0, 1); node.setDepth(1); assertEquals(node, node); assertNotEquals(node, null); assertNotEquals(node, new Object()); assertEquals(node, new Node(0, 1)); assertNotEquals(node, new Node(0, 0)); assertNotEquals(node, new Node(1, 1)); assertNotEquals(node, new Node(1, 0)); }
### Question: Node implements Comparable<Node> { @Override public int hashCode() { int hash = 12; hash = hash * 17 + x; hash = hash * 31 + y; return hash; } Node(int x, int y); int setParent(Node parent); void setCost(double cost); void setHeuristic(double heuristic); void setDepth(int depth); int getX(); int getY(); double getCost(); Node getParent(); double getHeuristic(); int getDepth(); @Override int compareTo(Node other); @Override boolean equals(Object object); @Override int hashCode(); @Override String toString(); String toStringCoordinates(); }### Answer: @Test void testHashCode() { final Node hash = new Node(0, 1); assertHashEquals(hash, new Node(0, 1)); assertHashNotEquals(hash, new Object()); assertHashNotEquals(hash, new Node(0, 0)); assertHashNotEquals(hash, new Node(1, 0)); assertHashNotEquals(hash, new Node(1, 1)); }
### Question: Node implements Comparable<Node> { @Override public String toString() { return new StringBuilder(MIN_LENGTH).append(getClass().getSimpleName()) .append(" [") .append(toStringCoordinates()) .append(", depth=") .append(depth) .append(", cost=") .append(cost) .append(", heuristic=") .append(heuristic) .append(", parent=") .append(parent != null ? '{' + parent.toStringCoordinates() + '}' : null) .append("]") .toString(); } Node(int x, int y); int setParent(Node parent); void setCost(double cost); void setHeuristic(double heuristic); void setDepth(int depth); int getX(); int getY(); double getCost(); Node getParent(); double getHeuristic(); int getDepth(); @Override int compareTo(Node other); @Override boolean equals(Object object); @Override int hashCode(); @Override String toString(); String toStringCoordinates(); }### Answer: @Test void testToString() { final Node node = new Node(1, 2); assertEquals("Node [x=1, y=2, depth=0, cost=0.0, heuristic=0.0, parent=null]", node.toString()); node.setParent(node); assertEquals("Node [x=1, y=2, depth=1, cost=0.0, heuristic=0.0, parent={x=1, y=2}]", node.toString()); }
### Question: HeuristicManhattan implements Heuristic { @Override public double getCost(int sx, int sy, int dx, int dy) { return minimumCost * (Math.abs(sx - (double) dx) + Math.abs(sy - (double) dy)); } HeuristicManhattan(int minimumCost); @Override double getCost(int sx, int sy, int dx, int dy); }### Answer: @Test void testHeuristic() { final Heuristic heuristic = new HeuristicManhattan(1); assertEquals(4.0, heuristic.getCost(1, 2, 3, 4)); }
### Question: UtilFile { public static String removeExtension(String file) { Check.notNull(file); final int extensionBegin = file.lastIndexOf(Constant.DOT); if (extensionBegin > 0) { return file.substring(0, extensionBegin); } return file; } private UtilFile(); static String removeExtension(String file); static String normalizeExtension(String file, String extension); static String getExtension(String file); static String getExtension(File file); static List<File> getFiles(File directory); static List<File> getFilesByExtension(File path, String extension); static List<File> getFilesByName(File path, String name); static void deleteFile(File file); static boolean exists(String path); static boolean isFile(String path); static boolean isType(File file, String extension); }### Answer: @Test void testRemoveExtension() { assertEquals("temp", UtilFile.removeExtension("temp.tmp")); assertEquals("temp", UtilFile.removeExtension("temp.")); assertEquals("temp", UtilFile.removeExtension("temp")); } @Test void testRemoveExtensionNull() { assertThrows(() -> UtilFile.removeExtension(null), Check.ERROR_NULL); }
### Question: PathfindableConfig { public static Map<String, PathData> imports(Configurer configurer) { Check.notNull(configurer); final Xml root = configurer.getRoot(); if (!root.hasChild(NODE_PATHFINDABLE)) { return Collections.emptyMap(); } final Map<String, PathData> categories = new HashMap<>(0); final Xml nodePathfindable = root.getChild(NODE_PATHFINDABLE); final Collection<Xml> children = nodePathfindable.getChildren(NODE_PATH); for (final Xml nodePath : children) { final PathData data = importPathData(nodePath); categories.put(data.getName(), data); } children.clear(); return categories; } private PathfindableConfig(); static Map<String, PathData> imports(Configurer configurer); static Xml exports(Map<String, PathData> pathData); static PathData importPathData(Xml node); static Xml exportPathData(PathData data); static final String NODE_PATHFINDABLE; static final String NODE_PATH; static final String ATT_CATEGORY; static final String ATT_COST; static final String ATT_BLOCK; static final String NODE_MOVEMENT; }### Answer: @Test void testNoNode() { final Xml root = new Xml("test"); final Media media = Medias.create("pathfindable.xml"); root.save(media); assertTrue(PathfindableConfig.imports(new Configurer(media)).isEmpty()); assertTrue(media.getFile().delete()); }
### Question: Path { public Path() { super(); } Path(); void prependStep(int x, int y); int getLength(); int getX(int index); int getY(int index); void clear(); }### Answer: @Test void testPath() { final Path path = new Path(); assertEquals(0, path.getLength()); path.prependStep(1, 2); assertEquals(1, path.getLength()); assertEquals(1, path.getX(0)); assertEquals(2, path.getY(0)); }
### Question: Step { @Override public boolean equals(Object other) { if (other instanceof Step) { final Step o = (Step) other; return o.getX() == x && o.getY() == y; } return false; } Step(int x, int y); int getX(); int getY(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer: @Test void testEquals() { final Step step = new Step(0, 1); assertEquals(step, step); assertEquals(step, new Step(0, 1)); assertNotEquals(step, null); assertNotEquals(step, new Object()); assertNotEquals(step, new Step(0, 0)); assertNotEquals(step, new Step(1, 1)); assertNotEquals(step, new Step(1, 0)); }
### Question: Step { @Override public int hashCode() { return x * y; } Step(int x, int y); int getX(); int getY(); @Override int hashCode(); @Override boolean equals(Object other); }### Answer: @Test void testHashCode() { final Step hash = new Step(0, 1); assertHashEquals(hash, new Step(0, 1)); assertHashEquals(hash, new Step(0, 0)); assertHashEquals(hash, new Step(1, 0)); assertHashNotEquals(hash, new Object()); assertHashNotEquals(hash, new Step(1, 1)); }
### Question: Astar { public static PathFinder createPathFinder(MapTile map, int maxSearchDistance, Heuristic heuristic) { return new PathFinderImpl(map, maxSearchDistance, heuristic); } private Astar(); static PathFinder createPathFinder(MapTile map, int maxSearchDistance, Heuristic heuristic); static Heuristic createHeuristicClosest(); static Heuristic createHeuristicClosestSquared(); static Heuristic createHeuristicManhattan(int minimumCost); }### Answer: @Test void testCreatePathFinder() { final MapTileGame map = new MapTileGame(); map.addFeature(new MapTileGroupModel()); map.addFeature(new MapTilePathModel()); assertNotNull(Astar.createPathFinder(map, 1, new HeuristicClosest())); }
### Question: Astar { public static Heuristic createHeuristicClosest() { return new HeuristicClosest(); } private Astar(); static PathFinder createPathFinder(MapTile map, int maxSearchDistance, Heuristic heuristic); static Heuristic createHeuristicClosest(); static Heuristic createHeuristicClosestSquared(); static Heuristic createHeuristicManhattan(int minimumCost); }### Answer: @Test void testCreateHeuristicClosest() { assertEquals(HeuristicClosest.class, Astar.createHeuristicClosest().getClass()); }
### Question: Astar { public static Heuristic createHeuristicClosestSquared() { return new HeuristicClosestSquared(); } private Astar(); static PathFinder createPathFinder(MapTile map, int maxSearchDistance, Heuristic heuristic); static Heuristic createHeuristicClosest(); static Heuristic createHeuristicClosestSquared(); static Heuristic createHeuristicManhattan(int minimumCost); }### Answer: @Test void testCreateHeuristicClosestSquared() { assertEquals(HeuristicClosestSquared.class, Astar.createHeuristicClosestSquared().getClass()); }
### Question: Astar { public static Heuristic createHeuristicManhattan(int minimumCost) { return new HeuristicManhattan(minimumCost); } private Astar(); static PathFinder createPathFinder(MapTile map, int maxSearchDistance, Heuristic heuristic); static Heuristic createHeuristicClosest(); static Heuristic createHeuristicClosestSquared(); static Heuristic createHeuristicManhattan(int minimumCost); }### Answer: @Test void testCreateHeuristicManhattan() { assertEquals(HeuristicManhattan.class, Astar.createHeuristicManhattan(1).getClass()); }
### Question: HeuristicClosestSquared implements Heuristic { @Override public double getCost(int sx, int sy, int dx, int dy) { final double x = dx - (double) sx; final double y = dy - (double) sy; return x * x + y * y; } HeuristicClosestSquared(); @Override double getCost(int sx, int sy, int dx, int dy); }### Answer: @Test void testHeuristic() { final Heuristic heuristic = new HeuristicClosestSquared(); assertEquals(8.0, heuristic.getCost(1, 2, 3, 4)); }
### Question: TileGame implements Tile { @Override public boolean equals(Object object) { if (this == object) { return true; } if (object == null || object.getClass() != getClass()) { return false; } final TileGame other = (TileGame) object; return number == other.number && tx == other.tx && ty == other.ty; } TileGame(int number, int tx, int ty, int width, int height); void set(int number); void setSheet(int sheetId); @Override int getNumber(); @Override Integer getKey(); @Override int getSheet(); @Override Integer getSheetKey(); @Override int getInTileX(); @Override int getInTileY(); @Override int getInTileWidth(); @Override int getInTileHeight(); @Override int getWidth(); @Override int getHeight(); @Override double getX(); @Override double getY(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); }### Answer: @Test void testEquals() { final TileGame tile = new TileGame(1, 16, 25, 4, 5); assertEquals(tile, tile); assertEquals(tile, new TileGame(1, 16, 25, 4, 5)); assertEquals(tile, new TileGame(1, 16, 25, 10, 5)); assertEquals(tile, new TileGame(1, 16, 25, 4, 10)); assertNotEquals(tile, null); assertNotEquals(tile, new Object()); assertNotEquals(tile, new TileGame(0, 16, 25, 4, 5)); assertNotEquals(tile, new TileGame(1, 0, 25, 4, 5)); assertNotEquals(tile, new TileGame(1, 16, 0, 4, 5)); }
### Question: TileGame implements Tile { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + number; result = prime * result + tx; result = prime * result + ty; return result; } TileGame(int number, int tx, int ty, int width, int height); void set(int number); void setSheet(int sheetId); @Override int getNumber(); @Override Integer getKey(); @Override int getSheet(); @Override Integer getSheetKey(); @Override int getInTileX(); @Override int getInTileY(); @Override int getInTileWidth(); @Override int getInTileHeight(); @Override int getWidth(); @Override int getHeight(); @Override double getX(); @Override double getY(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); }### Answer: @Test void testHashCode() { final TileGame tile = new TileGame(1, 16, 25, 4, 5); assertHashEquals(tile, tile); assertHashEquals(tile, new TileGame(1, 16, 25, 4, 5)); assertHashEquals(tile, new TileGame(1, 16, 25, 10, 5)); assertHashEquals(tile, new TileGame(1, 16, 25, 4, 10)); assertHashNotEquals(tile, new Object()); assertHashNotEquals(tile, new TileGame(0, 16, 25, 4, 5)); assertHashNotEquals(tile, new TileGame(1, 0, 25, 4, 5)); assertHashNotEquals(tile, new TileGame(1, 16, 0, 4, 5)); }
### Question: TileGame implements Tile { @Override public String toString() { return new StringBuilder(MIN_LENGHT).append("number = ") .append(number) .append(" | tx = ") .append(tx) .append(" | ty = ") .append(ty) .toString(); } TileGame(int number, int tx, int ty, int width, int height); void set(int number); void setSheet(int sheetId); @Override int getNumber(); @Override Integer getKey(); @Override int getSheet(); @Override Integer getSheetKey(); @Override int getInTileX(); @Override int getInTileY(); @Override int getInTileWidth(); @Override int getInTileHeight(); @Override int getWidth(); @Override int getHeight(); @Override double getX(); @Override double getY(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); }### Answer: @Test void testToString() { assertEquals("number = 1 | tx = 2 | ty = 3", new TileGame(1, 2, 3, 16, 16).toString()); }
### Question: ComponentRenderable implements ComponentRenderer { @Override public void render(Graphic g, Handlables featurables) { for (final Renderable renderable : featurables.get(Renderable.class)) { renderable.render(g); } } ComponentRenderable(); @Override void render(Graphic g, Handlables featurables); }### Answer: @Test void testRenderable() { final ComponentRenderable renderable = new ComponentRenderable(); final Handler handler = new Handler(services); handler.addComponent(renderable); final Renderer object = new Renderer(services, setup); handler.add(object); assertFalse(object.isRendered()); handler.update(1.0); assertFalse(object.isRendered()); handler.render(null); assertTrue(object.isRendered()); handler.removeAll(); handler.update(1.0); }
### Question: Features { public void add(Feature feature) { if (!isAnnotated(feature)) { throw new LionEngineException(ERROR_FEATURE_NOT_ANNOTATED + feature.getClass()); } final Feature old; if ((old = typeToFeature.put(feature.getClass(), feature)) != null) { throw new LionEngineException(ERROR_FEATURE_EXISTS + feature.getClass() + WITH + old.getClass()); } checkTypeDepth(feature, feature.getClass()); features.add(feature); } Features(); void add(Feature feature); C get(Class<C> feature); boolean contains(Class<C> feature); Iterable<Feature> getFeatures(); Iterable<Class<? extends Feature>> getFeaturesType(); }### Answer: @Test void testFeatureNotAnnotated() { assertThrows(() -> features.add(new FeatureModel(services, setup)), Features.ERROR_FEATURE_NOT_ANNOTATED + FeatureModel.class); } @Test void testAddExists() { features.add(new FeatureLevel1Model(services, setup)); final String error = Features.ERROR_FEATURE_EXISTS + FeatureLevel1Model.class + Features.WITH + FeatureLevel1Model.class; assertThrows(() -> features.add(new FeatureLevel1Model(services, setup)), error); } @Test void testAddExistsDepth() { features.add(new RefreshableModel(extrp -> { })); final String error = Features.ERROR_FEATURE_EXISTS + FeatureLevel1Model.class + Features.AS + Refreshable.class + Features.WITH + RefreshableModel.class; assertThrows(() -> features.add(new FeatureLevel1Model(services, setup)), error); }
### Question: Features { public Features() { super(); } Features(); void add(Feature feature); C get(Class<C> feature); boolean contains(Class<C> feature); Iterable<Feature> getFeatures(); Iterable<Class<? extends Feature>> getFeaturesType(); }### Answer: @Test void testFeatures() { assertFalse(features.contains(Feature.class)); final Identifiable identifiable = new IdentifiableModel(); features.add(identifiable); assertEquals(identifiable, features.get(Identifiable.class)); assertEquals(identifiable, features.get(IdentifiableModel.class)); int i = 0; for (final Feature current : features.getFeatures()) { assertEquals(identifiable, current); i++; } assertEquals(1, i); i = 0; for (final Class<? extends Feature> type : features.getFeaturesType()) { assertTrue(Feature.class.isAssignableFrom(type)); i++; } assertEquals(2, i); }
### Question: Features { public <C extends Feature> C get(Class<C> feature) { final Feature found = typeToFeature.get(feature); if (found != null) { return feature.cast(found); } throw new LionEngineException(ERROR_FEATURE_NOT_FOUND + feature.getName()); } Features(); void add(Feature feature); C get(Class<C> feature); boolean contains(Class<C> feature); Iterable<Feature> getFeatures(); Iterable<Class<? extends Feature>> getFeaturesType(); }### Answer: @Test void testFeatureNotFound() { assertThrows(() -> features.get(Feature.class), "Feature not found: " + Feature.class.getName()); }
### Question: UtilFile { public static String normalizeExtension(String file, String extension) { Check.notNull(file); Check.notNull(extension); final int length = file.length() + Constant.DOT.length() + extension.length(); final StringBuilder builder = new StringBuilder(length).append(removeExtension(file)).append(Constant.DOT); if (extension.startsWith(Constant.DOT)) { builder.append(getExtension(extension)); } else { builder.append(extension); } return builder.toString(); } private UtilFile(); static String removeExtension(String file); static String normalizeExtension(String file, String extension); static String getExtension(String file); static String getExtension(File file); static List<File> getFiles(File directory); static List<File> getFilesByExtension(File path, String extension); static List<File> getFilesByName(File path, String name); static void deleteFile(File file); static boolean exists(String path); static boolean isFile(String path); static boolean isType(File file, String extension); }### Answer: @Test void testNormalizeExtension() { assertEquals("temp.tmp", UtilFile.normalizeExtension("temp", "tmp")); assertEquals("temp.tmp", UtilFile.normalizeExtension("temp", ".tmp")); assertEquals("temp.tmp", UtilFile.normalizeExtension("temp", "..tmp")); assertEquals("temp.tmp", UtilFile.normalizeExtension("temp.tmp", ".tmp")); assertEquals("temp.tmp", UtilFile.normalizeExtension("temp.txt", ".tmp")); } @Test void testNormalizeExtensionNullFile() { assertThrows(() -> UtilFile.normalizeExtension(null, ""), Check.ERROR_NULL); } @Test void testNormalizeExtensionNullExtension() { assertThrows(() -> UtilFile.normalizeExtension("", null), Check.ERROR_NULL); }
### Question: AnimationConfig { public Animation getAnimation(String name) { final Animation animation = animations.get(name); if (animation == null) { throw new LionEngineException(ERROR_NOT_FOUND + name); } return animation; } AnimationConfig(Map<String, Animation> animations); static AnimationConfig imports(Configurer configurer); static AnimationConfig imports(Xml root); static Animation createAnimation(XmlReader node); static void exports(Xml root, Animation animation); Animation getAnimation(String name); boolean hasAnimation(String name); Collection<Animation> getAnimations(); static final String NODE_ANIMATIONS; static final String NODE_ANIMATION; static final String ANIMATION_NAME; static final String ANIMATION_START; static final String ANIMATION_END; static final String ANIMATION_SPEED; static final String ANIMATION_REVERSED; static final String ANIMATION_REPEAT; }### Answer: @Test void testGetUnknownAnimation() { final AnimationConfig config = new AnimationConfig(new HashMap<>()); assertThrows(() -> config.getAnimation("void"), AnimationConfig.ERROR_NOT_FOUND + "void"); }
### Question: Attribute { public int get() { return value; } Attribute(); void increase(int step); void set(int value); int get(); }### Answer: @Test void testConstructor() { final Attribute attribute = new Attribute(); assertEquals(0, attribute.get()); }
### Question: Attribute { public void increase(int step) { value += step; } Attribute(); void increase(int step); void set(int value); int get(); }### Answer: @Test void testIncrease() { final Attribute attribute = new Attribute(); attribute.increase(2); assertEquals(2, attribute.get()); }
### Question: Attribute { public void set(int value) { this.value = value; } Attribute(); void increase(int step); void set(int value); int get(); }### Answer: @Test void testSet() { final Attribute attribute = new Attribute(); attribute.set(1); assertEquals(1, attribute.get()); }
### Question: TimedMessage implements Updatable, Renderable { public void addMessage(String message, int x, int y, long time) { messages.add(new MessageData(message, x, y, time)); hasMessage = true; } TimedMessage(Text text); void addMessage(String message, int x, int y, long time); boolean hasMessage(); @Override void update(double extrp); @Override void render(Graphic g); }### Answer: @Test void testAddMessage() { final TimedMessage message = new TimedMessage(Graphics.createText(Constant.FONT_DIALOG, 8, TextStyle.NORMAL)); assertFalse(message.hasMessage()); message.addMessage("test", 0, 0, 50L); assertTrue(message.hasMessage()); }
### Question: TimedMessage implements Updatable, Renderable { @Override public void update(double extrp) { for (final MessageData messageData : messages) { if (messageData.elapsed()) { delete.add(messageData); deleted = true; } } if (deleted) { for (final MessageData messageData : delete) { messages.remove(messageData); } hasMessage = !messages.isEmpty(); deleted = false; } } TimedMessage(Text text); void addMessage(String message, int x, int y, long time); boolean hasMessage(); @Override void update(double extrp); @Override void render(Graphic g); }### Answer: @Test void testUpdate() { final TimedMessage message = new TimedMessage(Graphics.createText(Constant.FONT_DIALOG, 8, TextStyle.NORMAL)); message.update(1.0); assertFalse(message.hasMessage()); message.addMessage("test", 0, 0, 0L); message.addMessage("test2", 0, 0, 100L); assertTrue(message.hasMessage()); message.update(1.0); assertTrue(message.hasMessage()); UtilTests.pause(25L); message.update(1.0); assertTrue(message.hasMessage()); UtilTests.pause(100L); message.update(1.0); assertFalse(message.hasMessage()); }
### Question: TimedMessage implements Updatable, Renderable { @Override public void render(Graphic g) { for (final MessageData messageData : messages) { text.draw(g, messageData.x, messageData.y, messageData.message); } } TimedMessage(Text text); void addMessage(String message, int x, int y, long time); boolean hasMessage(); @Override void update(double extrp); @Override void render(Graphic g); }### Answer: @Test void testRender() { final TimedMessage message = new TimedMessage(Graphics.createText(Constant.FONT_DIALOG, 8, TextStyle.NORMAL)); message.addMessage("test", 0, 0, 0L); final Graphic g = Graphics.createGraphic(); message.render(g); message.update(1.0); message.render(g); g.dispose(); assertFalse(message.hasMessage()); }
### Question: Cursor implements Resource, Shape, Updatable, Renderable { public void setGrid(int width, int height) { Check.superiorStrict(width, 0); Check.superiorStrict(height, 0); gridWidth = width; gridHeight = height; } Cursor(); void addImage(int id, Media media); void setInputDevice(InputDevicePointer pointer); void setViewer(Viewer viewer); void setSyncMode(boolean sync); void setSensibility(double sh, double sv); void setLocation(int x, int y); void setSurfaceId(int surfaceId); void setRenderingOffset(int ox, int oy); void setArea(int minX, int minY, int maxX, int maxY); void setGrid(int width, int height); void setVisible(boolean visible); int getClick(); boolean hasClicked(int click); boolean hasClickedOnce(int click); Integer getSurfaceId(); double getSensibilityHorizontal(); double getSensibilityVertical(); double getScreenX(); double getScreenY(); boolean isSynchronized(); @Override void load(); @Override boolean isLoaded(); @Override void dispose(); @Override void update(double extrp); @Override void render(Graphic g); @Override double getX(); @Override double getY(); @Override int getWidth(); @Override int getHeight(); }### Answer: @Test void testSetGrid() { final Cursor cursor = new Cursor(); cursor.setGrid(10, 20); assertEquals(10, cursor.getWidth()); assertEquals(20, cursor.getHeight()); }
### Question: Cursor implements Resource, Shape, Updatable, Renderable { public int getClick() { return pointer.getClick(); } Cursor(); void addImage(int id, Media media); void setInputDevice(InputDevicePointer pointer); void setViewer(Viewer viewer); void setSyncMode(boolean sync); void setSensibility(double sh, double sv); void setLocation(int x, int y); void setSurfaceId(int surfaceId); void setRenderingOffset(int ox, int oy); void setArea(int minX, int minY, int maxX, int maxY); void setGrid(int width, int height); void setVisible(boolean visible); int getClick(); boolean hasClicked(int click); boolean hasClickedOnce(int click); Integer getSurfaceId(); double getSensibilityHorizontal(); double getSensibilityVertical(); double getScreenX(); double getScreenY(); boolean isSynchronized(); @Override void load(); @Override boolean isLoaded(); @Override void dispose(); @Override void update(double extrp); @Override void render(Graphic g); @Override double getX(); @Override double getY(); @Override int getWidth(); @Override int getHeight(); }### Answer: @Test void testNoInput() { final Cursor cursor = new Cursor(); assertThrows(NullPointerException.class, () -> cursor.getClick(), null); }
### Question: Cursor implements Resource, Shape, Updatable, Renderable { public void addImage(int id, Media media) { renderer.addImage(id, media); } Cursor(); void addImage(int id, Media media); void setInputDevice(InputDevicePointer pointer); void setViewer(Viewer viewer); void setSyncMode(boolean sync); void setSensibility(double sh, double sv); void setLocation(int x, int y); void setSurfaceId(int surfaceId); void setRenderingOffset(int ox, int oy); void setArea(int minX, int minY, int maxX, int maxY); void setGrid(int width, int height); void setVisible(boolean visible); int getClick(); boolean hasClicked(int click); boolean hasClickedOnce(int click); Integer getSurfaceId(); double getSensibilityHorizontal(); double getSensibilityVertical(); double getScreenX(); double getScreenY(); boolean isSynchronized(); @Override void load(); @Override boolean isLoaded(); @Override void dispose(); @Override void update(double extrp); @Override void render(Graphic g); @Override double getX(); @Override double getY(); @Override int getWidth(); @Override int getHeight(); }### Answer: @Test void testAddExistingId() { final Cursor cursor = new Cursor(); cursor.addImage(1, Medias.create("cursor.png")); cursor.addImage(1, Medias.create("cursor.png")); }
### Question: Cursor implements Resource, Shape, Updatable, Renderable { public void setSurfaceId(int surfaceId) { renderer.setSurfaceId(surfaceId); } Cursor(); void addImage(int id, Media media); void setInputDevice(InputDevicePointer pointer); void setViewer(Viewer viewer); void setSyncMode(boolean sync); void setSensibility(double sh, double sv); void setLocation(int x, int y); void setSurfaceId(int surfaceId); void setRenderingOffset(int ox, int oy); void setArea(int minX, int minY, int maxX, int maxY); void setGrid(int width, int height); void setVisible(boolean visible); int getClick(); boolean hasClicked(int click); boolean hasClickedOnce(int click); Integer getSurfaceId(); double getSensibilityHorizontal(); double getSensibilityVertical(); double getScreenX(); double getScreenY(); boolean isSynchronized(); @Override void load(); @Override boolean isLoaded(); @Override void dispose(); @Override void update(double extrp); @Override void render(Graphic g); @Override double getX(); @Override double getY(); @Override int getWidth(); @Override int getHeight(); }### Answer: @Test void testSetSurfaceId() { final Cursor cursor = new Cursor(); cursor.addImage(1, Medias.create("cursor.png")); cursor.setSurfaceId(1); cursor.update(1.0); assertEquals(Integer.valueOf(1), cursor.getSurfaceId()); assertFalse(cursor.isLoaded()); cursor.load(); assertTrue(cursor.isLoaded()); cursor.dispose(); assertNull(cursor.getSurfaceId()); } @Test void testSetSurfaceIdUnknown() { final Cursor cursor = new Cursor(); assertThrows(() -> cursor.setSurfaceId(1), CursorRenderer.ERROR_SURFACE_ID + 1); }
### Question: Cursor implements Resource, Shape, Updatable, Renderable { public void setLocation(int x, int y) { screenX = UtilMath.clamp(x, minX, maxX); screenY = UtilMath.clamp(y, minY, maxY); } Cursor(); void addImage(int id, Media media); void setInputDevice(InputDevicePointer pointer); void setViewer(Viewer viewer); void setSyncMode(boolean sync); void setSensibility(double sh, double sv); void setLocation(int x, int y); void setSurfaceId(int surfaceId); void setRenderingOffset(int ox, int oy); void setArea(int minX, int minY, int maxX, int maxY); void setGrid(int width, int height); void setVisible(boolean visible); int getClick(); boolean hasClicked(int click); boolean hasClickedOnce(int click); Integer getSurfaceId(); double getSensibilityHorizontal(); double getSensibilityVertical(); double getScreenX(); double getScreenY(); boolean isSynchronized(); @Override void load(); @Override boolean isLoaded(); @Override void dispose(); @Override void update(double extrp); @Override void render(Graphic g); @Override double getX(); @Override double getY(); @Override int getWidth(); @Override int getHeight(); }### Answer: @Test void testSetLocation() { final Cursor cursor = new Cursor(); cursor.setLocation(1, 2); assertEquals(0.0, cursor.getX()); assertEquals(0.0, cursor.getY()); assertEquals(1.0, cursor.getScreenX()); assertEquals(2.0, cursor.getScreenY()); cursor.update(1.0); assertEquals(1.0, cursor.getX()); assertEquals(2.0, cursor.getY()); assertEquals(1.0, cursor.getScreenX()); assertEquals(2.0, cursor.getScreenY()); }
### Question: Cursor implements Resource, Shape, Updatable, Renderable { public void setViewer(Viewer viewer) { Check.notNull(pointer); this.viewer = viewer; } Cursor(); void addImage(int id, Media media); void setInputDevice(InputDevicePointer pointer); void setViewer(Viewer viewer); void setSyncMode(boolean sync); void setSensibility(double sh, double sv); void setLocation(int x, int y); void setSurfaceId(int surfaceId); void setRenderingOffset(int ox, int oy); void setArea(int minX, int minY, int maxX, int maxY); void setGrid(int width, int height); void setVisible(boolean visible); int getClick(); boolean hasClicked(int click); boolean hasClickedOnce(int click); Integer getSurfaceId(); double getSensibilityHorizontal(); double getSensibilityVertical(); double getScreenX(); double getScreenY(); boolean isSynchronized(); @Override void load(); @Override boolean isLoaded(); @Override void dispose(); @Override void update(double extrp); @Override void render(Graphic g); @Override double getX(); @Override double getY(); @Override int getWidth(); @Override int getHeight(); }### Answer: @Test void testSetViewer() { final Cursor cursor = new Cursor(); final MouseMock mouse = new MouseMock(); mouse.move(1, 2); cursor.setInputDevice(mouse); final ViewerMock viewer = new ViewerMock(); cursor.setViewer(viewer); viewer.set(100, 200); cursor.update(1.0); assertEquals(101.0, cursor.getX()); assertEquals(438.0, cursor.getY()); assertEquals(1.0, cursor.getScreenX()); assertEquals(2.0, cursor.getScreenY()); }
### Question: Cursor implements Resource, Shape, Updatable, Renderable { @Override public void render(Graphic g) { renderer.render(g); } Cursor(); void addImage(int id, Media media); void setInputDevice(InputDevicePointer pointer); void setViewer(Viewer viewer); void setSyncMode(boolean sync); void setSensibility(double sh, double sv); void setLocation(int x, int y); void setSurfaceId(int surfaceId); void setRenderingOffset(int ox, int oy); void setArea(int minX, int minY, int maxX, int maxY); void setGrid(int width, int height); void setVisible(boolean visible); int getClick(); boolean hasClicked(int click); boolean hasClickedOnce(int click); Integer getSurfaceId(); double getSensibilityHorizontal(); double getSensibilityVertical(); double getScreenX(); double getScreenY(); boolean isSynchronized(); @Override void load(); @Override boolean isLoaded(); @Override void dispose(); @Override void update(double extrp); @Override void render(Graphic g); @Override double getX(); @Override double getY(); @Override int getWidth(); @Override int getHeight(); }### Answer: @Test void testRender() { final Cursor cursor = new Cursor(); cursor.addImage(0, Medias.create("cursor.png")); cursor.load(); final Graphic g = Graphics.createGraphic(); cursor.render(g); }
### Question: SurfaceConfig { @Override public boolean equals(Object object) { if (this == object) { return true; } if (object == null || object.getClass() != getClass()) { return false; } final SurfaceConfig other = (SurfaceConfig) object; return icon.equals(other.icon) && image.equals(other.image); } SurfaceConfig(String image, String icon); static SurfaceConfig imports(Configurer configurer); static SurfaceConfig imports(Xml root); static Xml exports(SurfaceConfig config); String getImage(); Optional<String> getIcon(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final String NODE_SURFACE; static final String ATT_IMAGE; static final String ATT_ICON; }### Answer: @Test void testEquals() { final SurfaceConfig config = new SurfaceConfig("image", "icon"); assertEquals(config, config); assertEquals(config, new SurfaceConfig("image", "icon")); assertEquals(new SurfaceConfig("image", null), new SurfaceConfig("image", null)); assertNotEquals(config, null); assertNotEquals(config, new Object()); assertNotEquals(config, new SurfaceConfig("", "icon")); assertNotEquals(config, new SurfaceConfig("image", "")); assertNotEquals(new SurfaceConfig("image", "icon"), new SurfaceConfig("image", null)); assertNotEquals(new SurfaceConfig("image", null), new SurfaceConfig("image", "icon")); }
### Question: SurfaceConfig { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + image.hashCode(); result = prime * result + icon.hashCode(); return result; } SurfaceConfig(String image, String icon); static SurfaceConfig imports(Configurer configurer); static SurfaceConfig imports(Xml root); static Xml exports(SurfaceConfig config); String getImage(); Optional<String> getIcon(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final String NODE_SURFACE; static final String ATT_IMAGE; static final String ATT_ICON; }### Answer: @Test void testHashCode() { final SurfaceConfig hash = new SurfaceConfig("image", "icon"); assertHashEquals(hash, new SurfaceConfig("image", "icon")); assertHashEquals(new SurfaceConfig("image", null), new SurfaceConfig("image", null)); assertHashNotEquals(hash, new Object()); assertHashNotEquals(hash, new SurfaceConfig("", "icon")); assertHashNotEquals(hash, new SurfaceConfig("image", "")); assertHashNotEquals(new SurfaceConfig("image", "icon"), new SurfaceConfig("image", null)); assertHashNotEquals(new SurfaceConfig("image", null), new SurfaceConfig("image", "icon")); }
### Question: SurfaceConfig { @Override public String toString() { return new StringBuilder(MIN_LENGTH).append(getClass().getSimpleName()) .append(" [image=") .append(image) .append(", icon=") .append(icon.orElse(null)) .append("]") .toString(); } SurfaceConfig(String image, String icon); static SurfaceConfig imports(Configurer configurer); static SurfaceConfig imports(Xml root); static Xml exports(SurfaceConfig config); String getImage(); Optional<String> getIcon(); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final String NODE_SURFACE; static final String ATT_IMAGE; static final String ATT_ICON; }### Answer: @Test void testToString() { final SurfaceConfig config = new SurfaceConfig("image", "icon"); assertEquals("SurfaceConfig [image=image, icon=icon]", config.toString()); }
### Question: Alterable { public int increase(double extrp, int increase) { final int current = getCurrent(); final double increased = current + increase * extrp; set(increased); if (increased > max) { return max - current; } return increase; } Alterable(int max); Alterable(int max, boolean overMax); int increase(double extrp, int increase); int increase(int increase); int decrease(double extrp, int decrease); int decrease(int decrease); void fill(); void reset(); void set(int value); void setMax(int max); int getMax(); int getCurrent(); int getPercent(); int getNeeded(int value); boolean isFull(); boolean isEmpty(); boolean isEnough(int value); static final int MIN; }### Answer: @Test void testIncrease() { final Alterable alterable = new Alterable(3); alterable.increase(1); assertEquals(1, alterable.getCurrent()); alterable.increase(2.0, 1); assertEquals(3, alterable.getCurrent()); alterable.increase(1); assertEquals(3, alterable.getCurrent()); }
### Question: Alterable { public int decrease(double extrp, int decrease) { final int remain = getCurrent(); final double decreased = remain - decrease * extrp; set(decreased); if (decreased < 0) { return remain; } return decrease; } Alterable(int max); Alterable(int max, boolean overMax); int increase(double extrp, int increase); int increase(int increase); int decrease(double extrp, int decrease); int decrease(int decrease); void fill(); void reset(); void set(int value); void setMax(int max); int getMax(); int getCurrent(); int getPercent(); int getNeeded(int value); boolean isFull(); boolean isEmpty(); boolean isEnough(int value); static final int MIN; }### Answer: @Test void testDecrease() { final Alterable alterable = new Alterable(3); alterable.fill(); alterable.decrease(1); assertEquals(2, alterable.getCurrent()); alterable.decrease(2.0, 1); assertEquals(0, alterable.getCurrent()); alterable.decrease(1); assertEquals(0, alterable.getCurrent()); }
### Question: Alterable { public void fill() { cur = max; } Alterable(int max); Alterable(int max, boolean overMax); int increase(double extrp, int increase); int increase(int increase); int decrease(double extrp, int decrease); int decrease(int decrease); void fill(); void reset(); void set(int value); void setMax(int max); int getMax(); int getCurrent(); int getPercent(); int getNeeded(int value); boolean isFull(); boolean isEmpty(); boolean isEnough(int value); static final int MIN; }### Answer: @Test void testFill() { final Alterable alterable = new Alterable(4); assertEquals(0, alterable.getCurrent()); alterable.fill(); assertEquals(4, alterable.getCurrent()); }
### Question: Alterable { public void reset() { cur = Alterable.MIN; } Alterable(int max); Alterable(int max, boolean overMax); int increase(double extrp, int increase); int increase(int increase); int decrease(double extrp, int decrease); int decrease(int decrease); void fill(); void reset(); void set(int value); void setMax(int max); int getMax(); int getCurrent(); int getPercent(); int getNeeded(int value); boolean isFull(); boolean isEmpty(); boolean isEnough(int value); static final int MIN; }### Answer: @Test void testReset() { final Alterable alterable = new Alterable(4); alterable.set(2); assertEquals(2, alterable.getCurrent()); alterable.reset(); assertEquals(0, alterable.getCurrent()); }
### Question: Alterable { public void setMax(int max) { this.max = max; if (this.max < Alterable.MIN) { this.max = Alterable.MIN; } set(cur); } Alterable(int max); Alterable(int max, boolean overMax); int increase(double extrp, int increase); int increase(int increase); int decrease(double extrp, int decrease); int decrease(int decrease); void fill(); void reset(); void set(int value); void setMax(int max); int getMax(); int getCurrent(); int getPercent(); int getNeeded(int value); boolean isFull(); boolean isEmpty(); boolean isEnough(int value); static final int MIN; }### Answer: @Test void testSetMax() { final Alterable alterable = new Alterable(0); alterable.set(1); assertEquals(0, alterable.getCurrent()); alterable.setMax(2); alterable.set(1); assertEquals(1, alterable.getCurrent()); alterable.setMax(0); assertEquals(0, alterable.getCurrent()); alterable.setMax(-1); assertEquals(0, alterable.getCurrent()); assertEquals(0, alterable.getMax()); }
### Question: EngineHeadless extends Engine { public static void start(String name, Version version) { Engine.start(new EngineHeadless(name, version, Constant.EMPTY_STRING)); } EngineHeadless(String name, Version version, String resourcesDir); EngineHeadless(String name, Version version, Class<?> classResource); static void start(String name, Version version); static void start(String name, Version version, String resourcesDir); static void start(String name, Version version, Class<?> classResource); }### Answer: @Test void testDefaultAlready() { EngineHeadless.start(EngineHeadlessTest.class.getName(), Version.DEFAULT); assertThrows(() -> EngineHeadless.start(EngineHeadlessTest.class.getName(), Version.DEFAULT), "The engine has already been started !"); } @Test void testNullResources() { assertThrows(() -> EngineHeadless.start(EngineHeadlessTest.class.getName(), Version.DEFAULT, (String) null), "Unexpected null argument !"); } @Test void testResourcesAlready() { EngineHeadless.start(EngineHeadlessTest.class.getName(), Version.DEFAULT, Constant.EMPTY_STRING); assertTrue(Engine.isStarted()); assertThrows(() -> EngineHeadless.start(EngineHeadlessTest.class.getName(), Version.DEFAULT, Constant.EMPTY_STRING), "The engine has already been started !"); } @Test void testClass() { EngineHeadless.start(EngineHeadlessTest.class.getName(), Version.DEFAULT, EngineHeadlessTest.class); assertTrue(Engine.isStarted()); assertThrows(() -> EngineHeadless.start(EngineHeadlessTest.class.getName(), Version.DEFAULT, EngineHeadlessTest.class), "The engine has already been started !"); }
### Question: FactoryGraphicHeadless implements FactoryGraphic { @Override public ImageBuffer rotate(ImageBuffer image, int angle) { final Rectangle rotated = new Rectangle(0, 0, image.getWidth(), image.getHeight()); rotated.rotate(angle); return new ImageBufferHeadless(rotated.getWidth(), rotated.getHeight(), image.getTransparency()); } FactoryGraphicHeadless(); @Override Screen createScreen(Config config); @Override Graphic createGraphic(); @Override Transform createTransform(); @Override Text createText(String fontName, int size, TextStyle style); @Override ImageBuffer createImageBuffer(int width, int height); @Override ImageBuffer createImageBuffer(int width, int height, ColorRgba transparency); @Override ImageBuffer getImageBuffer(Media media); @Override ImageBuffer getImageBuffer(ImageBuffer image); @Override ImageBuffer applyMask(ImageBuffer image, ColorRgba maskColor); @Override ImageBuffer[] splitImage(ImageBuffer image, int h, int v); @Override ImageBuffer rotate(ImageBuffer image, int angle); @Override ImageBuffer resize(ImageBuffer image, int width, int height); @Override ImageBuffer flipHorizontal(ImageBuffer image); @Override ImageBuffer flipVertical(ImageBuffer image); @Override void saveImage(ImageBuffer image, Media media); @Override ImageBuffer getRasterBuffer(ImageBuffer image, double fr, double fg, double fb); }### Answer: @Test @Override protected void testRotate() { final ImageBuffer image = Graphics.getImageBuffer(Medias.create("image.png")); final ImageBuffer rotate = Graphics.rotate(image, 90); assertNotEquals(image, rotate); assertEquals(image.getWidth(), rotate.getHeight()); assertEquals(image.getHeight(), rotate.getWidth()); rotate.dispose(); image.dispose(); }
### Question: UtilFile { public static String getExtension(String file) { Check.notNull(file); String ext = Constant.EMPTY_STRING; final int i = file.lastIndexOf(Constant.DOT); if (i >= 0 && i < file.length() - 1) { ext = file.substring(i + 1).toLowerCase(Locale.ENGLISH); } return ext; } private UtilFile(); static String removeExtension(String file); static String normalizeExtension(String file, String extension); static String getExtension(String file); static String getExtension(File file); static List<File> getFiles(File directory); static List<File> getFilesByExtension(File path, String extension); static List<File> getFilesByName(File path, String name); static void deleteFile(File file); static boolean exists(String path); static boolean isFile(String path); static boolean isType(File file, String extension); }### Answer: @Test void testGetExtension() { assertEquals("", UtilFile.getExtension("tmp")); assertEquals("tmp", UtilFile.getExtension(".tmp")); assertEquals("tmp", UtilFile.getExtension("temp.tmp")); assertEquals("t", UtilFile.getExtension("temp.t")); assertEquals(Constant.EMPTY_STRING, UtilFile.getExtension("temp.")); assertEquals(Constant.EMPTY_STRING, UtilFile.getExtension("temp")); } @Test void testGetExtensionNull() { assertThrows(() -> UtilFile.getExtension((String) null), Check.ERROR_NULL); } @Test void testGetExtensionFile() { assertEquals("tmp", UtilFile.getExtension(new File("temp.tmp"))); assertEquals("t", UtilFile.getExtension(new File("toto", "temp.t"))); assertEquals(Constant.EMPTY_STRING, UtilFile.getExtension(new File("temp."))); assertEquals(Constant.EMPTY_STRING, UtilFile.getExtension(new File("temp"))); } @Test void testGetExtensionFileNull() { assertThrows(() -> UtilFile.getExtension((File) null), Check.ERROR_NULL); }
### Question: Timing { public void set(long value) { cur = value; started = true; } Timing(); void start(); void stop(); void restart(); void pause(); void unpause(); boolean elapsed(long time); long elapsed(); void set(long value); long get(); boolean isStarted(); }### Answer: @Test void testSet() { timing.set(PAUSE); assertTrue(timing.isStarted()); assertTrue(timing.elapsed(PAUSE), String.valueOf(timing.elapsed())); }
### Question: TextHeadless implements Text { @Override public void draw(Graphic g, int x, int y, String text) { draw(g, x, y, Align.LEFT, text); } TextHeadless(String fontName, int size, TextStyle style); @Override void draw(Graphic g, int x, int y, String text); @Override void draw(Graphic g, int x, int y, Align alignment, String text); @Override void render(Graphic g); @Override void setLocation(int x, int y); @Override void setText(String text); @Override void setAlign(Align align); @Override void setColor(ColorRgba color); @Override int getSize(); @Override int getLocationX(); @Override int getLocationY(); @Override int getWidth(); @Override int getHeight(); @Override int getStringWidth(Graphic g, String str); @Override int getStringHeight(Graphic g, String str); }### Answer: @Test void testBold() { final Text text = Graphics.createText(Constant.FONT_DIALOG, 12, TextStyle.BOLD); text.draw(g, 0, 0, VALUE); } @Test void testItalic() { final Text text = Graphics.createText(Constant.FONT_DIALOG, 12, TextStyle.ITALIC); text.draw(g, 0, 0, VALUE); }
### Question: UtilFile { public static List<File> getFiles(File directory) { Check.notNull(directory); if (directory.isDirectory()) { final File[] files = directory.listFiles(); if (files != null) { return Arrays.asList(files); } } throw new LionEngineException(ERROR_DIRECTORY + directory.getPath()); } private UtilFile(); static String removeExtension(String file); static String normalizeExtension(String file, String extension); static String getExtension(String file); static String getExtension(File file); static List<File> getFiles(File directory); static List<File> getFilesByExtension(File path, String extension); static List<File> getFilesByName(File path, String name); static void deleteFile(File file); static boolean exists(String path); static boolean isFile(String path); static boolean isType(File file, String extension); }### Answer: @Test void testGetFiles() throws IOException { final Path folder = Files.createTempDirectory("temp"); final Path file1 = Files.createTempFile(folder, "temp", ".tmp"); final Path file2 = Files.createTempFile(folder, "temp", ".tmp"); final File dir = folder.toFile(); final List<File> found = new ArrayList<>(UtilFile.getFiles(dir)); final List<File> expected = Arrays.asList(file1.toFile(), file2.toFile()); Collections.sort(found); Collections.sort(expected); assertEquals(expected, found); Files.delete(file1); Files.delete(file2); Files.delete(folder); } @Test void testGetFilesError() throws IOException { assertThrows(() -> UtilFile.getFiles(new File("void")), UtilFile.ERROR_DIRECTORY + "void"); } @Test void testGetFilesNull() throws IOException { assertThrows(() -> UtilFile.getFiles(new File("void") { @Override public boolean isDirectory() { return true; } @Override public File[] listFiles() { return null; } }), UtilFile.ERROR_DIRECTORY + "void"); }
### Question: UtilFile { public static List<File> getFilesByExtension(File path, String extension) { Check.notNull(path); Check.notNull(extension); final List<File> filesList = new ArrayList<>(1); getFilesByExtensionRecursive(filesList, path, extension); return filesList; } private UtilFile(); static String removeExtension(String file); static String normalizeExtension(String file, String extension); static String getExtension(String file); static String getExtension(File file); static List<File> getFiles(File directory); static List<File> getFilesByExtension(File path, String extension); static List<File> getFilesByName(File path, String name); static void deleteFile(File file); static boolean exists(String path); static boolean isFile(String path); static boolean isType(File file, String extension); }### Answer: @Test void testGetFilesByExtension() throws IOException { assertTrue(UtilFile.getFilesByExtension(new File("void"), "txt").isEmpty()); final Path folder = Files.createTempDirectory("temp"); final Path file1 = Files.createTempFile(folder, "temp", ".tmp"); final Path file2 = Files.createTempFile(folder, "temp", ".txt"); final Path folder2 = Files.createTempDirectory(folder, "temp"); final Path file3 = Files.createTempFile(folder2, "temp", ".txt"); final List<File> expected = Arrays.asList(file2.toFile(), file3.toFile()); final List<File> result = UtilFile.getFilesByExtension(folder.toFile(), "txt"); Collections.sort(expected); Collections.sort(result); assertIterableEquals(expected, result); Files.delete(file1); Files.delete(file2); Files.delete(file3); Files.delete(folder2); Files.delete(folder); }
### Question: UtilFile { public static List<File> getFilesByName(File path, String name) { Check.notNull(path); Check.notNull(name); final List<File> filesList = new ArrayList<>(1); getFilesByNameRecursive(filesList, path, name); return filesList; } private UtilFile(); static String removeExtension(String file); static String normalizeExtension(String file, String extension); static String getExtension(String file); static String getExtension(File file); static List<File> getFiles(File directory); static List<File> getFilesByExtension(File path, String extension); static List<File> getFilesByName(File path, String name); static void deleteFile(File file); static boolean exists(String path); static boolean isFile(String path); static boolean isType(File file, String extension); }### Answer: @Test void testGetFilesByName() throws IOException { assertTrue(UtilFile.getFilesByName(new File("void"), "name").isEmpty()); final Path folder = Files.createTempDirectory("temp"); final Path file1 = Files.createTempFile(folder, "temp", ".tmp"); final Path file2 = Files.createTempFile(folder, "temp", ".txt"); final Path folder2 = Files.createTempDirectory(folder, "temp"); final Path file3 = Files.createTempFile(folder2, "temp", ".tmp"); assertIterableEquals(Arrays.asList(file2.toFile()), UtilFile.getFilesByName(folder.toFile(), file2.toFile().getName())); Files.delete(file1); Files.delete(file2); Files.delete(file3); Files.delete(folder2); Files.delete(folder); }
### Question: UtilFile { public static void deleteFile(File file) { Check.notNull(file); try { Files.delete(file.toPath()); } catch (final IOException exception) { throw new LionEngineException(exception, ERROR_DELETE_FILE + file.getAbsolutePath()); } } private UtilFile(); static String removeExtension(String file); static String normalizeExtension(String file, String extension); static String getExtension(String file); static String getExtension(File file); static List<File> getFiles(File directory); static List<File> getFilesByExtension(File path, String extension); static List<File> getFilesByName(File path, String name); static void deleteFile(File file); static boolean exists(String path); static boolean isFile(String path); static boolean isType(File file, String extension); }### Answer: @Test void testDeleteFile() throws IOException { final File file = Files.createTempFile("temp", ".tmp").toFile(); assertTrue(file.exists()); UtilFile.deleteFile(file); assertFalse(file.exists()); } @Test void testDeleteFileError() throws IOException { assertThrows(() -> UtilFile.deleteFile(new File("void")), UtilFile.ERROR_DELETE_FILE + new File("void").getAbsolutePath()); }
### Question: Check { public static void notNull(Object object) { if (object == null) { throw new LionEngineException(ERROR_NULL); } } private Check(); static void superiorOrEqual(int a, int b); static void superiorOrEqual(double a, double b); static void superiorStrict(int a, int b); static void superiorStrict(double a, double b); static void inferiorOrEqual(int a, int b); static void inferiorOrEqual(double a, double b); static void inferiorStrict(int a, int b); static void inferiorStrict(double a, double b); static void different(int a, int b); static void different(double a, double b); static void equality(int a, int b); static void notNull(Object object); }### Answer: @Test void testNotNull() { Check.notNull(new Object()); } @Test void testNotNullFail() { assertThrows(() -> Check.notNull(null), Check.ERROR_NULL); }
### Question: UtilFile { public static boolean exists(String path) { return path != null && new File(path).exists(); } private UtilFile(); static String removeExtension(String file); static String normalizeExtension(String file, String extension); static String getExtension(String file); static String getExtension(File file); static List<File> getFiles(File directory); static List<File> getFilesByExtension(File path, String extension); static List<File> getFilesByName(File path, String name); static void deleteFile(File file); static boolean exists(String path); static boolean isFile(String path); static boolean isType(File file, String extension); }### Answer: @Test void testExists() throws IOException { assertFalse(UtilFile.exists(null)); final Path folder = Files.createTempDirectory("temp"); final Path file = Files.createTempFile(folder, "temp", ".tmp"); assertTrue(UtilFile.exists(folder.toFile().getPath())); assertTrue(UtilFile.exists(file.toFile().getPath())); Files.delete(file); Files.delete(folder); assertFalse(UtilFile.exists(folder.toFile().getPath())); assertFalse(UtilFile.exists(file.toFile().getPath())); }
### Question: UtilFile { public static boolean isFile(String path) { return path != null && new File(path).isFile(); } private UtilFile(); static String removeExtension(String file); static String normalizeExtension(String file, String extension); static String getExtension(String file); static String getExtension(File file); static List<File> getFiles(File directory); static List<File> getFilesByExtension(File path, String extension); static List<File> getFilesByName(File path, String name); static void deleteFile(File file); static boolean exists(String path); static boolean isFile(String path); static boolean isType(File file, String extension); }### Answer: @Test void testIsFile() throws IOException { assertFalse(UtilFile.isFile(null)); final File file = Files.createTempFile("temp", ".tmp").toFile(); assertTrue(UtilFile.isFile(file.getPath())); assertTrue(file.delete()); assertFalse(UtilFile.isFile(file.getPath())); }
### Question: UtilFile { public static boolean isType(File file, String extension) { Check.notNull(extension); if (file != null && file.isFile()) { final String current = getExtension(file); return current.equals(extension.replace(Constant.DOT, Constant.EMPTY_STRING)); } return false; } private UtilFile(); static String removeExtension(String file); static String normalizeExtension(String file, String extension); static String getExtension(String file); static String getExtension(File file); static List<File> getFiles(File directory); static List<File> getFilesByExtension(File path, String extension); static List<File> getFilesByName(File path, String name); static void deleteFile(File file); static boolean exists(String path); static boolean isFile(String path); static boolean isType(File file, String extension); }### Answer: @Test void testIsType() { assertFalse(UtilFile.isType(null, Constant.EMPTY_STRING)); assertFalse(UtilFile.isType(new File("null"), Constant.EMPTY_STRING)); assertFalse(UtilFile.isType(new File(System.getProperty("java.io.tmpdir")), Constant.EMPTY_STRING)); assertTrue(UtilFile.isType(Medias.create("file").getFile(), Constant.EMPTY_STRING)); assertTrue(UtilFile.isType(Medias.create("file1.txt").getFile(), "txt")); }
### Question: UtilChecksum { public static String getSha(byte[] bytes) { Check.notNull(bytes); final StringBuilder builder = new StringBuilder(MAX_LENGTH); for (final byte b : SHA512.digest(bytes)) { builder.append(0xFF & b); } return builder.toString(); } private UtilChecksum(); static boolean checkSha(String value, String signature); static boolean checkSha(int value, String signature); static String getSha(byte[] bytes); static String getSha(int i); static String getSha(String str); }### Answer: @Test void testEncodingEmptyNullString() { assertThrows(() -> UtilChecksum.getSha((String) null), Check.ERROR_NULL); } @Test void testEncodingEmptyNullBytes() { assertThrows(() -> UtilChecksum.getSha((byte[]) null), Check.ERROR_NULL); }
### Question: UpdatableVoid { public static Updatable getInstance() { return INSTANCE; } private UpdatableVoid(); static Updatable getInstance(); }### Answer: @Test void testGetInstance() { assertNotNull(UpdatableVoid.getInstance()); } @Test void testUpdate() { UpdatableVoid.getInstance().update(1.0); }
### Question: Range { public boolean includes(int value) { return value >= min && value <= max; } Range(); Range(int min, int max); int getMin(); int getMax(); boolean includes(int value); boolean includes(double value); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final Range INT_POSITIVE; static final Range INT_POSITIVE_STRICT; }### Answer: @Test void testIncludes() { final Range range = new Range(-1, 1); assertTrue(range.includes(0)); assertTrue(range.includes(0.0)); assertTrue(range.includes(Double.MIN_NORMAL)); assertTrue(range.includes(range.getMin())); assertTrue(range.includes(range.getMax())); assertTrue(range.includes(range.getMin() + 1)); assertTrue(range.includes(range.getMax() - 1)); assertFalse(range.includes(range.getMax() + 1)); assertFalse(range.includes(range.getMin() - 1)); assertTrue(range.includes((double) range.getMin())); assertTrue(range.includes((double) range.getMax())); assertTrue(range.includes(range.getMin() + 0.000000000000001)); assertTrue(range.includes(range.getMax() - 0.000000000000001)); assertFalse(range.includes(range.getMax() + 0.000000000000001)); assertFalse(range.includes(range.getMin() - 0.000000000000001)); }
### Question: Range { @Override public boolean equals(Object object) { if (this == object) { return true; } if (object == null || object.getClass() != getClass()) { return false; } final Range other = (Range) object; return min == other.min && max == other.max; } Range(); Range(int min, int max); int getMin(); int getMax(); boolean includes(int value); boolean includes(double value); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final Range INT_POSITIVE; static final Range INT_POSITIVE_STRICT; }### Answer: @Test void testEquals() { final Range range = new Range(1, 2); assertEquals(range, range); assertEquals(range, new Range(1, 2)); assertNotEquals(range, null); assertNotEquals(range, new Object()); assertNotEquals(range, new Range(2, 2)); assertNotEquals(range, new Range(1, 1)); }
### Question: Range { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + min; result = prime * result + max; return result; } Range(); Range(int min, int max); int getMin(); int getMax(); boolean includes(int value); boolean includes(double value); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final Range INT_POSITIVE; static final Range INT_POSITIVE_STRICT; }### Answer: @Test void testHashCode() { final Range range = new Range(1, 2); assertHashEquals(range, new Range(1, 2)); assertHashNotEquals(range, new Object()); assertHashNotEquals(range, new Range(2, 2)); assertHashNotEquals(range, new Range(1, 1)); }
### Question: Range { @Override public String toString() { return new StringBuilder(MIN_LENGHT).append(getClass().getSimpleName()) .append(" [min=") .append(min) .append(", max=") .append(max) .append("]") .toString(); } Range(); Range(int min, int max); int getMin(); int getMax(); boolean includes(int value); boolean includes(double value); @Override int hashCode(); @Override boolean equals(Object object); @Override String toString(); static final Range INT_POSITIVE; static final Range INT_POSITIVE_STRICT; }### Answer: @Test void testToString() { assertEquals("Range [min=1, max=2]", new Range(1, 2).toString()); }
### Question: DocumentFactory { public static Document createDocument() { return getDocumentFactory().newDocument(); } private DocumentFactory(); static Document createDocument(); static Document createDocument(InputStream input); static Transformer createTransformer(); }### Answer: @Test void testCreateDocument() throws IOException { assertNotNull(DocumentFactory.createDocument()); try (InputStream input = DocumentFactoryTest.class.getResourceAsStream("type.xml")) { assertNotNull(DocumentFactory.createDocument(input)); } } @Test void testCreateDocumentMalformed() throws IOException { try (InputStream input = DocumentFactoryTest.class.getResourceAsStream("malformed.xml")) { final String message = "org.xml.sax.SAXParseException; lineNumber: 4; columnNumber: 7; "; assertThrowsIo(() -> DocumentFactory.createDocument(input), message); } } @Test void testCreateDocumentNullStream() throws IOException { assertThrows(() -> DocumentFactory.createDocument(null), Check.ERROR_NULL); } @Test void testMissingFeature() throws Exception { final Object old = UtilReflection.getField(DocumentFactory.class, "documentBuilder"); final Field field = DocumentFactory.class.getDeclaredField("documentBuilder"); UtilReflection.setAccessible(field, true); field.set(DocumentFactory.class, null); final String oldFactory = System.getProperty(DocumentBuilderFactory.class.getName()); System.setProperty(DocumentBuilderFactory.class.getName(), Factory.class.getName()); try { Verbose.info("*********************************** EXPECTED VERBOSE ***********************************"); assertCause(() -> DocumentFactory.createDocument(), ParserConfigurationException.class); Verbose.info("****************************************************************************************"); } finally { if (oldFactory != null) { System.setProperty(DocumentBuilderFactory.class.getName(), oldFactory); } else { System.setProperty(DocumentBuilderFactory.class.getName(), ""); } field.set(DocumentFactory.class, old); UtilReflection.setAccessible(field, false); } }
### Question: DocumentFactory { public static Transformer createTransformer() throws TransformerConfigurationException { return getTransformerFactory().newTransformer(); } private DocumentFactory(); static Document createDocument(); static Document createDocument(InputStream input); static Transformer createTransformer(); }### Answer: @Test void testCreateTransformer() throws TransformerConfigurationException { assertNotNull(DocumentFactory.createTransformer()); assertNotNull(DocumentFactory.createTransformer()); }
### Question: Engine { public static final synchronized void start(Engine engine) { Check.notNull(engine); if (started) { throw new LionEngineException(ERROR_STARTED_ALREADY); } Verbose.info(new StringBuilder(MIN_LENGTH).append(ENGINE_STARTING) .append(Constant.ENGINE_VERSION) .append(Constant.QUOTE) .append(FOR) .append(Constant.QUOTE) .append(engine.getName()) .append(Constant.SPACE) .append(engine.getVersion()) .append(Constant.QUOTE) .toString()); Medias.setFactoryMedia(new FactoryMediaDefault()); engine.open(); Engine.engine = engine; started = true; } protected Engine(String name, Version version); static final synchronized void start(Engine engine); static final synchronized void terminate(); static final synchronized String getProgramName(); static final synchronized Version getProgramVersion(); static final boolean isStarted(); final String getName(); final Version getVersion(); }### Answer: @Test void testStart() { Engine.start(new EngineMock("name", Version.DEFAULT)); assertThrows(() -> Engine.start(new EngineMock(null, Version.DEFAULT)), Check.ERROR_NULL); assertThrows(() -> Engine.start(new EngineMock("name", null)), Check.ERROR_NULL); } @Test void testAlreadyStarted() { Engine.start(new EngineMock("name", Version.DEFAULT)); assertThrows(() -> Engine.start(new EngineMock("name", Version.DEFAULT)), Engine.ERROR_STARTED_ALREADY); }
### Question: Engine { public static final synchronized String getProgramName() { if (!started) { throw new LionEngineException(ERROR_STARTED_NOT); } return engine.getName(); } protected Engine(String name, Version version); static final synchronized void start(Engine engine); static final synchronized void terminate(); static final synchronized String getProgramName(); static final synchronized Version getProgramVersion(); static final boolean isStarted(); final String getName(); final Version getVersion(); }### Answer: @Test void testNotStartedGetProgramName() { assertThrows(() -> Engine.getProgramName(), Engine.ERROR_STARTED_NOT); }
### Question: Engine { public static final synchronized Version getProgramVersion() { if (!started) { throw new LionEngineException(ERROR_STARTED_NOT); } return engine.getVersion(); } protected Engine(String name, Version version); static final synchronized void start(Engine engine); static final synchronized void terminate(); static final synchronized String getProgramName(); static final synchronized Version getProgramVersion(); static final boolean isStarted(); final String getName(); final Version getVersion(); }### Answer: @Test void testNotStartedGetProgramVersion() { assertThrows(() -> Engine.getProgramVersion(), Engine.ERROR_STARTED_NOT); }
### Question: Engine { public static final synchronized void terminate() { if (started) { engine.close(); started = false; Verbose.info(ENGINE_TERMINATED); engine.postClose(); engine = null; } } protected Engine(String name, Version version); static final synchronized void start(Engine engine); static final synchronized void terminate(); static final synchronized String getProgramName(); static final synchronized Version getProgramVersion(); static final boolean isStarted(); final String getName(); final Version getVersion(); }### Answer: @Test void testTerminate() { Engine.terminate(); Engine.terminate(); }
### Question: AudioFactory { public static synchronized void addFormat(AudioFormat format) { Check.notNull(format); for (final String current : format.getFormats()) { if (FACTORIES.put(current, format) != null) { throw new LionEngineException(ERROR_EXISTS + current); } } } private AudioFactory(); static synchronized Audio loadAudio(Media media); static synchronized A loadAudio(Media media, Class<A> type); static synchronized void addFormat(AudioFormat format); static synchronized void clearFormats(); static final String ERROR_FORMAT; }### Answer: @Test void testAddFormatNull() { assertThrows(() -> AudioFactory.addFormat(null), "Unexpected null argument !"); } @Test void testAddFormatExists() { AudioFactory.addFormat(new AudioVoidFormat(Arrays.asList("png"))); assertThrows(() -> AudioFactory.addFormat(new AudioVoidFormat(Arrays.asList("png"))), AudioFactory.ERROR_EXISTS + "png"); }
### Question: AudioFactory { public static synchronized Audio loadAudio(Media media) { Check.notNull(media); final String extension = UtilFile.getExtension(media.getPath()); return Optional.ofNullable(FACTORIES.get(extension)) .orElseThrow(() -> new LionEngineException(media, ERROR_FORMAT)) .loadAudio(media); } private AudioFactory(); static synchronized Audio loadAudio(Media media); static synchronized A loadAudio(Media media, Class<A> type); static synchronized void addFormat(AudioFormat format); static synchronized void clearFormats(); static final String ERROR_FORMAT; }### Answer: @Test void testLoadAudioNull() { assertThrows(() -> AudioFactory.loadAudio(null), "Unexpected null argument !"); } @Test void testLoadAudioNullFormat() { assertThrows(() -> AudioFactory.loadAudio(new MediaMock(), null), "Unexpected null argument !"); } @Test void testLoadAudio() { AudioFactory.addFormat(new AudioVoidFormat(Arrays.asList("png"))); assertNotNull(AudioFactory.loadAudio(Medias.create("image.png"))); assertNotNull(AudioFactory.loadAudio(Medias.create("image.png"), Audio.class)); assertNotNull(AudioFactory.loadAudio(Medias.create("image.png"), AudioVoid.class)); } @Test void testLoadAudioInvalidType() { assertThrows(() -> AudioFactory.loadAudio(Medias.create("image.wav"), MyAudio.class), "[image.wav] " + AudioFactory.ERROR_FORMAT); }
### Question: DefaultResponseErrorHandler implements ResponseErrorHandler { @Override public boolean hasError(ClientHttpResponse response) throws IOException { HttpStatus statusCode = response.getStatusCode(); return statusCode.series() == HttpStatus.Series.CLIENT_ERROR || statusCode.series() == HttpStatus.Series.SERVER_ERROR; } @Override boolean hasError(ClientHttpResponse response); @Override void handleError(ClientHttpResponse response); }### Answer: @Test public void hasError() throws Exception { assertTrue(errorHandler.hasError(new MockClientHttpResponse(HttpStatus.INTERNAL_SERVER_ERROR))); assertTrue(errorHandler.hasError(new MockClientHttpResponse(HttpStatus.BAD_REQUEST))); assertFalse(errorHandler.hasError(new MockClientHttpResponse(HttpStatus.ACCEPTED))); }
### Question: JenkinsHttpMessageConverter implements HttpMessageConverter<Jenkins> { @Override public void write(Jenkins t, String contentType, HttpOutputMessage outputMessage) throws IOException { throw new UnsupportedOperationException(); } @Override boolean canRead(Class<?> clazz); @Override boolean canWrite(Class<?> clazz); @Override Jenkins read(Class<? extends Jenkins> clazz, HttpInputMessage inputMessage); @Override void write(Jenkins t, String contentType, HttpOutputMessage outputMessage); }### Answer: @Test(expected = UnsupportedOperationException.class) public void write() throws Exception { converter.write(new Jenkins(), null, null); }
### Question: GroovyResponseHttpMessageConverter implements HttpMessageConverter<GroovyResponse> { @Override public boolean canRead(Class<?> clazz) { return GroovyResponse.class.isAssignableFrom(clazz); } @Override boolean canRead(Class<?> clazz); @Override boolean canWrite(Class<?> clazz); @Override GroovyResponse read(Class<? extends GroovyResponse> clazz, HttpInputMessage inputMessage); @Override void write(GroovyResponse t, String contentType, HttpOutputMessage outputMessage); }### Answer: @Test public void canRead() throws Exception { assertTrue(converter.canRead(GroovyResponse.class)); assertTrue(converter.canRead(new GroovyResponse() { @Override public InputStream getInputStream() throws IOException { return null; } }.getClass())); assertFalse(converter.canRead(Object.class)); }
### Question: GroovyResponseHttpMessageConverter implements HttpMessageConverter<GroovyResponse> { @Override public boolean canWrite(Class<?> clazz) { return false; } @Override boolean canRead(Class<?> clazz); @Override boolean canWrite(Class<?> clazz); @Override GroovyResponse read(Class<? extends GroovyResponse> clazz, HttpInputMessage inputMessage); @Override void write(GroovyResponse t, String contentType, HttpOutputMessage outputMessage); }### Answer: @Test public void canWrite() throws Exception { assertFalse(converter.canWrite(GroovyResponse.class)); assertFalse(converter.canWrite(Object.class)); }