diff --git a/README.md b/README.md index 5d686e9f..8c678f9c 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,27 @@ # Java Core June 2021 -## *Nikolaev Artem* +## *Filipchik Kirill* | Number | Solution | Short description | --- | --- | --- | -| HW1 | [Console printer](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/master/src/main/java/homework_1) | The app that reads input arguments and prints them, until "error" argument | +| HW1 | [Console printer](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_1) | The app that reads input arguments and prints them, until "ошибка" argument | +| HW2 | [PyramidPrinter](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_2/pyramid_printer) | The app that reads input argument and builds pyramid base on input value | +| HW2 | [RandomCharsTable](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_2/random_chars_table) | App reads from the console width and length of the chart, strategy keyword (even or odd). Prints to the console the chart of random chars from A to Z | +| HW2 | [TrafficLight](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_2/traffic_light) | App reads current time in seconds from the console and prints the traffic light| +| HW3 | [ImmutableClass](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_3) | ImmutableClass | +| HW3 | [Tests](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/test/java/homework_2/) | HW_2 Tests | +| HW4 | [Singleton](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_4/singleton) | Singleton| +| HW4 | [CustomAnnotation](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_4/сustom_annotation) | CustomAnnotation| +| HW4 | [CustomFileReader](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_4/custom_file_reader) | CustomFileReader| +| HW4 | [Tests](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/test/java/homework_4) | HW_4 Tests| +| HW5 | [HW_5](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_5) | HW_5| +| HW5 | [PowerOfNumber](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_5/power_of_number) | PowerOfNumber| +| HW5 | [CustomRegexMatcher](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_5/custom_regex_matcher) | CustomRegexMatcher| +| HW5 | [Tests](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/test/java/homework_5) | HW_5 Tests| +| HW6 | [MapProblemsGenerator](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_6/map_problems_generator) | MapProblemsGenerator| +| HW7 | [KittenToCatFunction](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/KirillFilipchik/src/main/java/homework_7/kitten_to_cat_function) | KittenToCatFunction| -[Link to markdown giude](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) + +[Link to CodingBat](https://codingbat.com/done?user=parallaksik@gmail.com&tag=9517187513) + +[Link to markdown guide](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) diff --git a/build.gradle b/build.gradle index b91dc843..ae57fa50 100644 --- a/build.gradle +++ b/build.gradle @@ -16,4 +16,10 @@ dependencies { test { useJUnitPlatform() +} + +jar { + manifest { + attributes 'Main-Class': 'homework_4.custom_file_reader.Main' + } } \ No newline at end of file diff --git a/src/main/java/course_project/sea_battle/SeaBattleApp.java b/src/main/java/course_project/sea_battle/SeaBattleApp.java new file mode 100644 index 00000000..0016f676 --- /dev/null +++ b/src/main/java/course_project/sea_battle/SeaBattleApp.java @@ -0,0 +1,16 @@ +package course_project.sea_battle; + +import course_project.sea_battle.controller.impl.GameControllerImpl; +import course_project.sea_battle.controller.impl.IOControllerImpl; + +public class SeaBattleApp { + public static void main(String[] args) { + try { + GameControllerImpl.getInstance().start(); + } catch (Exception ex) { + ex.printStackTrace(); + } finally { + IOControllerImpl.getInstance().close(); + } + } +} diff --git a/src/main/java/course_project/sea_battle/controller/FieldController.java b/src/main/java/course_project/sea_battle/controller/FieldController.java new file mode 100644 index 00000000..69ff5317 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/FieldController.java @@ -0,0 +1,8 @@ +package course_project.sea_battle.controller; + +import course_project.sea_battle.model.Field; + +public interface FieldController { + Field instance(); + void drawFields(Field... fields); +} diff --git a/src/main/java/course_project/sea_battle/controller/FieldFillController.java b/src/main/java/course_project/sea_battle/controller/FieldFillController.java new file mode 100644 index 00000000..fcf5f9b8 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/FieldFillController.java @@ -0,0 +1,8 @@ +package course_project.sea_battle.controller; + +import course_project.sea_battle.model.Field; + +public interface FieldFillController { + void setShips(Field field); + FieldFillController setGameSetupHolder(GameSetupHolder gameSetupHolder); +} diff --git a/src/main/java/course_project/sea_battle/controller/FireController.java b/src/main/java/course_project/sea_battle/controller/FireController.java new file mode 100644 index 00000000..04e5e0bf --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/FireController.java @@ -0,0 +1,9 @@ +package course_project.sea_battle.controller; + +import course_project.sea_battle.model.CellStatus; +import course_project.sea_battle.model.Field; + +public interface FireController { + CellStatus fire(Field targetField, Field enemyField, String coordinate); + boolean checkFire(Field field, String coordinate); +} diff --git a/src/main/java/course_project/sea_battle/controller/GameController.java b/src/main/java/course_project/sea_battle/controller/GameController.java new file mode 100644 index 00000000..85ce7052 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/GameController.java @@ -0,0 +1,7 @@ +package course_project.sea_battle.controller; + +import course_project.sea_battle.model.Game; + +public interface GameController { + Game start(); +} diff --git a/src/main/java/course_project/sea_battle/controller/GameSetupHolder.java b/src/main/java/course_project/sea_battle/controller/GameSetupHolder.java new file mode 100644 index 00000000..f3db2ade --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/GameSetupHolder.java @@ -0,0 +1,7 @@ +package course_project.sea_battle.controller; + +import java.util.Map; + +public interface GameSetupHolder { + Map getMapShips(); +} diff --git a/src/main/java/course_project/sea_battle/controller/IOController.java b/src/main/java/course_project/sea_battle/controller/IOController.java new file mode 100644 index 00000000..b8a3316d --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/IOController.java @@ -0,0 +1,8 @@ +package course_project.sea_battle.controller; + +public interface IOController { + void clr(); + void close(); + String dialog(String msg); + void print(String msg); +} diff --git a/src/main/java/course_project/sea_battle/controller/ParseController.java b/src/main/java/course_project/sea_battle/controller/ParseController.java new file mode 100644 index 00000000..9ce44292 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/ParseController.java @@ -0,0 +1,6 @@ +package course_project.sea_battle.controller; + +public interface ParseController { + int[] parseCoordinate(String coordinate); + boolean isVerticalVector(String vector); +} diff --git a/src/main/java/course_project/sea_battle/controller/PlayerController.java b/src/main/java/course_project/sea_battle/controller/PlayerController.java new file mode 100644 index 00000000..97f45cc7 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/PlayerController.java @@ -0,0 +1,7 @@ +package course_project.sea_battle.controller; + +import course_project.sea_battle.model.GamePlayer; + +public interface PlayerController { + GamePlayer instance(String name); +} diff --git a/src/main/java/course_project/sea_battle/controller/ShipController.java b/src/main/java/course_project/sea_battle/controller/ShipController.java new file mode 100644 index 00000000..1af4a0de --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/ShipController.java @@ -0,0 +1,9 @@ +package course_project.sea_battle.controller; + +import course_project.sea_battle.model.Field; + +public interface ShipController { + boolean placeShip(Field field, String coordinate, String vector, int size); + boolean placeShipByCoordinate(Field field, int x, int y, boolean isVertical, int size); + boolean isAnyShipAlive(Field field); +} diff --git a/src/main/java/course_project/sea_battle/controller/impl/FieldControllerImpl.java b/src/main/java/course_project/sea_battle/controller/impl/FieldControllerImpl.java new file mode 100644 index 00000000..8ec9bd43 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/impl/FieldControllerImpl.java @@ -0,0 +1,74 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.FieldController; +import course_project.sea_battle.controller.IOController; +import course_project.sea_battle.model.CellStatus; +import course_project.sea_battle.model.Field; + +import java.util.Arrays; +import java.util.Optional; +import java.util.stream.IntStream; + +public final class FieldControllerImpl implements FieldController { + private static final String TOP = " ╔══════════╗"; + private static final String HUD = " ║ABCDEFGHIG║"; + private static final String SPLIT_TOP_LINE = "╔══╬══════════╣"; + private static final String SPLIT_BOT_LINE = "╚══╩══════════╝"; + private static final String SPLIT_COL_LINE = "║"; + + private final IOController ioController = IOControllerImpl.getInstance(); + + private FieldControllerImpl() {} + + @Override + public Field instance() { + Field field = new Field(); + this.fillWater(field); + return field; + } + + private void fillWater(Field field) { + if (field == null) return; + CellStatus[][] cells = field.getCells(); + for (CellStatus[] row : + cells) { + Arrays.fill(row, CellStatus.WATER); + } + } + + @Override + public void drawFields(Field... fields) { + Arrays.stream(fields) + .map(this::prepareForPrint) + .reduce((arr1, arr2) -> { + Arrays.setAll(arr1, i -> arr1[i] + "\t" + arr2[i]); + return arr1; + }).ifPresent(x -> Arrays.stream(x).forEach(ioController::print)); + } + + private String[] prepareForPrint(Field field) { + String[] arr = new String[field.getCells().length + 4]; + arr[0] = TOP; + arr[1] = HUD; + arr[2] = SPLIT_TOP_LINE; + arr[arr.length - 1] = SPLIT_BOT_LINE; + StringBuilder sb = new StringBuilder(); + int bound = Field.FIELD_SIZE; + IntStream.range(0, bound).forEachOrdered(i -> { + sb.append(String.format(SPLIT_COL_LINE + "%2s" + SPLIT_COL_LINE, i + 1)); + Arrays.stream(field.getCells()[i]).forEachOrdered(sb::append); + sb.append(SPLIT_COL_LINE); + arr[i + 3] = sb.toString(); + sb.setLength(0); + }); + return arr; + } + + public static FieldControllerImpl getInstance() { + return FieldControllerImpl.Holder.INSTANCE; + } + + private static class Holder { + static final FieldControllerImpl INSTANCE = new FieldControllerImpl(); + } +} diff --git a/src/main/java/course_project/sea_battle/controller/impl/FireControllerImpl.java b/src/main/java/course_project/sea_battle/controller/impl/FireControllerImpl.java new file mode 100644 index 00000000..7efb8ab4 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/impl/FireControllerImpl.java @@ -0,0 +1,50 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.FireController; +import course_project.sea_battle.model.CellStatus; +import course_project.sea_battle.model.Field; + +public final class FireControllerImpl implements FireController { + private final ValidateControllerImpl validateController = ValidateControllerImpl.getInstance(); + private final ParserControllerImpl parserController = ParserControllerImpl.getInstance(); + + private FireControllerImpl() {} + + @Override + public CellStatus fire(Field opponentField, Field radar, String coordinate) { + if (radar == null || opponentField == null) throw new RuntimeException("Поле не может быть null"); + + int[] cordXY = parserController.parseCoordinate(coordinate); + int x = cordXY[0], y = cordXY[1]; + + CellStatus cellBefore = opponentField.getCell(x, y); + CellStatus cellAfter; + if (cellBefore == CellStatus.SHIP || cellBefore == CellStatus.HIT) { + cellAfter = CellStatus.HIT; + } + else { + cellAfter = CellStatus.SHOT; + } + opponentField.setCell(x, y, cellAfter); + radar.setCell(x, y, cellAfter); + return cellAfter; + } + + @Override + public boolean checkFire(Field field, String coordinate) { + if (field == null) return false; + if (!validateController.coordinate(coordinate)) return false; + int[] cordXY = parserController.parseCoordinate(coordinate); + + return field.getCell(cordXY[0], cordXY[1]) != CellStatus.HIT + && field.getCell(cordXY[0], cordXY[1]) != CellStatus.SHOT; + } + + public static FireControllerImpl getInstance() { + return FireControllerImpl.Holder.INSTANCE; + } + + private static class Holder { + static final FireControllerImpl INSTANCE = new FireControllerImpl(); + } +} diff --git a/src/main/java/course_project/sea_battle/controller/impl/GameControllerImpl.java b/src/main/java/course_project/sea_battle/controller/impl/GameControllerImpl.java new file mode 100644 index 00000000..77bd43c0 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/impl/GameControllerImpl.java @@ -0,0 +1,121 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.*; +import course_project.sea_battle.model.CellStatus; +import course_project.sea_battle.model.Game; +import course_project.sea_battle.model.GamePlayer; + +public final class GameControllerImpl implements GameController{ + private final PlayerController playerController = PlayerControllerImpl.getInstance(); + private final IOController ioController = IOControllerImpl.getInstance(); + private final FieldFillController manualFieldFillService = ManualFieldFillController.getInstance(); + private final FieldFillController randomFieldFillController = RandomFieldFillController.getInstance(); + private final FieldController fieldController = FieldControllerImpl.getInstance(); + private final FireController fireController = FireControllerImpl.getInstance(); + private final ShipController shipController = ShipControllerImpl.getInstance(); + + private GameControllerImpl() {} + + public Game start() { + Game game = new Game(); + addPlayers(game); + setShips(game.getPlayer1()); + ioController.dialog("Позовите Следующего"); + ioController.clr(); + setShips(game.getPlayer2()); + ioController.dialog("Да начнется битва"); + ioController.clr(); + + doGame(game); + ioController.close(); + return game; + } + + private void addPlayers(Game game) { + String name1; + String name2; + do { + name1 = ioController.dialog("Введите имя первого игрока:"); + } while (name1.isEmpty()); + game.setPlayer1(playerController.instance(name1)); + do { + name2 = ioController.dialog("Введите имя второго игрока:"); + } while (name2.isEmpty()); + game.setPlayer2(playerController.instance(name2)); + } + + private void setShips(GamePlayer player) { + ioController.print(player.getName() + ", установите корабли!"); + boolean nextStep = false; + while (!nextStep) { + String answerP1 = ioController.dialog("Заполнить рандомно?(y/n):"); + if (answerP1.trim().toLowerCase().matches("y")) { + randomFieldFillController.setShips(player.getFieldPlayer()); + nextStep = true; + } else if (answerP1.trim().toLowerCase().matches("n")) { + manualFieldFillService.setShips(player.getFieldPlayer()); + nextStep = true; + } else { + ioController.print("Попробуйте еще раз"); + } + } + } + + private void doGame(Game game){ + boolean isPlayer1Move = true; + boolean isGameOver = false; + + GamePlayer playerAtk = game.getPlayer1(); + GamePlayer playerDef = game.getPlayer2(); + + while (!isGameOver) { + + if (isPlayer1Move) { + playerAtk = game.getPlayer1(); + playerDef = game.getPlayer2(); + } else { + playerAtk = game.getPlayer2(); + playerDef = game.getPlayer1(); + } + + ioController.clr(); + if (!turnResult(playerAtk, playerDef)) { + isPlayer1Move = !isPlayer1Move; + } + isGameOver = !shipController.isAnyShipAlive(playerDef.getFieldPlayer()); + } + ioController.print(playerAtk.getName() + " Выйграл!"); + ioController.print(playerDef.getName() + " Проиграл!"); + fieldController.drawFields(playerAtk.getFieldPlayer(), playerAtk.getRadarPlayer(), + playerDef.getFieldPlayer(), playerDef.getRadarPlayer()); + game.setPlayerWin(playerAtk); + } + + private boolean turnResult(GamePlayer playerAtk, GamePlayer playerDef) { + ioController.dialog(playerAtk.getName() + ", Ваш ход!"); + fieldController.drawFields(playerAtk.getFieldPlayer(), playerAtk.getRadarPlayer()); + String coordinate; + do coordinate = ioController.dialog("Координаты:"); + while (!fireController.checkFire(playerAtk.getRadarPlayer(), coordinate)); + CellStatus cellStatus = fireController.fire(playerDef.getFieldPlayer(), + playerAtk.getRadarPlayer(), + coordinate); + fieldController.drawFields(playerAtk.getFieldPlayer(), playerAtk.getRadarPlayer()); + if (cellStatus != CellStatus.HIT) { + ioController.dialog("Мимо!"); + ioController.clr(); + return false; + } else { + ioController.dialog("Попали!"); + return true; + } + } + + public static GameControllerImpl getInstance() { + return GameControllerImpl.Holder.INSTANCE; + } + + private static class Holder { + static final GameControllerImpl INSTANCE = new GameControllerImpl(); + } +} diff --git a/src/main/java/course_project/sea_battle/controller/impl/GameSetupHolderImpl.java b/src/main/java/course_project/sea_battle/controller/impl/GameSetupHolderImpl.java new file mode 100644 index 00000000..4d56cd04 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/impl/GameSetupHolderImpl.java @@ -0,0 +1,34 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.GameSetupHolder; + +import java.util.Comparator; +import java.util.Map; +import java.util.TreeMap; + +public final class GameSetupHolderImpl implements GameSetupHolder { + private final Map map; + + private GameSetupHolderImpl() { + map = new TreeMap<>(Comparator.reverseOrder()); + map.put(4, 1); + map.put(3, 2); + map.put(2, 3); + map.put(1, 4); + } + + @Override + public Map getMapShips() { + TreeMap copyMap = new TreeMap<>(Comparator.reverseOrder()); + copyMap.putAll(map); + return copyMap; + } + + public static GameSetupHolderImpl getInstance() { + return GameSetupHolderImpl.Holder.INSTANCE; + } + + private static class Holder { + static final GameSetupHolderImpl INSTANCE = new GameSetupHolderImpl(); + } +} diff --git a/src/main/java/course_project/sea_battle/controller/impl/IOControllerImpl.java b/src/main/java/course_project/sea_battle/controller/impl/IOControllerImpl.java new file mode 100644 index 00000000..075e6738 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/impl/IOControllerImpl.java @@ -0,0 +1,46 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.IOController; + +import java.util.Scanner; + +public final class IOControllerImpl implements IOController { + //только для тестов. Я не знаю как сделать иначе, теперь сканер не финален и это ужасно. + private Scanner scanner = new Scanner(System.in).useDelimiter("\n"); + + @Override + public String dialog(String msg) { + System.out.println(msg); + return scanner.nextLine(); + } + + @Override + public void clr() { + print("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"); + } + + @Override + public void print(String msg) { + System.out.println(msg); + } + + @Override + public void close() { + scanner.close(); + } + + //только для тестов. Я не знаю как сделать иначе + public void setScanner(Scanner scanner) { + this.scanner = scanner; + } + + private IOControllerImpl() {} + + public static IOControllerImpl getInstance() { + return IOControllerImpl.Holder.INSTANCE; + } + + private static class Holder { + static final IOControllerImpl INSTANCE = new IOControllerImpl(); + } +} diff --git a/src/main/java/course_project/sea_battle/controller/impl/ManualFieldFillController.java b/src/main/java/course_project/sea_battle/controller/impl/ManualFieldFillController.java new file mode 100644 index 00000000..e9223896 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/impl/ManualFieldFillController.java @@ -0,0 +1,54 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.FieldController; +import course_project.sea_battle.controller.FieldFillController; +import course_project.sea_battle.controller.GameSetupHolder; +import course_project.sea_battle.controller.ShipController; +import course_project.sea_battle.model.Field; + +import java.util.*; + +public final class ManualFieldFillController implements FieldFillController { + private final ShipController shipController = ShipControllerImpl.getInstance(); + private final IOControllerImpl ioController = IOControllerImpl.getInstance(); + private final FieldController fieldController = FieldControllerImpl.getInstance(); + // я нарушаю свою идею тут, но так проще тестить + private GameSetupHolder gameSetupHolder = GameSetupHolderImpl.getInstance(); + + private ManualFieldFillController() { + } + + @Override + public void setShips(Field field) { + Map mapShips = gameSetupHolder.getMapShips(); + for (Map.Entry entry : mapShips.entrySet()) { + setShipsByType(field, entry); + } + } + + private void setShipsByType(Field field, Map.Entry entry) { + String coordinate; + String vector; + ioController.print("Введите " + entry.getKey() + " палубных коробля. Количество: " + entry.getValue()); + for (int i = 0; i < entry.getValue(); i++) { + do { + coordinate = ioController.dialog("Введите координаты\n(Exemple: a1):"); + vector = ioController.dialog("Введите направление(v/g):"); + } while (!shipController.placeShip(field, coordinate, vector, entry.getKey())); + fieldController.drawFields(field); + } + } + + public FieldFillController setGameSetupHolder(GameSetupHolder gameSetupHolder) { + this.gameSetupHolder = gameSetupHolder; + return this; + } + + public static ManualFieldFillController getInstance() { + return ManualFieldFillController.Holder.INSTANCE; + } + + private static class Holder { + static final ManualFieldFillController INSTANCE = new ManualFieldFillController(); + } +} diff --git a/src/main/java/course_project/sea_battle/controller/impl/ParserControllerImpl.java b/src/main/java/course_project/sea_battle/controller/impl/ParserControllerImpl.java new file mode 100644 index 00000000..ce641372 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/impl/ParserControllerImpl.java @@ -0,0 +1,27 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.ParseController; + +public final class ParserControllerImpl implements ParseController { + private ParserControllerImpl() {} + + @Override + public int[] parseCoordinate(String coordinate) { + int x = coordinate.toLowerCase().charAt(0) - 'a'; + int y = Integer.parseInt(coordinate.toLowerCase().substring(1)) - 1; + return new int[]{x, y}; + } + + @Override + public boolean isVerticalVector(String vector) { + return vector.equalsIgnoreCase("v"); + } + + public static ParserControllerImpl getInstance() { + return ParserControllerImpl.Holder.INSTANCE; + } + + private static class Holder { + static final ParserControllerImpl INSTANCE = new ParserControllerImpl(); + } +} diff --git a/src/main/java/course_project/sea_battle/controller/impl/PlayerControllerImpl.java b/src/main/java/course_project/sea_battle/controller/impl/PlayerControllerImpl.java new file mode 100644 index 00000000..7dcbbcc8 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/impl/PlayerControllerImpl.java @@ -0,0 +1,26 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.FieldController; +import course_project.sea_battle.controller.PlayerController; +import course_project.sea_battle.model.GamePlayer; + +public final class PlayerControllerImpl implements PlayerController { + private final FieldController fieldController = FieldControllerImpl.getInstance(); + private PlayerControllerImpl() {} + + @Override + public GamePlayer instance(String name) { + GamePlayer player = new GamePlayer(name); + player.setFieldPlayer(fieldController.instance()); + player.setRadarPlayer(fieldController.instance()); + return player; + } + + public static PlayerControllerImpl getInstance() { + return PlayerControllerImpl.Holder.INSTANCE; + } + + private static class Holder { + static final PlayerControllerImpl INSTANCE = new PlayerControllerImpl(); + } +} diff --git a/src/main/java/course_project/sea_battle/controller/impl/RandomFieldFillController.java b/src/main/java/course_project/sea_battle/controller/impl/RandomFieldFillController.java new file mode 100644 index 00000000..061d1cc1 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/impl/RandomFieldFillController.java @@ -0,0 +1,50 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.FieldController; +import course_project.sea_battle.controller.GameSetupHolder; +import course_project.sea_battle.controller.FieldFillController; +import course_project.sea_battle.controller.ShipController; +import course_project.sea_battle.model.Field; + +import java.util.Map; +import java.util.Random; + +public final class RandomFieldFillController implements FieldFillController { + private final ShipController shipController = ShipControllerImpl.getInstance(); + // я нарушаю свою идею тут, но так проще тестить + private GameSetupHolder gameSetupHolder = GameSetupHolderImpl.getInstance(); + private final FieldController fieldController = FieldControllerImpl.getInstance(); + + private RandomFieldFillController() {} + + @Override + public void setShips(Field field) { + Random random = new Random(); + for (Map.Entry entry : + gameSetupHolder.getMapShips().entrySet()) { + for (int i = 0; i < entry.getValue(); i++) { + while (!shipController.placeShipByCoordinate( + field, + random.nextInt(9), + random.nextInt(9), + random.nextBoolean(), + entry.getKey())); + } + } + fieldController.drawFields(field); + } + + @Override + public FieldFillController setGameSetupHolder(GameSetupHolder gameSetupHolder) { + this.gameSetupHolder = gameSetupHolder; + return this; + } + + public static RandomFieldFillController getInstance() { + return RandomFieldFillController.Holder.INSTANCE; + } + + private static class Holder { + static final RandomFieldFillController INSTANCE = new RandomFieldFillController(); + } +} diff --git a/src/main/java/course_project/sea_battle/controller/impl/ShipControllerImpl.java b/src/main/java/course_project/sea_battle/controller/impl/ShipControllerImpl.java new file mode 100644 index 00000000..5e00a013 --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/impl/ShipControllerImpl.java @@ -0,0 +1,142 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.ShipController; +import course_project.sea_battle.model.CellStatus; +import course_project.sea_battle.model.Field; + +import java.util.Arrays; + +public final class ShipControllerImpl implements ShipController { + private final ValidateControllerImpl validateController = ValidateControllerImpl.getInstance(); + private final ParserControllerImpl parserController = ParserControllerImpl.getInstance(); + + private ShipControllerImpl() {} + + @Override + public boolean placeShip(Field field, String coordinate, String vector, int size) { + if (!validateController.coordinate(coordinate)) return false; + if (!validateController.vector(vector)) return false; + + int[] cordXY = parserController.parseCoordinate(coordinate); + int x = cordXY[0], y = cordXY[1]; + boolean isVertical = parserController.isVerticalVector(vector); + + return placeShipByCoordinate(field, x, y, isVertical, size); + } + + @Override + public boolean placeShipByCoordinate(Field field, int x, int y, boolean isVertical, int size) { + if (field == null) return false; + if (0 > x || x > 9) return false; + if (0 > y || y > 9) return false; + Ship ship = new Ship(size, x, y, isVertical); + + if (!isAvailable(field, ship)) return false; + for (int i = 0; i < ship.getSize(); i++) { + if (ship.isVertical()) { + field.setCell(ship.starX, ship.startY + i, CellStatus.SHIP); + } else { + field.setCell(ship.starX + i, ship.startY, CellStatus.SHIP); + } + } + return true; + } + + @Override + public boolean isAnyShipAlive(Field field) { + if (field == null) return false; + return Arrays.stream(field.getCells()) + .flatMap(Arrays::stream) + .anyMatch(x -> x == CellStatus.SHIP); + } + + private boolean isAvailable(Field field, Ship ship) { + if (field.getCell(ship.starX, ship.startY) == CellStatus.SHIP) return false; + if(cellCheckCross(field, ship.starX, ship.startY)) return false; + + if (ship.isVertical()){ + if (ship.startY + ship.getSize() > Field.FIELD_SIZE) return false; + if (cellCheckCross(field, ship.starX, ship.startY + ship.getSize() - 1)) return false; + } else { + if (ship.starX + ship.getSize() > Field.FIELD_SIZE) return false; + if (cellCheckCross(field, ship.starX + ship.getSize() - 1, ship.startY)) return false; + } + for (int i = 0; i < ship.getSize(); i++) { + int dx = 0; + int dy = 0; + + if (ship.isVertical()) dy = i; + else dx = i; + + if (cellCheckPlus(field, ship.starX + dx, ship.startY + dy)) return false; + } + + return true; + } + + private boolean cellCheckCross(Field field, int x, int y) { + if (y - 1 >= 0 && x - 1 >= 0) { + if (field.getCell(x - 1, y - 1) == CellStatus.SHIP) return true; + } + if (y - 1 >= 0 && x + 1 < Field.FIELD_SIZE){ + if (field.getCell(x + 1, y - 1) == CellStatus.SHIP) return true; + } + if (y + 1 < Field.FIELD_SIZE && x - 1 >= 0) { + if (field.getCell(x - 1, y + 1) == CellStatus.SHIP) return true; + } + if (y + 1 < Field.FIELD_SIZE && x + 1 < Field.FIELD_SIZE) { + if (field.getCell(x + 1, y + 1) == CellStatus.SHIP) return true; + } + + return false; + } + + private boolean cellCheckPlus(Field field, int x, int y) { + if (x + 1 < Field.FIELD_SIZE) { + if (field.getCell(x + 1, y) == CellStatus.SHIP) return true; + } + + if (x - 1 >= 0) { + if (field.getCell(x - 1, y) == CellStatus.SHIP) return true; + } + + if (y + 1 < Field.FIELD_SIZE) { + if (field.getCell(x, y + 1) == CellStatus.SHIP) return true; + } + if (y - 1 >= 0) { + if (field.getCell(x, y - 1) == CellStatus.SHIP) return true; + } + return false; + } + + public static ShipControllerImpl getInstance() { + return ShipControllerImpl.Holder.INSTANCE; + } + + private static class Holder { + static final ShipControllerImpl INSTANCE = new ShipControllerImpl(); + } + + private static class Ship { + private final int size; + private final boolean isVertical; + private final int starX; + private final int startY; + + public Ship(int size, int x, int y, boolean isVertical) { + this.size = size; + + this.starX = x; + this.startY = y; + this.isVertical = isVertical; + } + + public int getSize() { + return size; + } + + public boolean isVertical() { + return isVertical; + } + } +} diff --git a/src/main/java/course_project/sea_battle/controller/impl/ValidateControllerImpl.java b/src/main/java/course_project/sea_battle/controller/impl/ValidateControllerImpl.java new file mode 100644 index 00000000..215ce52b --- /dev/null +++ b/src/main/java/course_project/sea_battle/controller/impl/ValidateControllerImpl.java @@ -0,0 +1,23 @@ +package course_project.sea_battle.controller.impl; + +public final class ValidateControllerImpl { + private ValidateControllerImpl() {} + + public boolean coordinate(String str) { + if (str == null) return false; + return str.toLowerCase().matches("[a-i]([1-9]|10)"); + } + + public boolean vector(String str) { + if (str == null) return false; + return str.toLowerCase().matches("[vg]"); + } + + public static ValidateControllerImpl getInstance() { + return ValidateControllerImpl.Holder.INSTANCE; + } + + private static class Holder { + static final ValidateControllerImpl INSTANCE = new ValidateControllerImpl(); + } +} diff --git a/src/main/java/course_project/sea_battle/model/BasePlayer.java b/src/main/java/course_project/sea_battle/model/BasePlayer.java new file mode 100644 index 00000000..6cc698ad --- /dev/null +++ b/src/main/java/course_project/sea_battle/model/BasePlayer.java @@ -0,0 +1,14 @@ +package course_project.sea_battle.model; + +public class BasePlayer { + private final String name; + + public BasePlayer(String name) { + this.name = name; + } + + public String getName() { + return name; + } + +} diff --git a/src/main/java/course_project/sea_battle/model/CellStatus.java b/src/main/java/course_project/sea_battle/model/CellStatus.java new file mode 100644 index 00000000..95048f8a --- /dev/null +++ b/src/main/java/course_project/sea_battle/model/CellStatus.java @@ -0,0 +1,19 @@ +package course_project.sea_battle.model; + +public enum CellStatus { + SHIP('█'), + SHOT('⊙'), + WATER('~'), + HIT('X'); + + private final char value; + + CellStatus(char value) { + this.value = value; + } + + @Override + public String toString() { + return String.valueOf(value); + } +} diff --git a/src/main/java/course_project/sea_battle/model/Field.java b/src/main/java/course_project/sea_battle/model/Field.java new file mode 100644 index 00000000..61e7e03a --- /dev/null +++ b/src/main/java/course_project/sea_battle/model/Field.java @@ -0,0 +1,18 @@ +package course_project.sea_battle.model; + +public class Field { + public static final int FIELD_SIZE = 10; + private final CellStatus[][] cells = new CellStatus[FIELD_SIZE][FIELD_SIZE]; + + public CellStatus[][] getCells() { + return cells; + } + + public CellStatus getCell(int x, int y) { + return cells[y][x]; + } + + public void setCell(int x, int y, CellStatus status) { + cells[y][x] = status; + } +} diff --git a/src/main/java/course_project/sea_battle/model/Game.java b/src/main/java/course_project/sea_battle/model/Game.java new file mode 100644 index 00000000..be6b2f0e --- /dev/null +++ b/src/main/java/course_project/sea_battle/model/Game.java @@ -0,0 +1,33 @@ +package course_project.sea_battle.model; + + +public class Game { + private GamePlayer player1; + private GamePlayer player2; + + private GamePlayer playerWin = null; + + public GamePlayer getPlayer1() { + return player1; + } + + public void setPlayer1(GamePlayer player1) { + this.player1 = player1; + } + + public GamePlayer getPlayer2() { + return player2; + } + + public void setPlayer2(GamePlayer player2) { + this.player2 = player2; + } + + public GamePlayer getPlayerWin() { + return playerWin; + } + + public void setPlayerWin(GamePlayer playerWin) { + this.playerWin = playerWin; + } +} diff --git a/src/main/java/course_project/sea_battle/model/GamePlayer.java b/src/main/java/course_project/sea_battle/model/GamePlayer.java new file mode 100644 index 00000000..f72d0175 --- /dev/null +++ b/src/main/java/course_project/sea_battle/model/GamePlayer.java @@ -0,0 +1,26 @@ +package course_project.sea_battle.model; + +public class GamePlayer extends BasePlayer{ + private Field fieldPlayer; + private Field radarPlayer; + + public GamePlayer(String name) { + super(name); + } + + public Field getFieldPlayer() { + return fieldPlayer; + } + + public void setFieldPlayer(Field fieldPlayer) { + this.fieldPlayer = fieldPlayer; + } + + public Field getRadarPlayer() { + return radarPlayer; + } + + public void setRadarPlayer(Field radarPlayer) { + this.radarPlayer = radarPlayer; + } +} diff --git a/src/main/java/homework_1/Main.java b/src/main/java/homework_1/Main.java index 07c029a2..7dc814ff 100644 --- a/src/main/java/homework_1/Main.java +++ b/src/main/java/homework_1/Main.java @@ -1,9 +1,39 @@ package homework_1; public class Main { + public static final String redColorOutString = "\u001B[31m"; + public static final String closeColorOutString = "\u001B[0m"; - public static void main(String[] args) { - System.out.println("Hello homework!"); - } + public static void main(String... args) { + for (String arg : args) { + if (arg.equals("ошибка")) { + System.out.println(redColorOutString + "Тревога!" + closeColorOutString); + return; + } else { + System.out.println(createStringResult(arg)); + } + } + } + private static String createStringResult(String str) { + StringBuilder strBuilder = new StringBuilder(); + strBuilder + .append(str) + .append(": ") + .append(str.length()) + .append(" букв"); + switch (str.length() % 10) { + case 1: + strBuilder.append("а"); + break; + case 2: + case 3: + case 4: + strBuilder.append("ы"); + break; + default: + break; + } + return strBuilder.toString(); + } } diff --git a/src/main/java/homework_2/pyramid_printer/Main.java b/src/main/java/homework_2/pyramid_printer/Main.java new file mode 100644 index 00000000..71e33035 --- /dev/null +++ b/src/main/java/homework_2/pyramid_printer/Main.java @@ -0,0 +1,8 @@ +package homework_2.pyramid_printer; + +public class Main { + + public static void main(String[] args) { + new PyramidPrinter().run(); + } +} diff --git a/src/main/java/homework_2/pyramid_printer/PyramidPrinter.java b/src/main/java/homework_2/pyramid_printer/PyramidPrinter.java new file mode 100644 index 00000000..bbfd1d4d --- /dev/null +++ b/src/main/java/homework_2/pyramid_printer/PyramidPrinter.java @@ -0,0 +1,20 @@ +package homework_2.pyramid_printer; + +import homework_2.utils.AppWithOneIntInput; + +public class PyramidPrinter extends AppWithOneIntInput { + + @Override + protected String calculate() { + if (error != null) return error; + StringBuilder strBuilder = new StringBuilder(); + StringBuilder result = new StringBuilder("\n"); + for (int i = 0; i < data; i++) { + strBuilder.append('x'); + result + .append(strBuilder) + .append('\n'); + } + return result.toString(); + } +} diff --git a/src/main/java/homework_2/random_chars_table/Main.java b/src/main/java/homework_2/random_chars_table/Main.java new file mode 100644 index 00000000..be586c4b --- /dev/null +++ b/src/main/java/homework_2/random_chars_table/Main.java @@ -0,0 +1,8 @@ +package homework_2.random_chars_table; + +public class Main { + + public static void main(String[] args) { + new RandomCharsTable().run(); + } +} diff --git a/src/main/java/homework_2/random_chars_table/RandomCharsTable.java b/src/main/java/homework_2/random_chars_table/RandomCharsTable.java new file mode 100644 index 00000000..3da26a5b --- /dev/null +++ b/src/main/java/homework_2/random_chars_table/RandomCharsTable.java @@ -0,0 +1,75 @@ +package homework_2.random_chars_table; + +import homework_2.utils.App; + +import java.util.Random; + +public class RandomCharsTable extends App { + private int length; + private int width; + private boolean isOdd; + + private boolean isDebug; + + @Override + protected void parseData() { + final String ERR_NON_VALID_DATA_MSG = "Passed parameters should match the format [positive integer] [positive integer] [even|odd]"; + + if (!inputStr.matches("[1-9][0-9]*\\s[1-9][0-9]*\\s(even|odd)")) { + error = ERR_NON_VALID_DATA_MSG; + return; + } + String[] arguments = inputStr.split("\\s"); + isOdd = arguments[2].equalsIgnoreCase("odd"); + try { + length = Integer.parseInt(arguments[0]); + width = Integer.parseInt(arguments[1]); + } catch (NumberFormatException ex) { + error = ERR_NON_VALID_DATA_MSG; + } + } + @Override + protected String calculate() { + if (error != null) return error; + + int check; + Random random; + + if (isDebug) random = new Random(1L); + else random = new Random(); + + StringBuilder charTable = new StringBuilder("\n"); + StringBuilder answerBuilder = new StringBuilder(); + + if(isOdd) { + check = 1; + answerBuilder.append("Odd letters - "); + } else { + check = 0; + answerBuilder.append("Even letters - "); + } + + for (int y = 0; y < length; y++) { + for (int x = 0; x < width; x++) { + char letter = (char)(65 + random.nextInt(25)); + charTable + .append("| ") + .append(letter) + .append(" "); + if (letter % 2 == check) { + answerBuilder + .append(letter) + .append(", "); + } + } + charTable.append("|\n"); + } + answerBuilder.setLength(answerBuilder.length() - 2); + return charTable.append(answerBuilder).toString(); + } + + public RandomCharsTable setDebug(boolean debug) { + isDebug = debug; + return this; + } +} diff --git a/src/main/java/homework_2/traffic_light/Color.java b/src/main/java/homework_2/traffic_light/Color.java new file mode 100644 index 00000000..595c8d91 --- /dev/null +++ b/src/main/java/homework_2/traffic_light/Color.java @@ -0,0 +1,29 @@ +package homework_2.traffic_light; + +public enum Color { + + GREEN(0, 35), + YELLOW, + RED(40, 55); + + private int start; + private int end; + + Color() { + } + + Color(int start, int end) { + this.start = start; + this.end = end; + } + + public static Color check(int sec) { + if (sec >= GREEN.start && sec < GREEN.end) { + return GREEN; + } else if (sec >= RED.start && sec < RED.end) { + return RED; + } else { + return YELLOW; + } + } +} diff --git a/src/main/java/homework_2/traffic_light/Main.java b/src/main/java/homework_2/traffic_light/Main.java new file mode 100644 index 00000000..3ff7f428 --- /dev/null +++ b/src/main/java/homework_2/traffic_light/Main.java @@ -0,0 +1,8 @@ +package homework_2.traffic_light; + +public class Main { + + public static void main(String[] args) { + new TrafficLight().run(); + } +} diff --git a/src/main/java/homework_2/traffic_light/TrafficLight.java b/src/main/java/homework_2/traffic_light/TrafficLight.java new file mode 100644 index 00000000..425613e2 --- /dev/null +++ b/src/main/java/homework_2/traffic_light/TrafficLight.java @@ -0,0 +1,18 @@ +package homework_2.traffic_light; + +import homework_2.utils.AppWithOneIntInput; + +public class TrafficLight extends AppWithOneIntInput { + + protected final static String MAX_MSG = "The day is over"; + private final static int MAX_VALUE = 86399; + + @Override + protected String calculate() { + if (error != null) return error; + if (data > MAX_VALUE) return (MAX_MSG); + + int sec = data % 60; + return Color.check(sec).name(); + } +} diff --git a/src/main/java/homework_2/utils/App.java b/src/main/java/homework_2/utils/App.java new file mode 100644 index 00000000..02efca63 --- /dev/null +++ b/src/main/java/homework_2/utils/App.java @@ -0,0 +1,55 @@ +package homework_2.utils; + +import java.io.InputStream; +import java.io.PrintStream; +import java.util.Scanner; + +public abstract class App implements Executable{ + + protected InputStream inputStream; + protected PrintStream printStream; + protected String error; + protected String inputStr; + + { + inputStream = System.in; + printStream = System.out; + } + + protected abstract void parseData(); + protected abstract String calculate(); + + @Override + public void run() { + readData(); + parseData(); + printStream.print(calculate().trim()); +// printResult(calculate(), inputStr); // custom output + } + + protected void printResult(String result, String inputValue) { + printResult(result, inputValue, printStream); + } + + protected void printResult(String result, String inputValue, PrintStream outputStream) { + String str = "input - " + inputValue + + ", output - " + result; + outputStream.println(str); + } + + protected void readData() { + final String STRING_MSG = "Введите данные:"; + try(Scanner sc = new Scanner(inputStream)) { + printStream.println(STRING_MSG); + inputStr = sc.nextLine(); + } + } + + public void setInputStream(InputStream inputStream) { + this.inputStream = inputStream; + } + + public void setPrintStream(PrintStream printStream) { + this.printStream = printStream; + } +} diff --git a/src/main/java/homework_2/utils/AppWithOneIntInput.java b/src/main/java/homework_2/utils/AppWithOneIntInput.java new file mode 100644 index 00000000..27d4c261 --- /dev/null +++ b/src/main/java/homework_2/utils/AppWithOneIntInput.java @@ -0,0 +1,22 @@ +package homework_2.utils; + +import java.util.Scanner; + +public abstract class AppWithOneIntInput extends App{ + + protected int data; + + @Override + protected void parseData() { + final String ERR_NON_VALID_DATA_MSG = "Only 1 non-negative integer is allowed as passed parameter"; + Scanner sc = new Scanner(inputStr).useDelimiter("\n"); + if (sc.hasNextInt()) { + data = sc.nextInt(); + if (data < 0) { + error = ERR_NON_VALID_DATA_MSG; + } + } else { + error = ERR_NON_VALID_DATA_MSG; + } + } +} diff --git a/src/main/java/homework_2/utils/Executable.java b/src/main/java/homework_2/utils/Executable.java new file mode 100644 index 00000000..6619a2d9 --- /dev/null +++ b/src/main/java/homework_2/utils/Executable.java @@ -0,0 +1,5 @@ +package homework_2.utils; + +public interface Executable { + void run(); +} diff --git a/src/main/java/homework_3/ImmutableClass.java b/src/main/java/homework_3/ImmutableClass.java new file mode 100644 index 00000000..90f0e085 --- /dev/null +++ b/src/main/java/homework_3/ImmutableClass.java @@ -0,0 +1,47 @@ +package homework_3; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +/* +The class must be declared as final +Data members in the class must be declared as private +Data members in the class must be declared as final +A parameterized constructor should initialize all the fields performing a deep copy +Deep Copy of objects should be performed in the getter methods +No setters + */ +public final class ImmutableClass { + private final String aString; + private final int anInt; + private final List aList; + + public ImmutableClass(List aList) { + this("default", 0, new ArrayList<>(aList)); + } + + public ImmutableClass(String aString, int anInt, List aList) { + //STRING - неизменяемый класс, глубокая копия не нужна, Так как STRING изменить нельзя. + List tempList = new ArrayList<>(aList); + this.aString = aString; + this.anInt = anInt; + this.aList = tempList; + } + + public String getString() { + return aString; + } + + public int getAnInt() { + return anInt; + } + + public List getAList() { + //return Collections.unmodifiableList(aList) - тоже будет прекрасно работать! + return new ArrayList<>(aList); + } + + public ImmutableClass getNew(List aList) { + return new ImmutableClass(getString(), getAnInt(), aList); + } +} diff --git a/src/main/java/homework_4/custom_file_reader/CustomFileReader.java b/src/main/java/homework_4/custom_file_reader/CustomFileReader.java new file mode 100644 index 00000000..79ef7658 --- /dev/null +++ b/src/main/java/homework_4/custom_file_reader/CustomFileReader.java @@ -0,0 +1,66 @@ +package homework_4.custom_file_reader; + +import java.io.BufferedReader; +import java.io.File; +import java.io.IOException; +import java.io.InputStreamReader; +import java.net.URL; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.Scanner; +import java.util.function.Consumer; + +public class CustomFileReader { + private static final String FILE_PATH = "custom_file_reader" + File.separator + "file"; + private static final Consumer FUNCTION = x -> System.out.println(x.replaceAll("[,.]", "")); + + public static void run() { + try { + run1(); + } catch (IOException e) { + e.printStackTrace(); + } + try { + run2(); + } catch (IOException e) { + e.printStackTrace(); + } + try { + run3(); + } catch (IOException e) { + e.printStackTrace(); + } + try { + run4(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + public static void run1() throws IOException { + try(Scanner scanner = new Scanner(getFileURL().openStream()).useDelimiter("\n")) { + scanner.forEachRemaining(FUNCTION); + } + } + + public static void run2() throws IOException { + try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(getFileURL().openStream()))) { + bufferedReader.lines().forEach(FUNCTION); + } + } + //The resource URL is not working in the JAR + public static void run3() throws IOException { + //lines - close stream + Files.lines(Paths.get(getFileURL().getPath())); + } + //The resource URL is not working in the JAR + public static void run4() throws IOException { + //readAllLines - close stream + Files.readAllLines(Paths.get(getFileURL().getPath())).forEach(FUNCTION); + } + + private static URL getFileURL() { + return ClassLoader.getSystemResource(FILE_PATH); + } + +} diff --git a/src/main/java/homework_4/custom_file_reader/Main.java b/src/main/java/homework_4/custom_file_reader/Main.java new file mode 100644 index 00000000..16214a05 --- /dev/null +++ b/src/main/java/homework_4/custom_file_reader/Main.java @@ -0,0 +1,10 @@ +package homework_4.custom_file_reader; + +import java.io.IOException; +import java.net.URISyntaxException; + +public class Main { + public static void main(String[] args) { + CustomFileReader.run(); + } +} diff --git a/src/main/java/homework_4/singleton/Singleton.java b/src/main/java/homework_4/singleton/Singleton.java new file mode 100644 index 00000000..080c9c5b --- /dev/null +++ b/src/main/java/homework_4/singleton/Singleton.java @@ -0,0 +1,13 @@ +package homework_4.singleton; + +public final class Singleton { + private Singleton() {} + + private static class Holder { + static final Singleton INSTANCE = new Singleton(); + } + + public static Singleton getInstance() { + return Holder.INSTANCE; + } +} diff --git "a/src/main/java/homework_4/\321\201ustom_annotation/CustomAnnotation.java" "b/src/main/java/homework_4/\321\201ustom_annotation/CustomAnnotation.java" new file mode 100644 index 00000000..6a6c929d --- /dev/null +++ "b/src/main/java/homework_4/\321\201ustom_annotation/CustomAnnotation.java" @@ -0,0 +1,13 @@ +package homework_4.сustom_annotation; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import static java.lang.annotation.ElementType.CONSTRUCTOR; +import static java.lang.annotation.RetentionPolicy.RUNTIME; + +@Retention(RUNTIME) +@Target(CONSTRUCTOR) +public @interface CustomAnnotation { + String value() default "CustomAnnotation"; +} diff --git "a/src/main/java/homework_4/\321\201ustom_annotation/SimpleClassWithNameField.java" "b/src/main/java/homework_4/\321\201ustom_annotation/SimpleClassWithNameField.java" new file mode 100644 index 00000000..5f614af3 --- /dev/null +++ "b/src/main/java/homework_4/\321\201ustom_annotation/SimpleClassWithNameField.java" @@ -0,0 +1,29 @@ +package homework_4.сustom_annotation; + +import java.lang.reflect.Constructor; + +public class SimpleClassWithNameField { + private String name; + + @CustomAnnotation("test name string") + public SimpleClassWithNameField(String name) { + Constructor constructor; + try { + constructor = this.getClass().getConstructor(String.class); + CustomAnnotation annotation = constructor.getAnnotation(CustomAnnotation.class); + if (annotation != null) { + this.name = annotation.value(); + } + if (!name.isEmpty()) { + this.name = name; + } + } catch (NoSuchMethodException e) { + e.printStackTrace(); + } + } + + public String getName() { + return name; + } + +} diff --git a/src/main/java/homework_5/AppHW_5.java b/src/main/java/homework_5/AppHW_5.java new file mode 100644 index 00000000..65aaf41e --- /dev/null +++ b/src/main/java/homework_5/AppHW_5.java @@ -0,0 +1,54 @@ +package homework_5; + +import homework_5.utils.MyReader; +import homework_5.utils.StringChecker; +import homework_5.utils.impl.MyReaderImpl; +import homework_5.utils.impl.StringCheckerImpl; + +import java.util.NoSuchElementException; + +public class AppHW_5 { + private static final String PATTERN = "default"; + + private final MyReader reader; + private final StringChecker matcher; + private final StringBuilder dataSB = new StringBuilder(); + private boolean isReaderClose = false; + + protected AppHW_5() { + this(PATTERN); + } + + public AppHW_5(String patternString) { + reader = new MyReaderImpl(); + matcher = new StringCheckerImpl().setPattern(patternString); + } + + public void clearData() { + dataSB.setLength(0); + } + + public boolean readData() throws NoSuchElementException { + boolean result = true; + if (isReaderClose) { + result = false; + } else { + dataSB.append(reader.readData()); + } + return result; + } + + protected boolean check() { + return matcher.checkData(dataSB.toString()); + } + + protected void closeReader() { + isReaderClose = true; + reader.close(); + } + + protected String getData() { + return this.dataSB.toString(); + } + +} diff --git a/src/main/java/homework_5/custom_regex_matcher/CustomRegexMatcher.java b/src/main/java/homework_5/custom_regex_matcher/CustomRegexMatcher.java new file mode 100644 index 00000000..211350a2 --- /dev/null +++ b/src/main/java/homework_5/custom_regex_matcher/CustomRegexMatcher.java @@ -0,0 +1,23 @@ +package homework_5.custom_regex_matcher; + +import homework_5.AppHW_5; + +public class CustomRegexMatcher extends AppHW_5 { + private final static String PATTERN_STRING = "[0-9a-zA-Z_]+@[0-9a-zA-Z_]+\\.[a-zA-Z]{2,3}"; + + public CustomRegexMatcher() { + super(PATTERN_STRING); + } + + public String run() { + readData(); + String result = String.valueOf(check()); + System.out.println(result); + closeReader(); + return result; + } + + public static void main(String[] args) { + new CustomRegexMatcher().run(); + } +} diff --git a/src/main/java/homework_5/digit/Digit.java b/src/main/java/homework_5/digit/Digit.java new file mode 100644 index 00000000..261c8376 --- /dev/null +++ b/src/main/java/homework_5/digit/Digit.java @@ -0,0 +1,8 @@ +package homework_5.digit; + +public class Digit { + + public static int calculate(long number) { + return 1 + (number / 10 == 0 ? 0 : calculate(number / 10)); + } +} diff --git a/src/main/java/homework_5/power_of_number/Exponent.java b/src/main/java/homework_5/power_of_number/Exponent.java new file mode 100644 index 00000000..b32fb1e4 --- /dev/null +++ b/src/main/java/homework_5/power_of_number/Exponent.java @@ -0,0 +1,8 @@ +package homework_5.power_of_number; + +public class Exponent { + public static long calculate(int base, int pow) throws InputNegativeBaseArgumentException { + if (pow < 0) throw new InputNegativeBaseArgumentException(); + return pow == 0 ? 1 : (base*calculate(base, pow-1)); + } +} diff --git a/src/main/java/homework_5/power_of_number/InputNegativeBaseArgumentException.java b/src/main/java/homework_5/power_of_number/InputNegativeBaseArgumentException.java new file mode 100644 index 00000000..67638278 --- /dev/null +++ b/src/main/java/homework_5/power_of_number/InputNegativeBaseArgumentException.java @@ -0,0 +1,4 @@ +package homework_5.power_of_number; + +public class InputNegativeBaseArgumentException extends RuntimeException { +} \ No newline at end of file diff --git a/src/main/java/homework_5/power_of_number/PowerOfNumber.java b/src/main/java/homework_5/power_of_number/PowerOfNumber.java new file mode 100644 index 00000000..9a7c7c36 --- /dev/null +++ b/src/main/java/homework_5/power_of_number/PowerOfNumber.java @@ -0,0 +1,41 @@ +package homework_5.power_of_number; + +import homework_5.AppHW_5; + +import java.util.Scanner; + +public class PowerOfNumber extends AppHW_5 { + private final static String PATTERN_STRING = "[0-9]* [0-9]*"; + private final static String ERROR = "Only 2 non-negative integers are allowed"; + + public PowerOfNumber() { + super(PATTERN_STRING); + } + + public String run() { + String result; + try { + readData(); + if (!check()) result = ERROR; + else result = calculate(); + } catch (Exception ex) { + return ERROR; + } + finally { + closeReader(); + } + + System.out.println(result); + return result; + } + + private String calculate() { + Scanner sc = new Scanner(getData()); + return String.valueOf(Exponent.calculate(sc.nextInt(), sc.nextInt())); + } + + public static void main(String[] args) { + new PowerOfNumber().run(); + } + +} diff --git a/src/main/java/homework_5/utils/MyReader.java b/src/main/java/homework_5/utils/MyReader.java new file mode 100644 index 00000000..5e51b8a0 --- /dev/null +++ b/src/main/java/homework_5/utils/MyReader.java @@ -0,0 +1,6 @@ +package homework_5.utils; + +public interface MyReader { + String readData(); + void close(); +} diff --git a/src/main/java/homework_5/utils/StringChecker.java b/src/main/java/homework_5/utils/StringChecker.java new file mode 100644 index 00000000..14453946 --- /dev/null +++ b/src/main/java/homework_5/utils/StringChecker.java @@ -0,0 +1,6 @@ +package homework_5.utils; + +public interface StringChecker { + + boolean checkData(String data); +} diff --git a/src/main/java/homework_5/utils/impl/MyReaderImpl.java b/src/main/java/homework_5/utils/impl/MyReaderImpl.java new file mode 100644 index 00000000..c8ab5ce3 --- /dev/null +++ b/src/main/java/homework_5/utils/impl/MyReaderImpl.java @@ -0,0 +1,37 @@ +package homework_5.utils.impl; + +import homework_5.utils.MyReader; + +import java.io.InputStream; +import java.io.PrintStream; +import java.util.NoSuchElementException; +import java.util.Scanner; + +public class MyReaderImpl implements MyReader { + private final InputStream inputStream; + private final PrintStream printStream; + private Scanner sc; + + public MyReaderImpl() { + inputStream = System.in; + printStream = System.out; + } + + public MyReaderImpl(InputStream inputStream, PrintStream printStream) { + this.inputStream = inputStream; + this.printStream = printStream; + } + + public String readData() throws NoSuchElementException, IllegalStateException { + final String STRING_MSG = "Введите данные:"; + if (sc == null) sc = new Scanner(inputStream); + printStream.println(STRING_MSG); + + return sc.nextLine(); + } + + public void close() { + if (sc != null) sc.close(); + } + +} diff --git a/src/main/java/homework_5/utils/impl/StringCheckerImpl.java b/src/main/java/homework_5/utils/impl/StringCheckerImpl.java new file mode 100644 index 00000000..63d33e1f --- /dev/null +++ b/src/main/java/homework_5/utils/impl/StringCheckerImpl.java @@ -0,0 +1,20 @@ +package homework_5.utils.impl; + +import homework_5.utils.StringChecker; + +import java.util.regex.Pattern; +import java.util.regex.PatternSyntaxException; + +public class StringCheckerImpl implements StringChecker { + private Pattern pattern; + + public boolean checkData(String data) { + if (pattern == null) pattern = Pattern.compile("default"); + return pattern.matcher(data).matches(); + } + + public StringCheckerImpl setPattern(String patternLiteral) throws PatternSyntaxException{ + this.pattern = Pattern.compile(patternLiteral); + return this; + } +} diff --git a/src/main/java/homework_6/map_problems_generator/Main.java b/src/main/java/homework_6/map_problems_generator/Main.java new file mode 100644 index 00000000..421ecc80 --- /dev/null +++ b/src/main/java/homework_6/map_problems_generator/Main.java @@ -0,0 +1,40 @@ +package homework_6.map_problems_generator; + +import homework_6.map_problems_generator.problem_impl.MutableProblem; +import homework_6.map_problems_generator.problem_impl.Wrapper; + +import java.io.UncheckedIOException; +import java.util.HashMap; +import java.util.Map; + +public class Main { + public static void main(String[] args) { + MapProblemsGenerator generator = new MapProblemsGenerator<>(); + Map, Integer> problemIntegerHashMap = new HashMap<>(); + + Wrapper noProblem = new Wrapper<>(generator.generateNoProblemClass("first")); + Wrapper collisionProblem = new Wrapper<>(generator.generateCollisionProblemClass("second")); + Wrapper collisionProblem2 = new Wrapper<>(generator.generateCollisionProblemClass("third")); + Wrapper gettingProblem = new Wrapper<>(generator.generateGettingProblemClass("fourth")); + + MutableProblem muttable = generator.generateMutableProblemClass("Muttable"); + Wrapper mutableProblem = new Wrapper<>(muttable); + + problemIntegerHashMap.put(noProblem, 1); + + problemIntegerHashMap.put(collisionProblem, 1); + problemIntegerHashMap.put(collisionProblem2, 1); + + problemIntegerHashMap.put(gettingProblem, 1); + problemIntegerHashMap.get(gettingProblem); + + problemIntegerHashMap.put(mutableProblem, 1); + System.out.println(problemIntegerHashMap.get(mutableProblem)); + muttable.setValue("Mod " + muttable.getValue()); + System.out.println(problemIntegerHashMap.get(mutableProblem)); + + problemIntegerHashMap.keySet().forEach(o -> ((Wrapper)o).getEvent().forEach(System.out::println)); + + + } +} diff --git a/src/main/java/homework_6/map_problems_generator/MapProblemsGenerator.java b/src/main/java/homework_6/map_problems_generator/MapProblemsGenerator.java new file mode 100644 index 00000000..1e884c10 --- /dev/null +++ b/src/main/java/homework_6/map_problems_generator/MapProblemsGenerator.java @@ -0,0 +1,25 @@ +package homework_6.map_problems_generator; + +import homework_6.map_problems_generator.problem_impl.CollisionProblem; +import homework_6.map_problems_generator.problem_impl.GettingProblem; +import homework_6.map_problems_generator.problem_impl.MutableProblem; +import homework_6.map_problems_generator.problem_impl.NoProblem; + +public class MapProblemsGenerator { + + public NoProblem generateNoProblemClass(T value) { + return new NoProblem<>(value); + } + + public CollisionProblem generateCollisionProblemClass(T value) { + return new CollisionProblem<>(value); + } + + public GettingProblem generateGettingProblemClass(T value) { + return new GettingProblem<>(value); + } + + public MutableProblem generateMutableProblemClass(T value) { + return new MutableProblem<>(value); + } +} diff --git a/src/main/java/homework_6/map_problems_generator/Problem.java b/src/main/java/homework_6/map_problems_generator/Problem.java new file mode 100644 index 00000000..9ee548ee --- /dev/null +++ b/src/main/java/homework_6/map_problems_generator/Problem.java @@ -0,0 +1,5 @@ +package homework_6.map_problems_generator; + +public interface Problem { + T getValue(); +} diff --git a/src/main/java/homework_6/map_problems_generator/problem_impl/CollisionProblem.java b/src/main/java/homework_6/map_problems_generator/problem_impl/CollisionProblem.java new file mode 100644 index 00000000..87140973 --- /dev/null +++ b/src/main/java/homework_6/map_problems_generator/problem_impl/CollisionProblem.java @@ -0,0 +1,13 @@ +package homework_6.map_problems_generator.problem_impl; + +public class CollisionProblem extends NoProblem { + + public CollisionProblem(T value) { + super(value); + } + + @Override + public int hashCode() { + return 0; + } +} diff --git a/src/main/java/homework_6/map_problems_generator/problem_impl/GettingProblem.java b/src/main/java/homework_6/map_problems_generator/problem_impl/GettingProblem.java new file mode 100644 index 00000000..537de9c1 --- /dev/null +++ b/src/main/java/homework_6/map_problems_generator/problem_impl/GettingProblem.java @@ -0,0 +1,15 @@ +package homework_6.map_problems_generator.problem_impl; + +import java.util.Random; + +public class GettingProblem extends NoProblem { + + public GettingProblem(T value) { + super(value); + } + + @Override + public int hashCode() { + return new Random().nextInt(); + } +} diff --git a/src/main/java/homework_6/map_problems_generator/problem_impl/MutableProblem.java b/src/main/java/homework_6/map_problems_generator/problem_impl/MutableProblem.java new file mode 100644 index 00000000..147b13b6 --- /dev/null +++ b/src/main/java/homework_6/map_problems_generator/problem_impl/MutableProblem.java @@ -0,0 +1,13 @@ +package homework_6.map_problems_generator.problem_impl; + +import homework_6.map_problems_generator.Problem; + +public class MutableProblem extends NoProblem { + public MutableProblem(T value) { + super(value); + } + + public void setValue(T value) { + this.value = value; + } +} diff --git a/src/main/java/homework_6/map_problems_generator/problem_impl/NoProblem.java b/src/main/java/homework_6/map_problems_generator/problem_impl/NoProblem.java new file mode 100644 index 00000000..3aaffd65 --- /dev/null +++ b/src/main/java/homework_6/map_problems_generator/problem_impl/NoProblem.java @@ -0,0 +1,33 @@ +package homework_6.map_problems_generator.problem_impl; + +import homework_6.map_problems_generator.Problem; + +import java.util.Objects; + +public class NoProblem implements Problem { + protected T value; + + public NoProblem(T value) { + this.value = value; + } + + @Override + public T getValue() { + return this.value; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + NoProblem noProblem = (NoProblem) o; + + return Objects.equals(value, noProblem.value); + } + + @Override + public int hashCode() { + return value != null ? value.hashCode() : 0; + } +} diff --git a/src/main/java/homework_6/map_problems_generator/problem_impl/Wrapper.java b/src/main/java/homework_6/map_problems_generator/problem_impl/Wrapper.java new file mode 100644 index 00000000..d86b896a --- /dev/null +++ b/src/main/java/homework_6/map_problems_generator/problem_impl/Wrapper.java @@ -0,0 +1,46 @@ +package homework_6.map_problems_generator.problem_impl; + +import homework_6.map_problems_generator.Problem; + +import java.util.ArrayList; +import java.util.List; + +public class Wrapper implements Problem { + private final Problem innerProblem; + private final List event = new ArrayList<>(); + + public Wrapper(Problem innerProblem) { + this.innerProblem = innerProblem; + } + + public List getEvent() { + return event; + } + + private void update(String str, String result) { + String res = "At the object class(" + innerProblem.getClass().getSimpleName() + + ") with value = " + innerProblem.getValue() + + ", was called method " + str + + ". Result = " + result; + event.add(res); + } + + @Override + public T getValue() { + return innerProblem.getValue(); + } + + @Override + public boolean equals(Object o) { + boolean equals = innerProblem.equals(o); + update("equals".toUpperCase() ,String.valueOf(equals)); + return equals; + } + + @Override + public int hashCode() { + int hashCode = innerProblem.hashCode(); + update("hashCode".toUpperCase() ,String.valueOf(hashCode)); + return hashCode; + } +} diff --git a/src/main/java/homework_7/Main.java b/src/main/java/homework_7/Main.java new file mode 100644 index 00000000..bfdc8c6a --- /dev/null +++ b/src/main/java/homework_7/Main.java @@ -0,0 +1,16 @@ +package homework_7; + +import homework_7.kitten_to_cat_function.Cat; +import homework_7.kitten_to_cat_function.Kitten; +import homework_7.kitten_to_cat_function.KittenToCatFunction; + +public class Main { + + public static void main(String[] args) { + Kitten kitten = new Kitten("Murzik", 1); + KittenToCatFunction function = (k) -> new Cat(k.getName(), k.getAge() + 4); + Cat cat = function.grow(kitten); + System.out.println(kitten); + System.out.println(cat); + } +} diff --git a/src/main/java/homework_7/kitten_to_cat_function/Cat.java b/src/main/java/homework_7/kitten_to_cat_function/Cat.java new file mode 100644 index 00000000..72df1a3c --- /dev/null +++ b/src/main/java/homework_7/kitten_to_cat_function/Cat.java @@ -0,0 +1,34 @@ +package homework_7.kitten_to_cat_function; + +public class Cat { + private String name; + private Integer age; + private String favoriteMeal; + + public Cat(String name, Integer age) { + this.name = name; + this.age = age; + this.favoriteMeal = "Fish"; + } + + public String getName() { + return name; + } + + public Integer getAge() { + return age; + } + + public String getFavoriteMeal() { + return favoriteMeal; + } + + @Override + public String toString() { + return "Cat{" + + "name='" + name + '\'' + + ", age=" + age + + ", favoriteMeal='" + favoriteMeal + '\'' + + '}'; + } +} diff --git a/src/main/java/homework_7/kitten_to_cat_function/Kitten.java b/src/main/java/homework_7/kitten_to_cat_function/Kitten.java new file mode 100644 index 00000000..ef316437 --- /dev/null +++ b/src/main/java/homework_7/kitten_to_cat_function/Kitten.java @@ -0,0 +1,34 @@ +package homework_7.kitten_to_cat_function; + +public class Kitten { + private String name; + private Integer age; + private String favoriteMeal; + + public Kitten(String name, Integer age) { + this.name = name; + this.age = age; + this.favoriteMeal = "Milk"; + } + + public String getName() { + return name; + } + + public Integer getAge() { + return age; + } + + public String getFavoriteMeal() { + return favoriteMeal; + } + + @Override + public String toString() { + return "Kitten{" + + "name='" + name + '\'' + + ", age=" + age + + ", favoriteMeal='" + favoriteMeal + '\'' + + '}'; + } +} diff --git a/src/main/java/homework_7/kitten_to_cat_function/KittenToCatFunction.java b/src/main/java/homework_7/kitten_to_cat_function/KittenToCatFunction.java new file mode 100644 index 00000000..5c7b09d5 --- /dev/null +++ b/src/main/java/homework_7/kitten_to_cat_function/KittenToCatFunction.java @@ -0,0 +1,6 @@ +package homework_7.kitten_to_cat_function; + +@FunctionalInterface +public interface KittenToCatFunction { + Cat grow(Kitten kitten); +} diff --git a/src/main/resources/custom_file_reader/file b/src/main/resources/custom_file_reader/file new file mode 100644 index 00000000..4036f3ab --- /dev/null +++ b/src/main/resources/custom_file_reader/file @@ -0,0 +1,119 @@ +Сергей Есенин + +Письмо к женщине + +Вы помните, +Вы всё, конечно, помните, +Как я стоял, +Приблизившись к стене, +Взволнованно ходили вы по комнате +И что-то резкое +В лицо бросали мне. + +Вы говорили: +Нам пора расстаться, +Что вас измучила +Моя шальная жизнь, +Что вам пора за дело приниматься, +А мой удел — +Катиться дальше, вниз. + +Любимая! +Меня вы не любили. +Не знали вы, что в сонмище людском +Я был как лошадь, загнанная в мыле, +Пришпоренная смелым ездоком. + +Не знали вы, +Что я в сплошном дыму, +В развороченном бурей быте +С того и мучаюсь, что не пойму — +Куда несет нас рок событий. + +Лицом к лицу +Лица не увидать. +Большое видится на расстоянье. +Когда кипит морская гладь — +Корабль в плачевном состоянье. + +Земля — корабль! +Но кто-то вдруг +За новой жизнью, новой славой +В прямую гущу бурь и вьюг +Ее направил величаво. + +Ну кто ж из нас на палубе большой +Не падал, не блевал и не ругался? +Их мало, с опытной душой, +Кто крепким в качке оставался. + +Тогда и я, +Под дикий шум, +Но зрело знающий работу, +Спустился в корабельный трюм, +Чтоб не смотреть людскую рвоту. + +Тот трюм был — +Русским кабаком. +И я склонился над стаканом, +Чтоб, не страдая ни о ком, +Себя сгубить +В угаре пьяном. + +Любимая! +Я мучил вас, +У вас была тоска +В глазах усталых: +Что я пред вами напоказ +Себя растрачивал в скандалах. + +Но вы не знали, +Что в сплошном дыму, +В развороченном бурей быте +С того и мучаюсь, +Что не пойму, +Куда несет нас рок событий… + +Теперь года прошли. +Я в возрасте ином. +И чувствую и мыслю по-иному. +И говорю за праздничным вином: +Хвала и слава рулевому! + +Сегодня я +В ударе нежных чувств. +Я вспомнил вашу грустную усталость. +И вот теперь +Я сообщить вам мчусь, +Каков я был, +И что со мною сталось! + +Любимая! +Сказать приятно мне: +Я избежал паденья с кручи. +Теперь в Советской стороне +Я самый яростный попутчик. + +Я стал не тем, +Кем был тогда. +Не мучил бы я вас, +Как это было раньше. +За знамя вольности +И светлого труда +Готов идти хоть до Ла-Манша. + +Простите мне… +Я знаю: вы не та — +Живете вы +С серьезным, умным мужем; +Что не нужна вам наша маета, +И сам я вам +Ни капельки не нужен. + +Живите так, +Как вас ведет звезда, +Под кущей обновленной сени. +С приветствием, +Вас помнящий всегда +Знакомый ваш +Сергей Есенин. diff --git a/src/test/java/course_project/sea_battle/controller/impl/FieldControllerImplTest.java b/src/test/java/course_project/sea_battle/controller/impl/FieldControllerImplTest.java new file mode 100644 index 00000000..0b91a674 --- /dev/null +++ b/src/test/java/course_project/sea_battle/controller/impl/FieldControllerImplTest.java @@ -0,0 +1,113 @@ +package course_project.sea_battle.controller.impl; + +import base.UnitBase; +import course_project.sea_battle.model.CellStatus; +import course_project.sea_battle.model.Field; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; + +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; + +class FieldControllerImplTest extends UnitBase { + + @Test + void InstanceMethodReturnFieldFillsWaterTest() { + assertTrue(Arrays.stream(FieldControllerImpl.getInstance().instance().getCells()) + .flatMap(Arrays::stream) + .allMatch(x -> x.equals(CellStatus.WATER))); + } + + @Test + void DrawFieldsWith1FieldTest() { + Field waterField1 = FieldControllerImpl.getInstance().instance(); + FieldControllerImpl.getInstance().drawFields(waterField1); + + String raw1 = " ╔══════════╗"; + String raw2 = " ║ABCDEFGHIG║"; + String raw3 = "╔══╬══════════╣"; + String raw4 = "║ 1║~~~~~~~~~~║"; + String raw5 = "║ 2║~~~~~~~~~~║"; + String raw6 = "║ 3║~~~~~~~~~~║"; + String raw7 = "║ 4║~~~~~~~~~~║"; + String raw8 = "║ 5║~~~~~~~~~~║"; + String raw9 = "║ 6║~~~~~~~~~~║"; + String raw10 = "║ 7║~~~~~~~~~~║"; + String raw11 = "║ 8║~~~~~~~~~~║"; + String raw12 = "║ 9║~~~~~~~~~~║"; + String raw13 = "║10║~~~~~~~~~~║"; + String raw14 = "╚══╩══════════╝"; + + assertEquals(14, getOutputLines().length); + assertEquals(raw1.trim(), getOutputLines()[0]); + assertEquals(raw2, getOutputLines()[1]); + assertEquals(raw3, getOutputLines()[2]); + assertEquals(raw4, getOutputLines()[3]); + assertEquals(raw5, getOutputLines()[4]); + assertEquals(raw6, getOutputLines()[5]); + assertEquals(raw7, getOutputLines()[6]); + assertEquals(raw8, getOutputLines()[7]); + assertEquals(raw9, getOutputLines()[8]); + assertEquals(raw10, getOutputLines()[9]); + assertEquals(raw11, getOutputLines()[10]); + assertEquals(raw12, getOutputLines()[11]); + assertEquals(raw13, getOutputLines()[12]); + assertEquals(raw14.trim(), getOutputLines()[13]); + } + + + @Test + void DrawFieldsWith2FieldsTest() { + + final String raw2 = " ║ABCDEFGHIG║" + "\t" + " ║ABCDEFGHIG║"; + final String raw3 = "╔══╬══════════╣" + "\t" + "╔══╬══════════╣"; + final String raw4 = "║ 1║~~~~~~~~~~║" + "\t" + "║ 1║X~~~~~~~~~║"; + final String raw5 = "║ 2║~~~~~~~~~~║" + "\t" + "║ 2║~~~~~~~~~~║"; + + + final Field waterField1 = FieldControllerImpl.getInstance().instance(); + final Field waterField2 = FieldControllerImpl.getInstance().instance(); + + waterField2.setCell(0,0, CellStatus.HIT); + + FieldControllerImpl.getInstance().drawFields(waterField1, waterField2); + + assertEquals(14, getOutputLines().length); + assertEquals(raw2, getOutputLines()[1]); + assertEquals(raw3, getOutputLines()[2]); + assertEquals(raw4, getOutputLines()[3]); + assertEquals(raw5, getOutputLines()[4]); + } + + @Test + void DrawFieldsWith3FieldsTest() { + + final String expected = + "╔══════════╗\t ╔══════════╗\t ╔══════════╗\n" + + " ║ABCDEFGHIG║\t ║ABCDEFGHIG║\t ║ABCDEFGHIG║\n" + + "╔══╬══════════╣\t╔══╬══════════╣\t╔══╬══════════╣\n" + + "║ 1║~~~~~~~~~~║\t║ 1║~~█~~~~~~~║\t║ 1║~~⊙~~~~~~~║\n" + + "║ 2║~~~~~~~~~~║\t║ 2║~~~~~~~~~~║\t║ 2║~~~~~~~~~~║\n" + + "║ 3║~~~~~~~~~~║\t║ 3║~~~~~~~~~~║\t║ 3║~~~~~~~~~~║\n" + + "║ 4║~~~~~~~~~~║\t║ 4║~~~~~~~~~~║\t║ 4║~~~~~~~~~~║\n" + + "║ 5║~~~~~~~~~~║\t║ 5║~~~~~~~~~~║\t║ 5║~~~~~~~~~~║\n" + + "║ 6║~~~~~~~~~~║\t║ 6║~~~~~~~~~~║\t║ 6║~~~~~~~~~~║\n" + + "║ 7║~~~~~~~~~~║\t║ 7║~~~~~~~~~~║\t║ 7║~~~~~~~~~~║\n" + + "║ 8║~~~~~~~~~~║\t║ 8║~~~~~~~~~~║\t║ 8║~~~~~~~~~~║\n" + + "║ 9║~~~~~~~~~~║\t║ 9║~~~~~~~~~~║\t║ 9║~~~~~~~~~~║\n" + + "║10║~~~~~~~~~~║\t║10║~~~~~~~~~~║\t║10║~~~~~~~~~~║\n" + + "╚══╩══════════╝\t╚══╩══════════╝\t╚══╩══════════╝"; + + + final Field waterField = FieldControllerImpl.getInstance().instance(); + final Field waterField2 = FieldControllerImpl.getInstance().instance(); + waterField2.setCell(2,0, CellStatus.SHIP); + final Field waterField3 = FieldControllerImpl.getInstance().instance(); + waterField3.setCell(2,0, CellStatus.SHOT); + + FieldControllerImpl.getInstance().drawFields(waterField, waterField2, waterField3); + + assertEquals(expected, getOutput()); + } +} \ No newline at end of file diff --git a/src/test/java/course_project/sea_battle/controller/impl/FireControllerImplTest.java b/src/test/java/course_project/sea_battle/controller/impl/FireControllerImplTest.java new file mode 100644 index 00000000..d71bc534 --- /dev/null +++ b/src/test/java/course_project/sea_battle/controller/impl/FireControllerImplTest.java @@ -0,0 +1,107 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.FireController; +import course_project.sea_battle.model.CellStatus; +import course_project.sea_battle.model.Field; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class FireControllerImplTest { + Field radar; + Field def; + FireController fireController = FireControllerImpl.getInstance(); + + @BeforeEach + void setField() { + radar = FieldControllerImpl.getInstance().instance(); + def = FieldControllerImpl.getInstance().instance(); + def.setCell(0, 0, CellStatus.SHIP); + def.setCell(1, 0, CellStatus.HIT); + def.setCell(2, 0, CellStatus.SHOT); + def.setCell(3, 0, CellStatus.WATER); + } + + @Test + void fireShipTest() { + assertEquals(CellStatus.WATER, radar.getCell(0,0)); + assertEquals(CellStatus.SHIP, def.getCell(0,0)); + CellStatus cell1 = fireController.fire(def, radar, "a1"); + assertEquals(CellStatus.HIT, radar.getCell(0,0)); + assertEquals(CellStatus.HIT, def.getCell(0,0)); + } + + @Test + void fireHitTest() { + assertEquals(CellStatus.WATER, radar.getCell(1,0)); + assertEquals(CellStatus.HIT, def.getCell(1,0)); + CellStatus cell1 = fireController.fire(def, radar, "b1"); + assertEquals(CellStatus.HIT, radar.getCell(1,0)); + assertEquals(CellStatus.HIT, def.getCell(1,0)); + } + + @Test + void fireShotTest() { + assertEquals(CellStatus.WATER, radar.getCell(2,0)); + assertEquals(CellStatus.SHOT, def.getCell(2,0)); + CellStatus cell1 = fireController.fire(def, radar, "c1"); + assertEquals(CellStatus.SHOT, radar.getCell(2,0)); + assertEquals(CellStatus.SHOT, def.getCell(2,0)); + } + + @Test + void fireWaterTest() { + assertEquals(CellStatus.WATER, radar.getCell(3,0)); + assertEquals(CellStatus.WATER, def.getCell(3,0)); + CellStatus cell1 = fireController.fire(def, radar, "d1"); + assertEquals(CellStatus.SHOT, radar.getCell(3,0)); + assertEquals(CellStatus.SHOT, def.getCell(3,0)); + } + + @Test + void checkFireValidDataTest() { + //проверет на корректные данные координат + boolean res = fireController.checkFire(def, "a2"); + boolean res2 = fireController.checkFire(def, "a3"); + boolean res3 = fireController.checkFire(def, "a4"); + + boolean res4 = fireController.checkFire(def, "a1"); + boolean res5 = fireController.checkFire(def, "b1"); + boolean res6 = fireController.checkFire(def, "c1"); + boolean res7 = fireController.checkFire(def, "d1"); + + assertTrue(res); + assertTrue(res2); + assertTrue(res3); + + assertTrue(res4); + assertTrue(res7); + + // стрелять 2 раза в 1 место нельзя, по этому тут ожидаем обратного + assertFalse(res5); + assertFalse(res6); + } + + @Test + void checkFireInValidDataTest() { + //проверет на корректные данные координат + boolean res = fireController.checkFire(def, "adsf"); + boolean res2 = fireController.checkFire(def, "adsf"); + boolean res3 = fireController.checkFire(def, "asdf"); + + boolean res4 = fireController.checkFire(def, "adf"); + boolean res5 = fireController.checkFire(def, "zcv"); + boolean res6 = fireController.checkFire(def, "asfd"); + boolean res7 = fireController.checkFire(null, "fgj"); + + assertFalse(res); + assertFalse(res2); + assertFalse(res3); + assertFalse(res4); + assertFalse(res5); + assertFalse(res6); + assertFalse(res7); + + } +} \ No newline at end of file diff --git a/src/test/java/course_project/sea_battle/controller/impl/GameControllerImplTest.java b/src/test/java/course_project/sea_battle/controller/impl/GameControllerImplTest.java new file mode 100644 index 00000000..edd626bd --- /dev/null +++ b/src/test/java/course_project/sea_battle/controller/impl/GameControllerImplTest.java @@ -0,0 +1,71 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.*; +import course_project.sea_battle.model.CellStatus; +import course_project.sea_battle.model.Field; +import course_project.sea_battle.model.Game; +import course_project.sea_battle.model.GamePlayer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; + +class GameControllerImplTest { + GameController gameController = GameControllerImpl.getInstance(); + IOControllerImpl ioController = IOControllerImpl.getInstance(); + FieldFillController randomFieldFillController = ManualFieldFillController.getInstance(); + final String firstPlayerName = "First player"; + final String secondPlayerName = "Second player"; + + @BeforeEach + void set() { + // Это не тест, а скорее игра в игру по сценарию. + // В игре каждый игрок ставит по 2 коробля (1 и 2 клетки) + // сделано от безисходности, так как не знаю как еще написать тут что то. + // но можно проверить + + + final String input = "" + + firstPlayerName + "\n" + //вводится имя 1го + secondPlayerName + "\n" + //вводится имя 2го + "n\n" + "a1\n" + "v\n" + "c1\n" + "v\n" + // говорим что руками поставим корабли и ставим a1 и с1 оба вертикально + "\n" + // передаем ход + "n\n" + "d1\n" + "G\n" + "g1\n" + "G\n" + // выставляем так же корабли + "\n" + // начинаем игру + "\n" + "a1\n" + "\n" + // принимаем ход, делаем выстрел мимо, передаем ход + "\n" + "a1\n" + "\n" + "\n" + "a2\n" + "\n" + "\n" + "c1\n" + "\n"; // делаем 3 выстрела, и выигрываем + + ioController.setScanner(new Scanner(input)); + + randomFieldFillController.setGameSetupHolder(() -> { + Map map = new TreeMap<>(Comparator.reverseOrder()); + map.put(1, 1); + map.put(2, 1); + return map; + }); + } + + @Test + void TestWinner() { + Game game = gameController.start(); + + GamePlayer playerWin = game.getPlayerWin(); + + Field fieldPlayer = playerWin.getFieldPlayer(); + Field radarPlayer = playerWin.getRadarPlayer(); + + assertEquals(firstPlayerName, game.getPlayer1().getName()); + assertEquals(secondPlayerName, game.getPlayer2().getName()); + assertEquals(secondPlayerName, game.getPlayerWin().getName()); + + assertTrue(ShipControllerImpl.getInstance().isAnyShipAlive(fieldPlayer)); + + assertEquals(3, + Arrays.stream(radarPlayer.getCells()) + .flatMap(Arrays::stream) + .filter(x -> x.equals(CellStatus.HIT)) + .count()); + } +} \ No newline at end of file diff --git a/src/test/java/course_project/sea_battle/controller/impl/ManualFieldFillControllerTest.java b/src/test/java/course_project/sea_battle/controller/impl/ManualFieldFillControllerTest.java new file mode 100644 index 00000000..4336c536 --- /dev/null +++ b/src/test/java/course_project/sea_battle/controller/impl/ManualFieldFillControllerTest.java @@ -0,0 +1,64 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.FieldFillController; +import course_project.sea_battle.model.CellStatus; +import course_project.sea_battle.model.Field; +import org.junit.jupiter.api.Test; + +import java.util.*; + +import static org.junit.jupiter.api.Assertions.*; + +class ManualFieldFillControllerTest { + FieldFillController fieldFillController = ManualFieldFillController.getInstance(); + Field field = FieldControllerImpl.getInstance().instance(); + + @Test + void setShips1Test() { + fieldFillController.setGameSetupHolder(() -> { + Map integerIntegerMap = new TreeMap<>(Comparator.reverseOrder()); + integerIntegerMap.put(6, 1); + return integerIntegerMap; + }); + + IOControllerImpl ioController = IOControllerImpl.getInstance(); + + final String value = "a1\nv"; + ioController.setScanner(new Scanner(value)); + + fieldFillController.setShips(field); + + assertEquals(6, Arrays.stream(field.getCells()) + .flatMap(Arrays::stream) + .filter(x -> x.equals(CellStatus.SHIP)) + .count()); + + ioController.close(); + } + + @Test + void setShips2Test() { + fieldFillController.setGameSetupHolder(() -> { + Map integerIntegerMap = new TreeMap<>(Comparator.reverseOrder()); + integerIntegerMap.put(6, 2); + return integerIntegerMap; + }); + + IOControllerImpl ioController = IOControllerImpl.getInstance(); + + final String value = + "a1\nv\n" + + "c1\ng"; + + ioController.setScanner(new Scanner(value)); + + fieldFillController.setShips(field); + + assertEquals(6 * 2, Arrays.stream(field.getCells()) + .flatMap(Arrays::stream) + .filter(x -> x.equals(CellStatus.SHIP)) + .count()); + + ioController.close(); + } +} \ No newline at end of file diff --git a/src/test/java/course_project/sea_battle/controller/impl/ParserControllerImplTest.java b/src/test/java/course_project/sea_battle/controller/impl/ParserControllerImplTest.java new file mode 100644 index 00000000..210b5959 --- /dev/null +++ b/src/test/java/course_project/sea_battle/controller/impl/ParserControllerImplTest.java @@ -0,0 +1,33 @@ +package course_project.sea_battle.controller.impl; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; +/* + так как парсер работает только с валидированными данными не валидные значения не имеют значения + */ +class ParserControllerImplTest { + course_project.sea_battle.controller.ParseController instance = ParserControllerImpl.getInstance(); + + @Test + void parseCoordinate() { + final String valid1 = "a1"; + final String valid2 = "b5"; + final String valid3 = "g1"; + final String valid4 = "h10"; + + assertArrayEquals(new int[]{0,0}, instance.parseCoordinate(valid1)); + assertArrayEquals(new int[]{1,4}, instance.parseCoordinate(valid2)); + assertArrayEquals(new int[]{6,0}, instance.parseCoordinate(valid3)); + assertArrayEquals(new int[]{7,9}, instance.parseCoordinate(valid4)); + } + + @Test + void isVerticalVector() { + final String valid1 = "v"; + final String valid2 = "g"; + + assertTrue(instance.isVerticalVector(valid1)); + assertFalse(instance.isVerticalVector(valid2)); + } +} \ No newline at end of file diff --git a/src/test/java/course_project/sea_battle/controller/impl/PlayerControllerImplTest.java b/src/test/java/course_project/sea_battle/controller/impl/PlayerControllerImplTest.java new file mode 100644 index 00000000..8fc08b8a --- /dev/null +++ b/src/test/java/course_project/sea_battle/controller/impl/PlayerControllerImplTest.java @@ -0,0 +1,37 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.PlayerController; +import course_project.sea_battle.model.BasePlayer; +import course_project.sea_battle.model.CellStatus; +import course_project.sea_battle.model.GamePlayer; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; + +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +class PlayerControllerImplTest { + PlayerController playerController = PlayerControllerImpl.getInstance(); + @Test + void instance() { + final String val1= "Тест 1"; + + BasePlayer player = playerController.instance(val1); + assertEquals(val1, player.getName()); + GamePlayer gamePlayer = null; + if (player.getClass() == GamePlayer.class) gamePlayer = (GamePlayer) player; + assertNotNull(gamePlayer); + assertNotNull(gamePlayer.getFieldPlayer()); + assertNotNull(gamePlayer.getRadarPlayer()); + + assertEquals(100, Arrays.stream(gamePlayer.getFieldPlayer().getCells()) + .flatMap(Arrays::stream) + .filter(x -> x.equals(CellStatus.WATER)) + .count()); + assertEquals(100, Arrays.stream(gamePlayer.getRadarPlayer().getCells()) + .flatMap(Arrays::stream) + .filter(x -> x.equals(CellStatus.WATER)) + .count()); + } +} \ No newline at end of file diff --git a/src/test/java/course_project/sea_battle/controller/impl/RandomFieldFillControllerTest.java b/src/test/java/course_project/sea_battle/controller/impl/RandomFieldFillControllerTest.java new file mode 100644 index 00000000..ea913557 --- /dev/null +++ b/src/test/java/course_project/sea_battle/controller/impl/RandomFieldFillControllerTest.java @@ -0,0 +1,67 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.FieldFillController; +import course_project.sea_battle.controller.ShipController; +import course_project.sea_battle.model.CellStatus; +import course_project.sea_battle.model.Field; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.Comparator; +import java.util.TreeMap; + +import static org.junit.jupiter.api.Assertions.*; + +class RandomFieldFillControllerTest { + + FieldFillController randomFieldFillController; + FieldControllerImpl fieldController = FieldControllerImpl.getInstance(); + ShipController shipController = ShipControllerImpl.getInstance(); + + @AfterEach + void after() { + randomFieldFillController = null; + } + @Test + void setShip() { + randomFieldFillController = RandomFieldFillController.getInstance() + .setGameSetupHolder(()-> { + TreeMap map = new TreeMap<>(Comparator.reverseOrder()); + map.put(5, 1); + return map; + }); + + Field instance = fieldController.instance(); + assertFalse(shipController.isAnyShipAlive(instance)); + randomFieldFillController.setShips(instance); + assertTrue(shipController.isAnyShipAlive(instance)); + long count = Arrays.stream(instance.getCells()) + .flatMap(Arrays::stream) + .filter(x -> x.equals(CellStatus.SHIP)) + .count(); + assertEquals(5, count); + } + + @Test + void setShips2() { + randomFieldFillController = RandomFieldFillController.getInstance() + .setGameSetupHolder(()-> { + TreeMap map = new TreeMap<>(Comparator.reverseOrder()); + map.put(5, 2); + return map; + }); + + Field instance = fieldController.instance(); + assertFalse(shipController.isAnyShipAlive(instance)); + randomFieldFillController.setShips(instance); + assertTrue(shipController.isAnyShipAlive(instance)); + + long count = Arrays.stream(instance.getCells()) + .flatMap(Arrays::stream) + .filter(x -> x.equals(CellStatus.SHIP)) + .count(); + assertEquals(5 * 2, count); + } +} \ No newline at end of file diff --git a/src/test/java/course_project/sea_battle/controller/impl/ShipControllerImplTest.java b/src/test/java/course_project/sea_battle/controller/impl/ShipControllerImplTest.java new file mode 100644 index 00000000..8a4d5485 --- /dev/null +++ b/src/test/java/course_project/sea_battle/controller/impl/ShipControllerImplTest.java @@ -0,0 +1,118 @@ +package course_project.sea_battle.controller.impl; + +import course_project.sea_battle.controller.FieldController; +import course_project.sea_battle.controller.ShipController; +import course_project.sea_battle.model.CellStatus; +import course_project.sea_battle.model.Field; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; + +import static org.junit.jupiter.api.Assertions.*; + +class ShipControllerImplTest { + FieldController fieldController = FieldControllerImpl.getInstance(); + ShipController shipController = ShipControllerImpl.getInstance(); + Field field; + + @BeforeEach + void set() { + field = fieldController.instance(); + assertTrue(Arrays.stream(field.getCells()) + .flatMap(Arrays::stream) + .allMatch(x -> x.equals(CellStatus.WATER))); + } + + @Test + void placeShip4timeTest() { + assertTrue(shipController.placeShip(field, "a1","v", 5)); + assertFalse(shipController.placeShip(field, "a1","v", 5)); + assertFalse(shipController.placeShip(field, "a1","v", 5)); + assertFalse(shipController.placeShip(field, "a1","v", 5)); + assertFalse(shipController.placeShip(field, "a1","v", 5)); + + assertEquals(5, Arrays.stream(field.getCells()) + .flatMap(Arrays::stream) + .filter(x -> x.equals(CellStatus.SHIP)) + .count() + ); + } + + @Test + void placeShip1timeTest() { + assertTrue(shipController.placeShip(field, "a1","v", 5)); + assertEquals(5, Arrays.stream(field.getCells()) + .flatMap(Arrays::stream) + .filter(x -> x.equals(CellStatus.SHIP)) + .count() + ); + } + + @Test + void placeShipNotValidCoordinateTest() { + assertFalse(shipController.placeShip(field, "z1","v", 5)); + assertFalse(shipController.placeShip(field, "a11","v", 5)); + assertFalse(shipController.placeShip(field, "z11","v", 5)); + assertFalse(shipController.placeShip(field, "a1","q", 5)); + assertFalse(shipController.placeShip(field, "a1","w", 5)); + + assertEquals(0, Arrays.stream(field.getCells()) + .flatMap(Arrays::stream) + .filter(x -> x.equals(CellStatus.SHIP)) + .count() + ); + } + + @Test + void placeShipByCoordinate4timeTest() { + assertTrue(shipController.placeShipByCoordinate(field, 0, 0, true, 5)); + assertFalse(shipController.placeShipByCoordinate(field, 0, 0, true, 5)); + assertFalse(shipController.placeShipByCoordinate(field, 0, 1, true, 5)); + assertFalse(shipController.placeShipByCoordinate(field, 0, 4, true, 5)); + + assertEquals(field.getCell(0, 0), CellStatus.SHIP); + assertEquals(field.getCell(0, 1), CellStatus.SHIP); + assertEquals(field.getCell(0, 2), CellStatus.SHIP); + assertEquals(field.getCell(0, 3), CellStatus.SHIP); + assertEquals(field.getCell(0, 4), CellStatus.SHIP); + + assertNotEquals(field.getCell(0, 5), CellStatus.SHIP); + } + + @Test + void placeShipByCoordinate1TimeTest() { + assertTrue(shipController.placeShipByCoordinate(field, 0, 0, true, 3)); + + assertEquals(field.getCell(0, 0), CellStatus.SHIP); + assertEquals(field.getCell(0, 1), CellStatus.SHIP); + assertEquals(field.getCell(0, 2), CellStatus.SHIP); + assertNotEquals(field.getCell(0, 3), CellStatus.SHIP); + assertNotEquals(field.getCell(0, 4), CellStatus.SHIP); + assertNotEquals(field.getCell(0, 5), CellStatus.SHIP); + } + + @Test + void placeShipByNotValidCoordinate() { + assertFalse(shipController.placeShipByCoordinate(field, 10, 0, true, 3)); + + field = fieldController.instance(); + assertTrue(Arrays.stream(field.getCells()) + .flatMap(Arrays::stream) + .allMatch(x -> x.equals(CellStatus.WATER))); + } + + @Test + void isAnyShipAlive() { + assertFalse(shipController.isAnyShipAlive(field)); + field.setCell(0,0, CellStatus.SHIP); + assertFalse(shipController.isAnyShipAlive(field)); + field.setCell(0,0, CellStatus.WATER); + assertFalse(shipController.isAnyShipAlive(field)); + field.setCell(0,0, CellStatus.SHOT); + assertFalse(shipController.isAnyShipAlive(field)); + + assertTrue(shipController.isAnyShipAlive(field)); + field.setCell(0,0, CellStatus.HIT); + } +} \ No newline at end of file diff --git a/src/test/java/course_project/sea_battle/controller/impl/ValidateControllerImplTest.java b/src/test/java/course_project/sea_battle/controller/impl/ValidateControllerImplTest.java new file mode 100644 index 00000000..ae8af477 --- /dev/null +++ b/src/test/java/course_project/sea_battle/controller/impl/ValidateControllerImplTest.java @@ -0,0 +1,61 @@ +package course_project.sea_battle.controller.impl; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class ValidateControllerImplTest { + + @Test + void ValidCoordinateTest() { + final String val1 = "a1"; + final String val2 = "b9"; + final String val3 = "a3"; + final String val4 = "A1"; + + assertTrue(ValidateControllerImpl.getInstance().coordinate(val1)); + assertTrue(ValidateControllerImpl.getInstance().coordinate(val2)); + assertTrue(ValidateControllerImpl.getInstance().coordinate(val3)); + assertTrue(ValidateControllerImpl.getInstance().coordinate(val4)); + } + + @Test + void NotValidCoordinateTest() { + final String val1 = "sdfa"; + final String val2 = "asdkgn."; + final String val3 = "kap 'sf'aojezvczv"; + final String val4 = ""; + final String val5 = null; + + assertFalse(ValidateControllerImpl.getInstance().coordinate(val1)); + assertFalse(ValidateControllerImpl.getInstance().coordinate(val2)); + assertFalse(ValidateControllerImpl.getInstance().coordinate(val3)); + assertFalse(ValidateControllerImpl.getInstance().coordinate(val4)); + assertFalse(ValidateControllerImpl.getInstance().coordinate(val5)); + } + + @Test + void ValidVectorTest() { + final String val1 = "g"; + final String val2 = "v"; + final String val3 = "V"; + + assertTrue(ValidateControllerImpl.getInstance().vector(val1)); + assertTrue(ValidateControllerImpl.getInstance().vector(val2)); + assertTrue(ValidateControllerImpl.getInstance().vector(val3)); + } + + @Test + void NotValidVectorTest() { + final String val1 = "d"; + final String val2 = "z"; + final String val3 = "zfsdfs"; + + final String val4 = null; + + assertFalse(ValidateControllerImpl.getInstance().vector(val1)); + assertFalse(ValidateControllerImpl.getInstance().vector(val2)); + assertFalse(ValidateControllerImpl.getInstance().vector(val3)); + assertFalse(ValidateControllerImpl.getInstance().vector(val4)); + } +} \ No newline at end of file diff --git a/src/test/java/homework_1/MainTest.java b/src/test/java/homework_1/MainTest.java new file mode 100644 index 00000000..c5d3075e --- /dev/null +++ b/src/test/java/homework_1/MainTest.java @@ -0,0 +1,64 @@ +package homework_1; + +import base.UnitBase; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class MainTest extends UnitBase { + + @Test + void ValidInputArgsMain() { + + String[] input = { + "тест", + "не тест", + "много букв", + "Sunday", + "Monday", + "Tuesday", + "Wednesday", + "Thursday", + "Friday", + "Saturday"}; + Main.main(input); + printOut(); + assertEquals("тест: 4 буквы", getOutputLines()[0]); + assertEquals("не тест: 7 букв", getOutputLines()[1]); + assertEquals("много букв: 10 букв", getOutputLines()[2]); + assertEquals("Sunday: 6 букв", getOutputLines()[3]); + assertEquals("Monday: 6 букв", getOutputLines()[4]); + assertEquals("Tuesday: 7 букв", getOutputLines()[5]); + assertEquals("Wednesday: 9 букв", getOutputLines()[6]); + assertEquals("Thursday: 8 букв", getOutputLines()[7]); + assertEquals("Friday: 6 букв", getOutputLines()[8]); + assertEquals("Saturday: 8 букв", getOutputLines()[9]); + } + + @Test + void ErrorInputArgsMain() { + + String[] input = { + "ошибка" + }; + Main.main(input); + printOut(); + + assertTrue(getOutputLines()[0].contains("Тревога!")); + } + + @Test + void MixInputArgsMain() { + + String[] input = { + "тест", + "не тест", + "ошибка" + }; + Main.main(input); + printOut(); + assertEquals("тест: 4 буквы", getOutputLines()[0]); + assertEquals("не тест: 7 букв", getOutputLines()[1]); + assertTrue(getOutputLines()[2].contains("Тревога")); + } +} \ No newline at end of file diff --git a/src/test/java/homework_2/pyramid_printer/PyramidPrinterTest.java b/src/test/java/homework_2/pyramid_printer/PyramidPrinterTest.java new file mode 100644 index 00000000..e12d75ec --- /dev/null +++ b/src/test/java/homework_2/pyramid_printer/PyramidPrinterTest.java @@ -0,0 +1,90 @@ +package homework_2.pyramid_printer; + +import base.UnitBase; +import org.junit.jupiter.api.Test; + +import java.util.NoSuchElementException; + +import static org.junit.jupiter.api.Assertions.*; + +class PyramidPrinterTest extends UnitBase { + @Test + void InputZeroAsArgument() { + setInput("0"); + + new PyramidPrinter().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("", getOutputLines()[0]); + } + + @Test + void InputFiveAsArgument() { + setInput("5"); + + new PyramidPrinter().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("x", getOutputLines()[0]); + assertEquals("xx", getOutputLines()[1]); + assertEquals("xxx", getOutputLines()[2]); + assertEquals("xxxx", getOutputLines()[3]); + assertEquals("xxxxx", getOutputLines()[4]); + } + + @Test + void InputMinusOneAsArgument() { + setInput("-1"); + + new PyramidPrinter().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("Only 1 non-negative integer is allowed as passed parameter", getOutputLines()[0]); + } + + @Test + void InputStringValueAsArgument() { + setInput("String"); + + new PyramidPrinter().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("Only 1 non-negative integer is allowed as passed parameter", getOutputLines()[0]); + } + + @Test + void InputTwoArguments() { + setInput("2 2"); + + new PyramidPrinter().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("Only 1 non-negative integer is allowed as passed parameter", getOutputLines()[0]); + } + + @Test + void InputDoubleAsArgument() { + setInput("0.1"); + + new PyramidPrinter().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("Only 1 non-negative integer is allowed as passed parameter", getOutputLines()[0]); + } + + @Test + void InputDigitalValueBiggerThenIntegerAsArgument() { + setInput("9999999999"); + + new PyramidPrinter().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("Only 1 non-negative integer is allowed as passed parameter", getOutputLines()[0]); + } + + @Test + void InputEmptyArgument() { + setInput(""); + assertThrows(NoSuchElementException.class, () -> new PyramidPrinter().run()); + } +} \ No newline at end of file diff --git a/src/test/java/homework_2/random_chars_table/RandomCharsTableTest.java b/src/test/java/homework_2/random_chars_table/RandomCharsTableTest.java new file mode 100644 index 00000000..a9dfcd3c --- /dev/null +++ b/src/test/java/homework_2/random_chars_table/RandomCharsTableTest.java @@ -0,0 +1,133 @@ +package homework_2.random_chars_table; + +import base.UnitBase; +import org.junit.jupiter.api.RepeatedTest; +import org.junit.jupiter.api.Test; + +import java.util.NoSuchElementException; +import java.util.Random; + +import static org.junit.jupiter.api.Assertions.*; + +class RandomCharsTableTest extends UnitBase { + @Test + void InputZeroAsArgument() { + setInput("0 0 odd"); + + new RandomCharsTable().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("Passed parameters should match the format [positive integer] [positive integer] [even|odd]", getOutputLines()[0]); + } + + @Test + void InputEmptyArgument() { + setInput(""); + assertThrows(NoSuchElementException.class, () -> new RandomCharsTable().run()); + } + + /* + for this test use new RandomCharsTable().setDebug(true).run(); + 3 3 odd + | K | N | W | + | N | E | E | + | J | G | D | + Even letters - N, N, J, D + */ + @Test + void InputValidEvenArguments() { + setInput("3 3 even"); + + new RandomCharsTable().setDebug(true).run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("| K | N | W |", getOutputLines()[0]); + assertEquals("| N | E | E |", getOutputLines()[1]); + assertEquals("| J | G | D |", getOutputLines()[2]); + assertEquals("Even letters - N, N, J, D", getOutputLines()[3]); + } + + /* + for this test use new RandomCharsTable().setDebug(true).run(); + 3 3 odd + | K | N | W | + | N | E | E | + | J | G | D | + odd letters - K, W, E, E, G + */ + @Test + void InputValidOddArguments() { + setInput("3 3 odd"); + + new RandomCharsTable().setDebug(true).run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("| K | N | W |", getOutputLines()[0]); + assertEquals("| N | E | E |", getOutputLines()[1]); + assertEquals("| J | G | D |", getOutputLines()[2]); + assertEquals("Odd letters - K, W, E, E, G", getOutputLines()[3]); + } + + @Test + void InputRandomRowsAndColumnsAsArgument() { + final String STRATEGY = "even"; + final int ROWS = 1 + new Random().nextInt(20); + final int COLUMNS = 1 + new Random().nextInt(20); + final String input = "" + ROWS + " " + COLUMNS + " " + STRATEGY; + + setInput(input); + + new RandomCharsTable().run(); + printOut(); + removeFromOutput("Введите данные:"); + for (int i = 0; i < ROWS; i++) + assertTrue(getOutputLines()[i].matches("(\\|\\s[A-Z]\\s){" + COLUMNS + "}\\|")); + } + + // дальше тест уродлив, но как иначе распарсить эти строки и сравнить все я не знаю + // за то покрывает все варианты. + @RepeatedTest(10) + void InputRandomCheckStrategy() { + final boolean isOdd = new Random().nextBoolean(); + + final int ROWS = 1 + new Random().nextInt(20); + final int COLUMNS = 1 + new Random().nextInt(20); + + final String STRATEGY; + final char testChar; // добавим точно валидное значение, что бы быть уверенным в тесте + + if (isOdd) { + STRATEGY = "Odd"; + testChar = 91; + + } else { + STRATEGY = "Even"; + testChar = 92; + } + + final String input = "" + ROWS + " " + COLUMNS + " " + STRATEGY.toLowerCase(); + + setInput(input); + + new RandomCharsTable().run(); + printOut(); + removeFromOutput("Введите данные:"); + + final String[] strategyRow = getOutputLines()[ROWS].trim().split(" - "); + final char[] charsInAnswerRow = + (strategyRow[1].replaceAll(",|\\s","") + testChar).toCharArray(); + + StringBuilder charsInTable = new StringBuilder(); + for (int i = 0; i < ROWS; i++){ + charsInTable.append(getOutputLines()[i].replaceAll("\\||\\s" , "")); + } + + charsInTable.append(testChar); + + for (char aChar : charsInAnswerRow) { + assertEquals(testChar % 2, aChar % 2); + assertNotEquals(-1, charsInTable.indexOf("" + aChar)); + } + assertEquals(STRATEGY + " letters", strategyRow[0]); + } +} \ No newline at end of file diff --git a/src/test/java/homework_2/traffic_light/TrafficLightTest.java b/src/test/java/homework_2/traffic_light/TrafficLightTest.java new file mode 100644 index 00000000..5014e1b1 --- /dev/null +++ b/src/test/java/homework_2/traffic_light/TrafficLightTest.java @@ -0,0 +1,117 @@ +package homework_2.traffic_light; + +import base.UnitBase; +import org.junit.jupiter.api.Test; + +import java.util.NoSuchElementException; + +import static org.junit.jupiter.api.Assertions.*; + +class TrafficLightTest extends UnitBase { + @Test + void InputZeroAsArgument() { + setInput("0"); + + new TrafficLight().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("GREEN", getOutputLines()[0]); + } + + @Test + void InputFiftyFiveAsArgument() { + setInput("55"); + + new TrafficLight().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("YELLOW", getOutputLines()[0]); + } + + @Test + void InputThirtyFiveAsArgument() { + setInput("35"); + + new TrafficLight().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("YELLOW", getOutputLines()[0]); + } + + @Test + void InputFiftyAsArgument() { + setInput("50"); + + new TrafficLight().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("RED", getOutputLines()[0]); + } + + @Test + void InputMinusOneAsArgument() { + setInput("-1"); + + new TrafficLight().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("Only 1 non-negative integer is allowed as passed parameter", getOutputLines()[0]); + } + + @Test + void InputStringValueAsArgument() { + setInput("String"); + + new TrafficLight().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("Only 1 non-negative integer is allowed as passed parameter", getOutputLines()[0]); + } + + @Test + void InputTwoArguments() { + setInput("2 2"); + + new TrafficLight().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("Only 1 non-negative integer is allowed as passed parameter", getOutputLines()[0]); + } + + @Test + void InputDoubleAsArgument() { + setInput("0.1"); + + new TrafficLight().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("Only 1 non-negative integer is allowed as passed parameter", getOutputLines()[0]); + } + + @Test + void InputDigitalValueBiggerThenIntegerAsArgument() { + setInput("9999999999"); + + new TrafficLight().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("Only 1 non-negative integer is allowed as passed parameter", getOutputLines()[0]); + } + + @Test + void InputValueBiggerThenSecInOneDayAsArgument() { + setInput("86401"); + + new TrafficLight().run(); + printOut(); + removeFromOutput("Введите данные:"); + assertEquals("The day is over", getOutputLines()[0]); + } + + @Test + void InputEmptyArgument() { + setInput(""); + assertThrows(NoSuchElementException.class, () -> new TrafficLight().run()); + } + +} \ No newline at end of file diff --git a/src/test/java/homework_4/custom_file_reader/CustomFileReaderTest.java b/src/test/java/homework_4/custom_file_reader/CustomFileReaderTest.java new file mode 100644 index 00000000..df5cca8d --- /dev/null +++ b/src/test/java/homework_4/custom_file_reader/CustomFileReaderTest.java @@ -0,0 +1,41 @@ +package homework_4.custom_file_reader; + +import base.UnitBase; +import org.junit.jupiter.api.Test; + +import java.io.FileNotFoundException; +import java.io.IOException; + +import static homework_4.custom_file_reader.CustomFileReader.*; +import static org.junit.jupiter.api.Assertions.assertFalse; + +class CustomFileReaderTest extends UnitBase { + + @Test + void TestRun1() throws IOException { + run1(); + assertFalse(getOutput().contains(".")); + assertFalse(getOutput().contains(",")); + } + + @Test + void TestRun2() throws IOException { + run2(); + assertFalse(getOutput().contains(".")); + assertFalse(getOutput().contains(",")); + } + + @Test + void TestRun3() throws IOException { + run3(); + assertFalse(getOutput().contains(".")); + assertFalse(getOutput().contains(",")); + } + + @Test + void TestRun4() throws IOException { + run4(); + assertFalse(getOutput().contains(".")); + assertFalse(getOutput().contains(",")); + } +} \ No newline at end of file diff --git a/src/test/java/homework_4/singleton/SingletonTest.java b/src/test/java/homework_4/singleton/SingletonTest.java new file mode 100644 index 00000000..dcda1c2c --- /dev/null +++ b/src/test/java/homework_4/singleton/SingletonTest.java @@ -0,0 +1,17 @@ +package homework_4.singleton; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class SingletonTest { + + @Test + void getInstance() { + Singleton singleton1 = Singleton.getInstance(); + Singleton singleton2 = Singleton.getInstance(); + + assertEquals(singleton1, singleton2); + assertTrue(singleton1 == singleton2); + } +} \ No newline at end of file diff --git "a/src/test/java/homework_4/\321\201ustom_annotation/SimpleClassWithNameFieldTest.java" "b/src/test/java/homework_4/\321\201ustom_annotation/SimpleClassWithNameFieldTest.java" new file mode 100644 index 00000000..582b2c3f --- /dev/null +++ "b/src/test/java/homework_4/\321\201ustom_annotation/SimpleClassWithNameFieldTest.java" @@ -0,0 +1,19 @@ +package homework_4.сustom_annotation; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class SimpleClassWithNameFieldTest { + @Test + void testEmptyNameString() { + SimpleClassWithNameField obj = new SimpleClassWithNameField(""); + assertEquals("test name string", obj.getName()); + } + + @Test + void testNotEmptyNameString() { + SimpleClassWithNameField obj = new SimpleClassWithNameField("test"); + assertEquals("test", obj.getName()); + } +} \ No newline at end of file diff --git a/src/test/java/homework_5/AppHW_5Test.java b/src/test/java/homework_5/AppHW_5Test.java new file mode 100644 index 00000000..f240e3a0 --- /dev/null +++ b/src/test/java/homework_5/AppHW_5Test.java @@ -0,0 +1,80 @@ +package homework_5; + +import base.UnitBase; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class AppHW_5Test extends UnitBase { + + @Test + void clearDataTest() { + String input_data = "default"; + setInput(input_data); + + AppHW_5 appHW_5 = new AppHW_5(); + appHW_5.readData(); + appHW_5.clearData(); + assertEquals("", appHW_5.getData()); + } + + @Test + void readDataTest() { + String input_data = "default"; + setInput(input_data); + + AppHW_5 appHW_5 = new AppHW_5(); + appHW_5.readData(); + + assertEquals(input_data, appHW_5.getData()); + } + + @Test + void checkTest() { + String input_data = "default"; + setInput(input_data); + + AppHW_5 appHW_5 = new AppHW_5(); + appHW_5.readData(); + + assertTrue(appHW_5.check()); + } + + @Test + void closeReaderTest() { + String input_data = "default"; + setInput(input_data); + + AppHW_5 appHW_5 = new AppHW_5(); + appHW_5.closeReader(); + + assertFalse(appHW_5.readData()); + } + + @Test + void getDataTest() { + assertEquals("", new AppHW_5().getData()); + } + + @Test + void getDataTest2() { + String input_data = "default"; + setInput(input_data); + + AppHW_5 appHW_5 = new AppHW_5(); + appHW_5.readData(); + + assertEquals("default", appHW_5.getData()); + } + + @Test + void getDataInvalidTest() { + String input_data = "default"; + setInput(input_data); + + AppHW_5 appHW_5 = new AppHW_5(); + appHW_5.readData(); + + assertNotEquals("def", appHW_5.getData()); + } +} \ No newline at end of file diff --git a/src/test/java/homework_5/custom_regex_matcher/CustomRegexMatcherTest.java b/src/test/java/homework_5/custom_regex_matcher/CustomRegexMatcherTest.java new file mode 100644 index 00000000..6a8a1224 --- /dev/null +++ b/src/test/java/homework_5/custom_regex_matcher/CustomRegexMatcherTest.java @@ -0,0 +1,44 @@ +package homework_5.custom_regex_matcher; + +import base.UnitBase; +import org.junit.jupiter.api.Test; + +import java.util.NoSuchElementException; + +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertThrows; + +class CustomRegexMatcherTest extends UnitBase { + + @Test + void validInputTest() { + final String input_value = "test_email@test_host.com"; + setInput(input_value); + + String result = new CustomRegexMatcher().run(); + + removeFromOutput("Введите данные:"); + assertEquals("true", result); + assertEquals("true", getOutputLines()[0]); + } + + @Test + void EmptyInputTest() { + final String input_value = ""; + setInput(input_value); + + assertThrows(NoSuchElementException.class, () -> new CustomRegexMatcher().run()); + } + + @Test + void notValidInputTest() { + final String input_value = "@test_host.com"; + setInput(input_value); + + String result = new CustomRegexMatcher().run(); + + removeFromOutput("Введите данные:"); + assertEquals("false", result); + assertEquals("false", getOutputLines()[0]); + } +} \ No newline at end of file diff --git a/src/test/java/homework_5/digit/DigitTest.java b/src/test/java/homework_5/digit/DigitTest.java new file mode 100644 index 00000000..e37e52cc --- /dev/null +++ b/src/test/java/homework_5/digit/DigitTest.java @@ -0,0 +1,25 @@ +package homework_5.digit; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class DigitTest { + @Test + void positiveNumberTest() { + final long num1 = 15_005_532L; + final long num2 = 12L; + + assertEquals(8, Digit.calculate(num1)); + assertEquals(2, Digit.calculate(num2)); + } + + @Test + void negativeNumberTest() { + final long num1 = -15_005_532L; + final long num2 = -12L; + + assertEquals(8, Digit.calculate(num1)); + assertEquals(2, Digit.calculate(num2)); + } +} \ No newline at end of file diff --git a/src/test/java/homework_5/exponent/ExponentTest.java b/src/test/java/homework_5/exponent/ExponentTest.java new file mode 100644 index 00000000..68fb8dfb --- /dev/null +++ b/src/test/java/homework_5/exponent/ExponentTest.java @@ -0,0 +1,49 @@ +package homework_5.exponent; + +import homework_5.power_of_number.Exponent; +import homework_5.power_of_number.InputNegativeBaseArgumentException; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +class ExponentTest { + + @Test + void positiveNumberTest() { + final int base1 = 2; + final int base2 = 9; + + final int num1 = 10_000; + final int num2 = 2; + + assertEquals(100_000_000, Exponent.calculate(num1,base1)); + assertEquals(512, Exponent.calculate(num2, base2)); + } + + @Test + void negativeNumberTest() { + final int base1 = 2; + final int base2 = 9; + + final int num1 = -10_000; + final int num2 = -2; + + assertEquals(100_000_000, Exponent.calculate(num1,base1)); + assertEquals(-512, Exponent.calculate(num2, base2)); + } + + @Test + void negativeBaseTest() { + final int base1 = -2; + final int base2 = -9; + + final int num1 = -10_000; + final int num2 = -2; + + assertThrows(InputNegativeBaseArgumentException.class, () -> Exponent.calculate(num1,base1)); + assertThrows(InputNegativeBaseArgumentException.class, () -> Exponent.calculate(num2, base2)); + + } + +} \ No newline at end of file diff --git a/src/test/java/homework_5/power_of_number/PowerOfNumberTest.java b/src/test/java/homework_5/power_of_number/PowerOfNumberTest.java new file mode 100644 index 00000000..08b35f40 --- /dev/null +++ b/src/test/java/homework_5/power_of_number/PowerOfNumberTest.java @@ -0,0 +1,69 @@ +package homework_5.power_of_number; + +import base.UnitBase; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +class PowerOfNumberTest extends UnitBase { + + @Test + void validInputTest() { + final String input_value = "2 2"; + setInput(input_value); + + String result = new PowerOfNumber().run(); + + removeFromOutput("Введите данные:"); + assertEquals("4", result); + assertEquals("4", getOutputLines()[0]); + } + + @Test + void validInputTest2() { + final String input_value = "0 0"; + setInput(input_value); + + String result = new PowerOfNumber().run(); + + removeFromOutput("Введите данные:"); + assertEquals("1", result); + assertEquals("1", getOutputLines()[0]); + } + + @Test + void EmptyInputTest() { + final String input_value = ""; + setInput(input_value); + + String result = new PowerOfNumber().run(); + + removeFromOutput("Введите данные:"); + assertEquals("Only 2 non-negative integers are allowed", result); + } + + @Test + void notValidInputTest() { + final String input_value = "@test_host.com"; + setInput(input_value); + + String result = new PowerOfNumber().run(); + + removeFromOutput("Введите данные:"); + assertEquals("Only 2 non-negative integers are allowed", result); + assertEquals("Only 2 non-negative integers are allowed", getOutputLines()[0]); + } + + @Test + void notValidInputTest2() { + final String input_value = "-2 0"; + setInput(input_value); + + String result = new PowerOfNumber().run(); + + removeFromOutput("Введите данные:"); + assertEquals("Only 2 non-negative integers are allowed", result); + assertEquals("Only 2 non-negative integers are allowed", getOutputLines()[0]); + } +} \ No newline at end of file diff --git a/src/test/java/homework_5/utils/impl/MyReaderImplTest.java b/src/test/java/homework_5/utils/impl/MyReaderImplTest.java new file mode 100644 index 00000000..d4dcfcbe --- /dev/null +++ b/src/test/java/homework_5/utils/impl/MyReaderImplTest.java @@ -0,0 +1,44 @@ +package homework_5.utils.impl; + +import base.UnitBase; +import org.junit.jupiter.api.Test; + +import java.util.NoSuchElementException; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +class MyReaderImplTest extends UnitBase { + + + @Test + void readValidTest() { + String input_value = "text"; + setInput(input_value); + + MyReaderImpl reader = new MyReaderImpl(); + + assertEquals(input_value, reader.readData()); + assertEquals("Введите данные:", getOutput()); + } + + @Test + void EmptyInputTest() { + final String input_value = ""; + setInput(input_value); + + assertThrows(NoSuchElementException.class, () -> new MyReaderImpl().readData()); + } + + @Test + void closeAndReadTest() { + final String input_value = "test"; + setInput(input_value); + + MyReaderImpl reader = new MyReaderImpl(); + reader.readData(); + reader.close(); + + assertThrows(IllegalStateException.class, reader::readData); + } +} \ No newline at end of file diff --git a/src/test/java/homework_5/utils/impl/StringCheckerImplTest.java b/src/test/java/homework_5/utils/impl/StringCheckerImplTest.java new file mode 100644 index 00000000..95a09f91 --- /dev/null +++ b/src/test/java/homework_5/utils/impl/StringCheckerImplTest.java @@ -0,0 +1,41 @@ +package homework_5.utils.impl; + +import base.UnitBase; +import org.junit.jupiter.api.Test; + +import java.util.regex.PatternSyntaxException; + +import static org.junit.jupiter.api.Assertions.*; + +class StringCheckerImplTest extends UnitBase { + + @Test + void setPatternValidTest() { + String pattern = "\\s+.*[\\w]?"; + + new StringCheckerImpl().setPattern(pattern); + } + + @Test + void setPatternInvalidTest() { + String pattern = "\\"; + + assertThrows(PatternSyntaxException.class, () -> new StringCheckerImpl().setPattern(pattern)); + } + + @Test + void checkValidDataTest() { + String pattern = "[abc]{0,3}"; + String input = "abc"; + + assertTrue(new StringCheckerImpl().setPattern(pattern).checkData(input)); + } + + @Test + void checkInvalidDataTest() { + String pattern = "[abc]{0,3}"; + String input = "abd"; + + assertFalse(new StringCheckerImpl().setPattern(pattern).checkData(input)); + } +} \ No newline at end of file