diff --git a/README.md b/README.md index 5d686e9f..69c88ab0 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,21 @@ + # Java Core June 2021 -## *Nikolaev Artem* +## *Drozdov Nikita* つ ◕_◕ ༽つ | 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/DrozdovNikita/src/main/java/homework_1) | The app that reads input arguments and prints them, until "error" argument | +| HW2 | [Traffic light](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/DrozdovNikita/src/main/java/homework_2/traffic_light)
[PyramidPrinter](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/DrozdovNikita/src/main/java/homework_2/pyramid_printer)
[RandomCharsTable](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/DrozdovNikita/src/main/java/homework_2/random_chars_table)| The app that reads input args and prints current traffic light
The app that reads input integer and prints "x" pyramid
The app that reads input arg, generate chars table and prints odd/even letters | +| HW3 | [ImmutableClass](https://github.com/NikolaevArtem/Java_Core_June_2021/blob/feature/DrozdovNikita/src/main/java/homework_3/MyImmutableClass.java) | | +| HW4 | [CustomFileReader](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/DrozdovNikita/src/main/java/homework_4/custom_file_reader)
[Singleton](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/DrozdovNikita/src/main/java/homework_4/singleton)
[CustomAnnotation](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/DrozdovNikita/src/main/java/homework_4/custom_annotation) | The app has 6 implementation file reader: Apache, BufferedReader, FileInputStream, Guava, Scanner and NIO
The app-singleton
The app use custom annotations to create xml structure for your object: XmlSerializable and XmlElement | +| HW5 | [PowerOfNumber](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/DrozdovNikita/src/main/java/homework_5/power_of_number)
[CustomRegexMatcher](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/DrozdovNikita/src/main/java/homework_5/custom_regex_matcher) | The app that reads two input integers and prints a to the power of b
The app that reads input phone number and prints its validity | +| HW6 | [MapProblemsGenerator](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/DrozdovNikita/src/main/java/homework_6) | The app that generate map problems +| HW7 | [KittenToCatFunction](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/DrozdovNikita/src/main/java/homework_7) | The app that implementation KittenToCatFunction functional interface +| CP | [SeaBattle](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/DrozdovNikita/src/main/java/course_project) | Sea Battle +| | | | +| TEST | [Test dir](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/DrozdovNikita/src/test/java) + -[Link to markdown giude](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) +[Link to markdown giude](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)
+[Link to сodingBat](https://codingbat.com/done?user=ndrozdov9@gmail.com&tag=8408048475) diff --git a/build.gradle b/build.gradle index b91dc843..522c2e14 100644 --- a/build.gradle +++ b/build.gradle @@ -12,6 +12,7 @@ repositories { dependencies { testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0' + testCompile 'org.junit.jupiter:junit-jupiter-params:5.7.0' } test { diff --git a/gradlew b/gradlew old mode 100644 new mode 100755 diff --git a/src/main/java/base/BaseClazz.java b/src/main/java/base/BaseClazz.java new file mode 100644 index 00000000..644820fb --- /dev/null +++ b/src/main/java/base/BaseClazz.java @@ -0,0 +1,28 @@ +package base; + +import java.math.BigInteger; +import java.util.stream.IntStream; + +public abstract class BaseClazz { + + protected static final String ANSI_RESET = "\033[0m"; + protected static final String ANSI_RED = "\u001B[31m"; + protected static final String ANSI_RED_BACKGROUND = "\u001B[41m"; + protected static final String ANSI_GREEN_BACKGROUND = "\u001B[42m"; + protected static final String ANSI_YELLOW_BACKGROUND = "\u001B[43m"; + + public abstract void run(); + + protected boolean isValid(String... arg) { + if (arg[0].split("\\s").length > 1) { + return false; + } + if (!arg[0].chars().allMatch(Character::isDigit)) { + return false; + } + + return new BigInteger(arg[0]).compareTo(BigInteger.valueOf(Integer.MAX_VALUE)) <= 0 && + IntStream.of(Integer.parseInt(arg[0])).allMatch(elem -> elem + 1 > 0); + } + +} diff --git a/src/main/java/course_project/Game.java b/src/main/java/course_project/Game.java new file mode 100644 index 00000000..417f53f1 --- /dev/null +++ b/src/main/java/course_project/Game.java @@ -0,0 +1,97 @@ +package course_project; + +import base.BaseClazz; +import course_project.services.FieldPrinter; +import course_project.services.GameService; +import course_project.services.PlayerController; +import course_project.ship.abstracts.SinglePartShip; +import course_project.ship.models.Player; +import course_project.ship.abstracts.ShipType; + +import java.util.*; +import java.util.function.Function; +import java.util.stream.Stream; + +import static course_project.services.GameService.*; + +public class Game extends BaseClazz { + + private static String MISS = "Промах. В следующий раз повезет"; + + private final Player player = new Player("player1"); + private final Player computer = new Player("player2"); + + public static Scanner scanner = new Scanner(System.in); + + private static final Function> convert = + elem -> elem + .getMapShips() + .values() + .stream() + .flatMap(e -> e + .stream() + .flatMap(l -> l.getList().stream())); + + @Override + public void run() { + player.getMapShips().putAll(GameService.getNewPlayerWithRandomShips(player.getName()).getMapShips()); + computer.getMapShips().putAll(GameService.getNewPlayerWithRandomShips(computer.getName()).getMapShips()); + startGame(); + } + + private void startGame() { + Player aim = computer; + Player attacker = player; + while (!(player.isEmptyHealthShips() || computer.isEmptyHealthShips())) { + FieldPrinter.printFiled(convert.apply(attacker), attacker.getHitsMap(), attacker.getDamageList().stream()); + String result = playersHit(aim, attacker); + if (!result.equals(MISS)) { + System.out.println(result); + } else { + aim = (aim == computer ? player : computer); + attacker = (attacker == computer ? player : computer); + clearConsole(); + System.out.println(result); + try { + Thread.sleep(1500); + } catch (InterruptedException e) { + e.printStackTrace(); + } + clearConsole(); + } + } + FieldPrinter.printFiled(convert.apply(attacker), attacker.getHitsMap(), attacker.getDamageList().stream()); + System.out.println("Победил " + attacker.getName()); + } + + private void initPlayer(Player gamer) { + FieldPrinter.printFieldForInit(convert.apply(gamer)); + PlayerController.initShipLists(gamer, ShipType.SINGLE_DECK, 4); + FieldPrinter.printFieldForInit(convert.apply(gamer)); + PlayerController.initShipLists(gamer, ShipType.DOUBLE_DECK, 3); + FieldPrinter.printFieldForInit(convert.apply(gamer)); + PlayerController.initShipLists(gamer, ShipType.THREE_DECK, 2); + FieldPrinter.printFieldForInit(convert.apply(gamer)); + PlayerController.initShipLists(gamer, ShipType.FOUR_DECK, 1); + } + + private void initPlayer1(Player gamer) { + PlayerController.addToList(gamer, ShipType.SINGLE_DECK, "A10", "V", 1); + PlayerController.addToList(gamer, ShipType.SINGLE_DECK, "D9", "V", 1); + PlayerController.addToList(gamer, ShipType.SINGLE_DECK, "F9", "V", 1); + PlayerController.addToList(gamer, ShipType.SINGLE_DECK, "G6", "V", 1); + PlayerController.addToList(gamer, ShipType.DOUBLE_DECK, "A1", "H", 2); + PlayerController.addToList(gamer, ShipType.DOUBLE_DECK, "J3", "V", 2); + PlayerController.addToList(gamer, ShipType.DOUBLE_DECK, "I9", "V", 2); + PlayerController.addToList(gamer, ShipType.THREE_DECK, "D1", "V", 3); + PlayerController.addToList(gamer, ShipType.THREE_DECK, "B5", "V", 3); + PlayerController.addToList(gamer, ShipType.FOUR_DECK, "G1", "H", 4); + } + + private void clearConsole() { + for (int i = 0; i < 20; i++) { + System.out.println(); + } + } + +} \ No newline at end of file diff --git a/src/main/java/course_project/Main.java b/src/main/java/course_project/Main.java new file mode 100644 index 00000000..45e469da --- /dev/null +++ b/src/main/java/course_project/Main.java @@ -0,0 +1,11 @@ +package course_project; + +public class Main { + + public static void main(String[] args) { + + new Game().run(); + + } + +} diff --git a/src/main/java/course_project/services/FieldPrinter.java b/src/main/java/course_project/services/FieldPrinter.java new file mode 100644 index 00000000..5039e8d3 --- /dev/null +++ b/src/main/java/course_project/services/FieldPrinter.java @@ -0,0 +1,99 @@ +package course_project.services; + +import course_project.ship.abstracts.SinglePartShip; + +import java.util.List; +import java.util.Map; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +public class FieldPrinter { + + private static final int FIELD_CAPACITY = 10; + protected static final String ANSI_RESET = "\033[0m"; + protected static final String ANSI_GREEN = "\u001B[32m"; + protected static final String ANSI_CYAN = "\u001B[36m"; + + private FieldPrinter() { + throw new IllegalStateException("Utility class"); + } + + public static void printFieldForInit(Stream attacker) { + int[][] attackerField = new int[FIELD_CAPACITY][FIELD_CAPACITY]; + attacker.forEach(elem -> add(attackerField, elem, 1)); + printTableHeader(); + System.out.println(); + for (int i = 0; i < FIELD_CAPACITY; i++) { + printLineTable(i, attackerField); + System.out.println(); + } + } + + public static void printFiled(Stream attacker, + Map> opponent, + Stream damageList) { + int[][] attackerField = new int[FIELD_CAPACITY][FIELD_CAPACITY]; + int[][] opponentField = new int[FIELD_CAPACITY][FIELD_CAPACITY]; + attacker.forEach(elem -> add(attackerField, elem, 1)); + damageList.forEach(elem -> add(attackerField, elem, -1)); + opponent.entrySet().forEach(elem -> add(opponentField, elem)); + + System.out.printf("%-51s", "your field"); + System.out.println("opponent field"); + + printTableHeader(); + System.out.printf("%4s", " | "); + printTableHeader(); + System.out.println(); + + for (int i = 0; i < FIELD_CAPACITY; i++) { + printLineTable(i, attackerField); + System.out.printf("%4s", " | "); + printLineOpponentTable(i, opponentField); + System.out.println(); + } + } + + private static void printTableHeader() { + System.out.printf("%4s", ""); + IntStream.range(0, FIELD_CAPACITY).forEach(i -> System.out.printf("%4s", (char) (65 + i))); + } + + private static void printLineTable(int i, int[][] field) { + System.out.printf("%4s", i + 1); + for (int j = 0; j < FIELD_CAPACITY; j++) { + if (field[i][j] == 1) { + System.out.printf("%13s", ANSI_GREEN + "x" + ANSI_RESET); + } else if (field[i][j] == -1) { + System.out.printf("%13s", ANSI_CYAN + "o" + ANSI_RESET); + } else { + System.out.printf("%4s", "."); + } + } + } + + private static void printLineOpponentTable(int i, int[][] field) { + System.out.printf("%4s", i + 1); + for (int j = 0; j < FIELD_CAPACITY; j++) { + if (field[i][j] == 1) { + System.out.printf("%13s", ANSI_GREEN + "x" + ANSI_RESET); + } else if (field[i][j] == -1) { + System.out.printf("%13s", ANSI_CYAN + "o" + ANSI_RESET); + } else { + System.out.printf("%4s", "?"); + } + } + } + + private static void add(int[][] field, SinglePartShip partShip, int value) { + field[partShip.getY() - 1][partShip.getX() - 1] = value; + } + + private static void add(int[][] field, Map.Entry> partShip) { + if (partShip.getKey()) { + partShip.getValue().forEach(elem -> add(field, elem, 1)); + } else { + partShip.getValue().forEach(elem -> add(field, elem, -1)); + } + } +} \ No newline at end of file diff --git a/src/main/java/course_project/services/GameService.java b/src/main/java/course_project/services/GameService.java new file mode 100644 index 00000000..a648be2b --- /dev/null +++ b/src/main/java/course_project/services/GameService.java @@ -0,0 +1,214 @@ +package course_project.services; + +import course_project.Game; +import course_project.ship.abstracts.ShipType; +import course_project.ship.models.Player; +import course_project.ship.abstracts.SinglePartShip; + +import java.security.NoSuchAlgorithmException; +import java.security.SecureRandom; +import java.util.*; + +public final class GameService { + + private static final String SHIP_SANK = "Вражеский корабль потоплен!"; + private static final String SHIP_DAMAGED = "Вражеский корабль подбит"; + private static final String MISS = "Промах. В следующий раз повезет"; + private static final String INVALID_IN = "Неверные координаты цели, попробуйте еще раз!"; + private static final String EXIST_HIT = "Вы уже стреляли по цели с такими координатами!"; + private static final String ANSI_RESET = "\033[0m"; + private static final String ANSI_RED = "\u001B[31m"; + + private static Random rand; + + static { + try { + rand = SecureRandom.getInstanceStrong(); + } catch (NoSuchAlgorithmException e) { + e.printStackTrace(); + } + } + + private GameService() { + throw new IllegalStateException("Utility class"); + } + + public static String playersHit(Player aim, Player attacker) { + String coordinates = getNewCoordinates(attacker.getName()); + SinglePartShip partShip = new SinglePartShip(coordinates.charAt(0) - 64, new Integer(coordinates.substring(1))); + while (containsHit(aim, partShip)) { + System.out.println(ANSI_RED + EXIST_HIT + ANSI_RESET); + coordinates = getNewCoordinates(attacker.getName()); + partShip = new SinglePartShip(coordinates.charAt(0) - 64, new Integer(coordinates.substring(1))); + } + aim.getDamageList().add(partShip); + attacker.getHitsMap().get(aim.containsShip(partShip)).add(partShip); + if (aim.containsShip(partShip)) { + if (PlayerController.destroyPartShip(aim, partShip)) { + markSunkShip(attacker, aim, partShip); + return SHIP_SANK; + } else { + return SHIP_DAMAGED; + } + } + return MISS; + } + + public static boolean markSunkShip(Player attacker, Player aim, SinglePartShip partShip) { + List marks = new ArrayList<>(); + + List ship = aim.getShip(partShip).getList(); + List damageList = aim.getDamageList(); + if (ship.size() < 2 || ship.get(0).getY().equals(ship.get(1).getY())) { + marks.addAll(markSunkHorizontalShip(ship)); + } else { + marks.addAll(markSunkVerticalShip(ship)); + } + return attacker.getHitsMap().get(Boolean.FALSE).addAll(marks) && damageList.addAll(marks); + } + + private static Set markSunkVerticalShip(List list) { + Set hitsSet = new HashSet<>(); + SinglePartShip headerShip = list.get(0); + addToList(hitsSet, new SinglePartShip(headerShip.getX() - 1, headerShip.getY() - 1)); + addToList(hitsSet, new SinglePartShip(headerShip.getX(), headerShip.getY() - 1)); + addToList(hitsSet, new SinglePartShip(headerShip.getX() + 1, headerShip.getY() - 1)); + for (SinglePartShip s : list) { + addToList(hitsSet, new SinglePartShip(s.getX() - 1, s.getY())); + addToList(hitsSet, new SinglePartShip(s.getX() + 1, s.getY())); + } + SinglePartShip lastShip = list.get(list.size() - 1); + addToList(hitsSet, new SinglePartShip(lastShip.getX() - 1, lastShip.getY() + 1)); + addToList(hitsSet, new SinglePartShip(lastShip.getX(), lastShip.getY() + 1)); + addToList(hitsSet, new SinglePartShip(lastShip.getX() + 1, lastShip.getY() + 1)); + return hitsSet; + } + + private static Set markSunkHorizontalShip(List list) { + Set hitsList = new HashSet<>(); + SinglePartShip headerShip = list.get(0); + addToList(hitsList, new SinglePartShip(headerShip.getX() - 1, headerShip.getY() - 1)); + addToList(hitsList, new SinglePartShip(headerShip.getX() - 1, headerShip.getY())); + addToList(hitsList, new SinglePartShip(headerShip.getX() - 1, headerShip.getY() + 1)); + for (SinglePartShip s : list) { + addToList(hitsList, new SinglePartShip(s.getX(), s.getY() - 1)); + addToList(hitsList, new SinglePartShip(s.getX(), s.getY() + 1)); + } + SinglePartShip lastShip = list.get(list.size() - 1); + addToList(hitsList, new SinglePartShip(lastShip.getX() + 1, lastShip.getY() - 1)); + addToList(hitsList, new SinglePartShip(lastShip.getX() + 1, lastShip.getY())); + addToList(hitsList, new SinglePartShip(lastShip.getX() + 1, lastShip.getY() + 1)); + + return hitsList; + } + + private static boolean addToList(Set hitsList, SinglePartShip partShip) { + if ((0 < partShip.getX() && partShip.getX() < 11) && (0 < partShip.getY() && partShip.getY() < 11)) { + return hitsList.add(partShip); + } + return false; + } + + public static boolean isVerticalNeighbor(Player gamer, SinglePartShip partShip) { + int x = partShip.getX(); + int y = partShip.getY(); + return gamer.containsShip(partShip.setX(x - 1)) ||//-x + gamer.containsShip(partShip.setX(x - 1).setY(y + 1)) ||//-x +y + gamer.containsShip(partShip.setY(y + 1)) ||//+y + gamer.containsShip(partShip.setX(x + 1).setY(y + 1)) ||//+x +y + gamer.containsShip(partShip.setX(x + 1));//+x + } + + public static boolean isHorizontalNeighbor(Player gamer, SinglePartShip partShip) { + int x = partShip.getX(); + int y = partShip.getY(); + return gamer.containsShip(partShip.setY(y - 1)) ||//-y + gamer.containsShip(partShip.setX(x + 1).setY(y - 1)) ||//+x -y + gamer.containsShip(partShip.setX(x + 1)) ||//+x + gamer.containsShip(partShip.setX(x + 1).setY(y + 1)) ||//+x +y + gamer.containsShip(partShip.setY(y + 1));//+y + } + + + public static boolean isHeaderNeighbor(Player gamer, SinglePartShip partShip) { + int x = partShip.getX(); + int y = partShip.getY(); + + return gamer.containsShip(partShip.setX(x - 1).setY(y - 1)) ||//-x -y + gamer.containsShip(partShip.setY(y - 1)) ||//-y + gamer.containsShip(partShip.setX(x + 1).setY(y - 1)) ||//+x -y + gamer.containsShip(partShip.setX(x - 1)) ||//-x + gamer.containsShip(partShip.setX(x + 1)) ||//+x + gamer.containsShip(partShip.setX(x - 1).setY(y + 1)) ||//-x +y + gamer.containsShip(partShip.setY(y + 1)) ||//+y + gamer.containsShip(partShip.setX(x + 1).setY(y + 1));//+x +y + } + + public static String getNewCoordinates(String name) { + System.out.printf(name + ": введите координаты цели([A-J][1-10]): "); + String coordinates = Game.scanner.nextLine().trim().toUpperCase(Locale.ROOT); + while (!isValidCoordinatesForShot(coordinates)) { + System.out.println(ANSI_RED + INVALID_IN + ANSI_RESET); + System.out.printf(name + ": введите координаты цели([A-J][1-10]): "); + coordinates = Game.scanner.nextLine().trim().toUpperCase(Locale.ROOT); + } + return coordinates; + } + + public static String getNewCoordinates(int numberOfShip, int numberOfShipDeck) { + System.out.printf("Введите координаты и положение %1$s-ого %2$s-палубного корабля([A-J][1-10] [v|h]): ", numberOfShip, numberOfShipDeck); + String coordinates = Game.scanner.nextLine().trim().toUpperCase(Locale.ROOT); + while (!isValidCoordinatesForShip(coordinates)) { + System.out.println(ANSI_RED + INVALID_IN + ANSI_RESET); + System.out.printf("Введите координаты и положение %1$s-ого %2$s-палубного корабля([A-J][1-10] [v|h]): ", numberOfShip, numberOfShipDeck); + coordinates = Game.scanner.nextLine().trim().toUpperCase(Locale.ROOT); + } + return coordinates; + } + + public static Player getNewPlayerWithRandomShips(String name) { + Player tempPlayer = new Player(name); + + for (int i = 0; i < 4; i++) { + + for (int j = i; j < 4; j++) { + + String coordinates = getRandomCoordinates(); + String location = rand.nextBoolean() ? "V" : "H"; + + SinglePartShip partShip = new SinglePartShip(coordinates.charAt(0) - 64, new Integer(coordinates.substring(1))); + while (tempPlayer.containsShip(partShip) || + !PlayerController.addToList(tempPlayer, ShipType.getType(i + 1), coordinates, location, i + 1)) { + coordinates = getRandomCoordinates(); + location = rand.nextBoolean() ? "V" : "H"; + partShip = new SinglePartShip(coordinates.charAt(0) - 64, new Integer(coordinates.substring(1))); + } + } + } + + return tempPlayer; + } + + private static boolean containsHit(Player gamer, SinglePartShip partShip) { + return gamer.getDamageList().contains(partShip); + } + + private static boolean isValidCoordinatesForShot(String... arg) { + if (arg[0].split("\\s").length > 1) { + return false; + } + return arg[0].matches("[A-J][1-9][0]*"); + } + + private static boolean isValidCoordinatesForShip(String... arg) { + if (arg[0].split("\\s").length != 2) { + return false; + } + String[] split = arg[0].split("\\s"); + return split[0].matches("[A-J]([1-9]|10)") && split[1].matches("[VH]"); + } + + private static String getRandomCoordinates() { + return (char) (65 + rand.nextInt(10)) + String.valueOf(rand.nextInt(10) + 1); + } +} diff --git a/src/main/java/course_project/services/PlayerController.java b/src/main/java/course_project/services/PlayerController.java new file mode 100644 index 00000000..072b03ec --- /dev/null +++ b/src/main/java/course_project/services/PlayerController.java @@ -0,0 +1,80 @@ +package course_project.services; + +import course_project.ship.abstracts.ShipStatus; +import course_project.ship.abstracts.ShipType; +import course_project.ship.models.Player; +import course_project.ship.models.Ship; +import course_project.ship.abstracts.SinglePartShip; + +import java.util.*; + +import static course_project.services.GameService.*; + +public final class PlayerController { + + private static final String ANSI_RESET = "\033[0m"; + private static final String ANSI_RED = "\u001B[31m"; + + private PlayerController() { + throw new IllegalStateException("Utility class"); + } + + public static boolean destroyPartShip(Player player, SinglePartShip partShip) { + Map> ships = player.getMapShips(); + Collection> values = ships.values(); + + for (List next : values) { + for (Ship next1 : next) { + if (next1.getList().contains(partShip)) { + List list = next1.getList(); + for (SinglePartShip singlePartShip : list) { + if (singlePartShip.equals(partShip)) { + singlePartShip.setStatus(ShipStatus.SANK); + } + } + return list.stream().noneMatch(elem -> elem.getStatus().equals(ShipStatus.HEALTHY)); + } + } + } + return false; + } + + public static void initShipLists(Player gamer, ShipType shipType, int countOfDeck) { + for (int i = 0; i < countOfDeck; i++) { + String coordinates = GameService.getNewCoordinates(i + 1, 5 - countOfDeck); + if (!addToList(gamer, shipType, coordinates.split("\\s")[0], coordinates.split("\\s")[1], 5 - countOfDeck)) { + System.out.println(ANSI_RED + "Что-то пошло не так, попробуйте еще раз" + ANSI_RESET); + i--; + } + } + } + + public static boolean addToList(Player gamer, ShipType shipType, String coordinates, String location, int countOfDeck) { + List tempList = new ArrayList<>(); + SinglePartShip partShip = new SinglePartShip(coordinates.charAt(0) - 64, new Integer(coordinates.substring(1))); + for (int i = 0; i < countOfDeck; i++) { + if (i == 0 && isHeaderNeighbor(gamer, partShip)) { + return false; + } + if (gamer.containsShip(partShip)) { + return false; + } + if ((partShip.getX() > 10 || partShip.getY() > 10)) { + return false; + } + if (location.equals("V") ? isVerticalNeighbor(gamer, partShip) : isHorizontalNeighbor(gamer, partShip)) { + return false; + } + tempList.add(partShip); + if (location.equals("V")) { + partShip = partShip.setY(partShip.getY() + 1); + } else { + partShip = partShip.setX(partShip.getX() + 1); + } + } + gamer.getMapShips().get(shipType.getType()).add(new Ship(tempList)); + return true; + } + + +} diff --git a/src/main/java/course_project/ship/abstracts/ShipStatus.java b/src/main/java/course_project/ship/abstracts/ShipStatus.java new file mode 100644 index 00000000..c3b15acc --- /dev/null +++ b/src/main/java/course_project/ship/abstracts/ShipStatus.java @@ -0,0 +1,23 @@ +package course_project.ship.abstracts; + +public enum ShipStatus { + + SANK("Sank", 0), + HEALTHY("Healthy", 1); + + private String status; + private int value; + + ShipStatus(String status, int value) { + this.status = status; + this.value = value; + } + + public String getStatus() { + return status; + } + + public int getValue() { + return value; + } +} diff --git a/src/main/java/course_project/ship/abstracts/ShipType.java b/src/main/java/course_project/ship/abstracts/ShipType.java new file mode 100644 index 00000000..3b3d871b --- /dev/null +++ b/src/main/java/course_project/ship/abstracts/ShipType.java @@ -0,0 +1,35 @@ +package course_project.ship.abstracts; + +public enum ShipType { + + SINGLE_DECK ("SingleDeckShip", 4), + DOUBLE_DECK ("DoubleDeckShip", 3), + THREE_DECK ("ThreeDeckShip", 2), + FOUR_DECK ("FourDeckShip", 1); + + private String type; + private int count; + + ShipType(String type, int count) { + this.type = type; + this.count = count; + } + + public String getType() { + return type; + } + + public static ShipType getType(int n) { + switch (n) { + case 1: return ShipType.SINGLE_DECK; + case 2: return ShipType.DOUBLE_DECK; + case 3: return ShipType.THREE_DECK; + case 4: return ShipType.FOUR_DECK; + } + return null; + } + + public int getCount() { + return count; + } +} diff --git a/src/main/java/course_project/ship/abstracts/SinglePartShip.java b/src/main/java/course_project/ship/abstracts/SinglePartShip.java new file mode 100644 index 00000000..601a9181 --- /dev/null +++ b/src/main/java/course_project/ship/abstracts/SinglePartShip.java @@ -0,0 +1,61 @@ +package course_project.ship.abstracts; + +import java.util.Objects; + +public class SinglePartShip { + + private Integer x; + private Integer y; + private ShipStatus status; + + public SinglePartShip(Integer x, Integer y) { + this.x = x; + this.y = y; + status = ShipStatus.HEALTHY; + } + + public Integer getX() { + return x; + } + + public SinglePartShip setX(Integer x) { + return new SinglePartShip(x, this.y); + } + + public Integer getY() { + return y; + } + + public SinglePartShip setY(Integer y) { + return new SinglePartShip(this.x, y); + } + + public ShipStatus getStatus() { + return status; + } + + public void setStatus(ShipStatus status) { + this.status = status; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + SinglePartShip partShip = (SinglePartShip) o; + return Objects.equals(x, partShip.x) && Objects.equals(y, partShip.y); + } + + @Override + public int hashCode() { + return Objects.hash(x, y); + } + + @Override + public String toString() { + return "{" + + "x=" + x + + ", y=" + y + + '}'; + } +} diff --git a/src/main/java/course_project/ship/models/Player.java b/src/main/java/course_project/ship/models/Player.java new file mode 100644 index 00000000..0603ba3f --- /dev/null +++ b/src/main/java/course_project/ship/models/Player.java @@ -0,0 +1,79 @@ +package course_project.ship.models; + +import course_project.ship.abstracts.ShipStatus; +import course_project.ship.abstracts.SinglePartShip; +import course_project.ship.abstracts.ShipType; + +import java.util.*; +import java.util.stream.Stream; + +public class Player { + + private String name; + private final Map> ships = new HashMap<>(); + private final Map> hitsMap = new HashMap<>(); + private final List damageList = new ArrayList<>(); + + public Player(String name) { + this.name = name; + ships.put(ShipType.SINGLE_DECK.getType(), new ArrayList<>()); + ships.put(ShipType.DOUBLE_DECK.getType(),new ArrayList<>()); + ships.put(ShipType.THREE_DECK.getType(), new ArrayList<>()); + ships.put(ShipType.FOUR_DECK.getType(), new ArrayList<>()); + + hitsMap.put(Boolean.TRUE, new ArrayList<>()); + hitsMap.put(Boolean.FALSE, new ArrayList<>()); + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public List getDamageList() { + return damageList; + } + + public Map> getMapShips() { + return ships; + } + + public Map> getHitsMap() { + return hitsMap; + } + + public Ship getShip(SinglePartShip partShip) { + Collection> values = ships.values(); + for (List shipList : values) { + for (Ship ship : shipList) { + if (ship.contains(partShip)) { + return ship; + } + } + } + return null; + } + + public boolean containsShip(SinglePartShip singlePartShip) { + Stream singlePartShipStream = ships + .values() + .stream() + .flatMap(elem -> elem + .stream() + .flatMap(l -> l.getList().stream())); + return singlePartShipStream.anyMatch(elem -> elem.equals(singlePartShip)); + } + + public boolean isEmptyHealthShips() { + Stream singlePartShipStream = ships + .values() + .stream() + .flatMap(elem -> elem + .stream() + .flatMap(l -> l.getList().stream())); + return singlePartShipStream.noneMatch(elem -> elem.getStatus().equals(ShipStatus.HEALTHY)); + } +} diff --git a/src/main/java/course_project/ship/models/Ship.java b/src/main/java/course_project/ship/models/Ship.java new file mode 100644 index 00000000..991c0a72 --- /dev/null +++ b/src/main/java/course_project/ship/models/Ship.java @@ -0,0 +1,26 @@ +package course_project.ship.models; + +import course_project.ship.abstracts.SinglePartShip; + +import java.util.ArrayList; +import java.util.List; + +public class Ship { + + private final List list = new ArrayList<>(); + + public Ship() { + } + + public Ship(List list) { + this.list.addAll(list); + } + + public boolean contains(SinglePartShip singlePartShip) { + return list.contains(singlePartShip); + } + + public List getList() { + return list; + } +} diff --git a/src/main/java/homework_1/Main.java b/src/main/java/homework_1/Main.java index 07c029a2..95b12963 100644 --- a/src/main/java/homework_1/Main.java +++ b/src/main/java/homework_1/Main.java @@ -2,8 +2,13 @@ public class Main { - public static void main(String[] args) { - System.out.println("Hello homework!"); - } - + public static void main(String[] args) { + for (String arg : args) { + if (arg.equals("error")) { + System.out.println("\033[0;31m" + "Alarm!" + "\033[0m"); + break; + } + System.out.println(arg + ": " + arg.length() + " letters"); + } + } } 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..7d3a6d98 --- /dev/null +++ b/src/main/java/homework_2/pyramid_printer/PyramidPrinter.java @@ -0,0 +1,32 @@ +package homework_2.pyramid_printer; + +import base.BaseClazz; + +import java.util.Scanner; + +public class PyramidPrinter extends BaseClazz { + + private static final String ERROR_MESSAGE = "Only 1 non-negative integer is allowed as passed parameter"; + + @Override + public void run() { + System.out.println("Enter the number"); + Scanner scanner = new Scanner(System.in); + String inputStr = scanner.nextLine().trim(); + if (isValid(inputStr)) { + printPyramid(Integer.parseInt(inputStr)); + } else { + System.out.println(ANSI_RED + ERROR_MESSAGE + ANSI_RESET); + } + scanner.close(); + } + + private void printPyramid(int n) { + for (int i = 0; i < n; i++) { + for (int j = 0; j < i + 1; j++) { + System.out.print("x"); + } + System.out.println(); + } + } +} 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..32437e19 --- /dev/null +++ b/src/main/java/homework_2/random_chars_table/RandomCharsTable.java @@ -0,0 +1,83 @@ +package homework_2.random_chars_table; + +import base.BaseClazz; + +import java.util.*; + +public class RandomCharsTable extends BaseClazz { + + private static final String ERROR_MESSAGE = "Passed parameters should match the format [positive integer] [positive integer] [even|odd]"; + + @Override + public void run() { + Scanner systemScanner = new Scanner(System.in); + + System.out.println("Enter width, height and parity"); + String s = systemScanner.nextLine(); + if (isValid(s)) { + Scanner stringScanner = new Scanner(s); + char[][] table = RandomCharsTableCreator.initAndFillTable(stringScanner.nextInt(), stringScanner.nextInt()); + String parity = stringScanner.next(); + List characterList = getValidChars(table, parity); + + printTable(table); + System.out.println(parity + " letters - " + getResult(characterList)); + stringScanner.close(); + } else { + System.out.println(ANSI_RED + ERROR_MESSAGE + ANSI_RESET); + } + + systemScanner.close(); + } + + @Override + protected boolean isValid(String... inputStr) { + if (inputStr.length > 1) return false; + return inputStr[0].matches("^(([1-9][0-9]*\\s){2})(odd|even)"); + } + + public void printTable(char[][] arrayOfChars) { + for (char[] chars : arrayOfChars) { + System.out.print("|"); + for (char ch : chars) { + System.out.print(ch + "|"); + } + System.out.println(); + } + } + + private String getResult(List characterList) { + StringBuilder stringBuilder = new StringBuilder(); + ListIterator characterListIterator = characterList.listIterator(); + + while (characterListIterator.hasNext()) { + stringBuilder.append(characterListIterator.next()); + if (characterListIterator.hasNext()) { + stringBuilder.append(", "); + } else { + stringBuilder.append("\n"); + } + } + return stringBuilder.toString(); + } + + private List getValidChars(char[][] arrayOfChars, String parity) { + List characterList = new ArrayList<>(); + + for (char[] chars : arrayOfChars) { + for (char ch : chars) { + if (parity.equals("even")) { + if (ch % 2 == 0) { + characterList.add(ch); + } + } else { + if (ch % 2 == 1) { + characterList.add(ch); + } + } + } + } + + return characterList; + } +} diff --git a/src/main/java/homework_2/random_chars_table/RandomCharsTableCreator.java b/src/main/java/homework_2/random_chars_table/RandomCharsTableCreator.java new file mode 100644 index 00000000..f545aa88 --- /dev/null +++ b/src/main/java/homework_2/random_chars_table/RandomCharsTableCreator.java @@ -0,0 +1,23 @@ +package homework_2.random_chars_table; + +import java.util.Random; + +public final class RandomCharsTableCreator { + + private static final Random random = new Random(); + + private RandomCharsTableCreator() { + throw new IllegalStateException("Utility class"); + } + + public static char[][] initAndFillTable(int height, int width) { + char[][] table = new char[height][width]; + for (int i = 0; i < height; i++) { + for (int j = 0; j < width; j++) { + table[i][j] = (char) (random.nextInt(26) + 65); + } + } + return table; + } + +} 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..cbe0ed4b --- /dev/null +++ b/src/main/java/homework_2/traffic_light/TrafficLight.java @@ -0,0 +1,44 @@ +package homework_2.traffic_light; + +import base.BaseClazz; + +import java.util.Scanner; + +public class TrafficLight extends BaseClazz { + + private static final String ERROR_MESSAGE = "Only 1 non-negative integer is allowed as passed parameter"; + + @Override + public void run() { + System.out.println("Enter the number"); + Scanner scanner = new Scanner(System.in); + String inputStr = scanner.nextLine().trim(); + if (isValid(inputStr)) { + if (Integer.parseInt(inputStr) < 86400) { + int seconds = Integer.parseInt(inputStr); + String result = getTrafficLight(seconds); + System.out.println(result); + } else { + System.out.println(ANSI_RED + "Day is over" + ANSI_RESET); + } + } else { + System.out.println(ANSI_RED + ERROR_MESSAGE + ANSI_RESET); + } + scanner.close(); + } + + protected String getTrafficLight(int numberOfSeconds) { + int cutNumberOfSeconds = numberOfSeconds % 60; + if (0 <= cutNumberOfSeconds && cutNumberOfSeconds < 35) { + return ANSI_GREEN_BACKGROUND + "Green light" + ANSI_RESET; + } + if (35 <= cutNumberOfSeconds && cutNumberOfSeconds < 40 || cutNumberOfSeconds >= 55) { + return ANSI_YELLOW_BACKGROUND + "Yellow light" + ANSI_RESET; + } + if (cutNumberOfSeconds >= 40) { + return ANSI_RED_BACKGROUND + "Red light" + ANSI_RESET; + } + return "Something went wrong"; + } +} + diff --git a/src/main/java/homework_2/traffic_light/TrafficLightExtraMode.java b/src/main/java/homework_2/traffic_light/TrafficLightExtraMode.java new file mode 100644 index 00000000..376278b5 --- /dev/null +++ b/src/main/java/homework_2/traffic_light/TrafficLightExtraMode.java @@ -0,0 +1,34 @@ +package homework_2.traffic_light; + +import java.time.DateTimeException; +import java.time.LocalTime; +import java.util.Scanner; + +public class TrafficLightExtraMode extends TrafficLight { + + private int secondsParsed; + + @Override + public void run() { + System.out.println("Enter the number"); + Scanner scanner = new Scanner(System.in); + String inputStr = scanner.nextLine(); + if (isValid(inputStr)) { + String result = getTrafficLight(secondsParsed); + System.out.println(result); + } + scanner.close(); + } + + @Override + public boolean isValid(String... arg) { + if (arg.length > 1) return false; + try { + secondsParsed = LocalTime.parse(arg[0]).toSecondOfDay(); + } catch (DateTimeException exception) { + System.out.println(ANSI_RED + "Only hh:mm:ss input format (hh < 24, mm < 60, ss < 60)" + ANSI_RESET); + return false; + } + return true; + } +} diff --git a/src/main/java/homework_3/MyImmutableClass.java b/src/main/java/homework_3/MyImmutableClass.java new file mode 100644 index 00000000..0e47946e --- /dev/null +++ b/src/main/java/homework_3/MyImmutableClass.java @@ -0,0 +1,71 @@ +package homework_3; + +import java.time.LocalDate; +import java.util.HashMap; +import java.util.Map; + +/* +The class and his fields must have a final modifier +The class don't must have setters +Fields must have a private modifier +The constructor should do defensive copy for reference object +Defensive copy to reference object should be for getters + */ +public final class MyImmutableClass { + + private final String myName; + private final int myAge; + private final Map myPassword; + + public MyImmutableClass(String myName) { + this.myName = myName; + this.myAge = LocalDate.now().getYear(); + Map map = new HashMap<>(); + map.put("epam", "12345"); + map.put("ok.com", "qwerty"); + this.myPassword = map; + } + + public MyImmutableClass(String myName, int myAge) { + this.myName = myName; + this.myAge = myAge; + Map map = new HashMap<>(); + map.put("epam", "12345"); + map.put("ok.com", "qwerty"); + this.myPassword = map; + } + + public MyImmutableClass(String myName, int myAge, Map myPassword) { + this.myName = myName; + this.myAge = myAge; + this.myPassword = new HashMap<>(myPassword); + } + + public String getMyName() { + return myName; + } + + public int getMyAge() { + return myAge; + } + + public Map getMyPassword() { + return new HashMap<>(myPassword); + } + + public MyImmutableClass getNewMyImmutableClass(MyImmutableClass myOldImmutableClass, String myNewName) { + return new MyImmutableClass(myNewName, myOldImmutableClass.getMyAge(), myOldImmutableClass.getMyPassword()); + } + + public MyImmutableClass getNewMyImmutableClass(MyImmutableClass myOldImmutableClass, int myNewAge) { + return new MyImmutableClass(myOldImmutableClass.getMyName(), myNewAge, myOldImmutableClass.getMyPassword()); + } + + public MyImmutableClass getNewMyImmutableClass(MyImmutableClass myOldImmutableClass, Map myNewPassword) { + return new MyImmutableClass(myOldImmutableClass.getMyName(), myOldImmutableClass.getMyAge(), myNewPassword); + } + + public MyImmutableClass getNewMyImmutableClass(String myNewName, int myNewAge, Map myNewPassword) { + return new MyImmutableClass(myNewName, myNewAge, myNewPassword); + } +} diff --git a/src/main/java/homework_4/custom_annotation/Cat.java b/src/main/java/homework_4/custom_annotation/Cat.java new file mode 100644 index 00000000..0de43fc5 --- /dev/null +++ b/src/main/java/homework_4/custom_annotation/Cat.java @@ -0,0 +1,57 @@ +package homework_4.custom_annotation; + +import homework_4.custom_annotation.annotations.XmlElement; +import homework_4.custom_annotation.annotations.XmlSerializable; + +@XmlSerializable +public class Cat { + + @XmlElement + private String name; + + @XmlElement + private String age; + + @XmlElement + private String breed; + + private String emailAddress; + + public Cat(String name, String age, String breed) { + this.name = name; + this.age = age; + this.breed = breed; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getAge() { + return age; + } + + public void setAge(String age) { + this.age = age; + } + + public String getBreed() { + return breed; + } + + public void setBreed(String breed) { + this.breed = breed; + } + + public String getEmailAddress() { + return emailAddress; + } + + public void setEmailAddress(String emailAddress) { + this.emailAddress = emailAddress; + } +} diff --git a/src/main/java/homework_4/custom_annotation/annotations/XmlConverter.java b/src/main/java/homework_4/custom_annotation/annotations/XmlConverter.java new file mode 100644 index 00000000..04b9f25c --- /dev/null +++ b/src/main/java/homework_4/custom_annotation/annotations/XmlConverter.java @@ -0,0 +1,63 @@ +package homework_4.custom_annotation.annotations; + +import homework_4.custom_annotation.custom_exception.XmlSerializationException; + +import java.lang.reflect.Field; +import java.util.HashMap; +import java.util.Locale; +import java.util.Map; +import java.util.Objects; +import java.util.stream.Collectors; + +public class XmlConverter { + + public String convertToXml(Object object) throws XmlSerializationException { + try { + validObjectToSerializable(object); + return getXmlString(object); + } catch (Exception e) { + throw new XmlSerializationException(e.getMessage()); + } + } + + private void validObjectToSerializable(Object object) { + if (Objects.isNull(object)) { + throw new XmlSerializationException("The object is null"); + } + + Class serializableClass = object.getClass(); + if (!serializableClass.isAnnotationPresent(XmlSerializable.class)) { + throw new XmlSerializationException("The object " + serializableClass.getSimpleName() + " should be annotated with " + XmlSerializable.class.getSimpleName()); + } + } + + private String getXmlString(Object object) throws Exception { + Class serializableClass = object.getClass(); + Map xmlElementsMap = new HashMap<>(); + for (Field field : serializableClass.getDeclaredFields()) { + field.setAccessible(true); + if (field.isAnnotationPresent(XmlElement.class)) { + xmlElementsMap.put(getKey(field), (String) field.get(object)); + } + } + + String xmlString = xmlElementsMap.entrySet() + .stream() + .map(entry -> "<" + entry.getKey().toLowerCase(Locale.ROOT) + ">" + + entry.getValue().toLowerCase(Locale.ROOT) + + "") + .collect(Collectors.joining("")); + return "<" + serializableClass.getSimpleName().toLowerCase(Locale.ROOT) + "s" + ">" + + "<" + serializableClass.getSimpleName().toLowerCase(Locale.ROOT) + ">" + + xmlString + + "" + + ""; + } + + private String getKey(Field field) { + String value = field.getAnnotation(XmlElement.class) + .key(); + return value.isEmpty() ? field.getName() : value; + } + +} diff --git a/src/main/java/homework_4/custom_annotation/annotations/XmlElement.java b/src/main/java/homework_4/custom_annotation/annotations/XmlElement.java new file mode 100644 index 00000000..08a72cae --- /dev/null +++ b/src/main/java/homework_4/custom_annotation/annotations/XmlElement.java @@ -0,0 +1,12 @@ +package homework_4.custom_annotation.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.FIELD) +public @interface XmlElement { + String key() default ""; +} \ No newline at end of file diff --git a/src/main/java/homework_4/custom_annotation/annotations/XmlSerializable.java b/src/main/java/homework_4/custom_annotation/annotations/XmlSerializable.java new file mode 100644 index 00000000..11b54767 --- /dev/null +++ b/src/main/java/homework_4/custom_annotation/annotations/XmlSerializable.java @@ -0,0 +1,11 @@ +package homework_4.custom_annotation.annotations; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.TYPE) +public @interface XmlSerializable { +} diff --git a/src/main/java/homework_4/custom_annotation/custom_exception/XmlSerializationException.java b/src/main/java/homework_4/custom_annotation/custom_exception/XmlSerializationException.java new file mode 100644 index 00000000..8c5ce331 --- /dev/null +++ b/src/main/java/homework_4/custom_annotation/custom_exception/XmlSerializationException.java @@ -0,0 +1,8 @@ +package homework_4.custom_annotation.custom_exception; + +public class XmlSerializationException extends RuntimeException { + + public XmlSerializationException(String message) { + super(message); + } +} 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..dc37d03b --- /dev/null +++ b/src/main/java/homework_4/custom_file_reader/CustomFileReader.java @@ -0,0 +1,66 @@ +package homework_4.custom_file_reader; + +import homework_4.custom_file_reader.utility_classes.*; +import homework_4.custom_file_reader.utility_classes.InputStreamReaderFileReader; + +import java.io.*; + +public class CustomFileReader { + + private String fileContent; + private File fileReader; + + public CustomFileReader() { + fileReader = new File("./src/main/resources/custom_file_reader/file.txt"); + } + + public CustomFileReader(String filePath) { + fileReader = new File(filePath); + } + + public CustomFileReader(File file) { + fileReader = file; + } + + public String getFileContent() { + return fileContent; + } + + private void run(AbstractFileReader reader) { + if (fileReader.exists()) { + fileContent = reader.getFileContent(fileReader); + printResult(); + } else { + System.out.println("File not found in path"); + } + } + + //used NIO + public void run1() { + this.run(new NIOFileReader()); + } + + //used FileInputStream (only end) + public void run2() { + this.run(new FileInputStreamFileReader()); + } + + //used InputStreamReaderFileReader + public void run3() { + this.run(new InputStreamReaderFileReader()); + } + + //used Scanner + public void run4() { + this.run(new ScannerFileReader()); + } + + //used BufferedReader + public void run5() { + this.run(new BufferedReaderFileReader()); + } + + private void printResult() { + System.out.println(fileContent.replaceAll("[.,]", "")); + } +} 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..b879dfb6 --- /dev/null +++ b/src/main/java/homework_4/custom_file_reader/Main.java @@ -0,0 +1,9 @@ +package homework_4.custom_file_reader; + +public class Main { + + public static void main(String[] args) { + new CustomFileReader().run1(); + } + +} diff --git a/src/main/java/homework_4/custom_file_reader/utility_classes/AbstractFileReader.java b/src/main/java/homework_4/custom_file_reader/utility_classes/AbstractFileReader.java new file mode 100644 index 00000000..ae61d018 --- /dev/null +++ b/src/main/java/homework_4/custom_file_reader/utility_classes/AbstractFileReader.java @@ -0,0 +1,31 @@ +package homework_4.custom_file_reader.utility_classes; + +import java.io.File; +import java.util.Iterator; +import java.util.List; + +public abstract class AbstractFileReader { + + protected String fileContent; + + public String getFileContent() { + return fileContent; + } + + public abstract String getFileContent(File file); + + protected void fillFileContent(List stringList) { + Iterator iterator = stringList.iterator(); + StringBuilder tempStringBuilder = new StringBuilder(); + while (iterator.hasNext()) { + String tempStr = iterator.next(); + if (iterator.hasNext()) { + tempStringBuilder.append(tempStr).append("\n"); + } else { + tempStringBuilder.append(tempStr); + } + } + fileContent = tempStringBuilder.toString(); + } + +} diff --git a/src/main/java/homework_4/custom_file_reader/utility_classes/BufferedReaderFileReader.java b/src/main/java/homework_4/custom_file_reader/utility_classes/BufferedReaderFileReader.java new file mode 100644 index 00000000..5d937bbe --- /dev/null +++ b/src/main/java/homework_4/custom_file_reader/utility_classes/BufferedReaderFileReader.java @@ -0,0 +1,22 @@ +package homework_4.custom_file_reader.utility_classes; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.util.List; +import java.util.stream.Collectors; + +public class BufferedReaderFileReader extends AbstractFileReader { + + @Override + public String getFileContent(File file) { + try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { + List stringList = bufferedReader.lines().collect(Collectors.toList()); + fillFileContent(stringList); + } catch (IOException e) { + e.printStackTrace(); + } + return fileContent; + } +} diff --git a/src/main/java/homework_4/custom_file_reader/utility_classes/FileInputStreamFileReader.java b/src/main/java/homework_4/custom_file_reader/utility_classes/FileInputStreamFileReader.java new file mode 100644 index 00000000..a51aa7d2 --- /dev/null +++ b/src/main/java/homework_4/custom_file_reader/utility_classes/FileInputStreamFileReader.java @@ -0,0 +1,20 @@ +package homework_4.custom_file_reader.utility_classes; + +import java.io.*; +public class FileInputStreamFileReader extends AbstractFileReader { + + @Override + public String getFileContent(File file) { + try (FileInputStream fileInputStream = new FileInputStream(file.getPath())) { + StringBuilder fileCSB = new StringBuilder(); + int i; + while ((i = fileInputStream.read()) != -1) { + fileCSB.append((char) i); + } + fileContent = fileCSB.toString(); + } catch (IOException e) { + e.printStackTrace(); + } + return fileContent; + } +} diff --git a/src/main/java/homework_4/custom_file_reader/utility_classes/InputStreamReaderFileReader.java b/src/main/java/homework_4/custom_file_reader/utility_classes/InputStreamReaderFileReader.java new file mode 100644 index 00000000..0d582d99 --- /dev/null +++ b/src/main/java/homework_4/custom_file_reader/utility_classes/InputStreamReaderFileReader.java @@ -0,0 +1,25 @@ +package homework_4.custom_file_reader.utility_classes; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; + +public class InputStreamReaderFileReader extends AbstractFileReader { + + @Override + public String getFileContent(File file) { + try (InputStreamReader inputStreamReader = new java.io.InputStreamReader(new FileInputStream(file.getPath()), StandardCharsets.UTF_8)) { + StringBuilder fileCSB = new StringBuilder(); + int i; + while ((i = inputStreamReader.read()) != -1) { + fileCSB.append((char) i); + } + fileContent = fileCSB.toString(); + } catch (IOException e) { + e.printStackTrace(); + } + return fileContent; + } +} diff --git a/src/main/java/homework_4/custom_file_reader/utility_classes/NIOFileReader.java b/src/main/java/homework_4/custom_file_reader/utility_classes/NIOFileReader.java new file mode 100644 index 00000000..067e4889 --- /dev/null +++ b/src/main/java/homework_4/custom_file_reader/utility_classes/NIOFileReader.java @@ -0,0 +1,23 @@ +package homework_4.custom_file_reader.utility_classes; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.List; + +public class NIOFileReader extends AbstractFileReader { + + @Override + public String getFileContent(File file) { + Path path = Paths.get(file.getPath()); + try { + List stringList = Files.readAllLines(path); + fillFileContent(stringList); + } catch (IOException e) { + e.printStackTrace(); + } + return fileContent; + } +} diff --git a/src/main/java/homework_4/custom_file_reader/utility_classes/ScannerFileReader.java b/src/main/java/homework_4/custom_file_reader/utility_classes/ScannerFileReader.java new file mode 100644 index 00000000..b58b21d7 --- /dev/null +++ b/src/main/java/homework_4/custom_file_reader/utility_classes/ScannerFileReader.java @@ -0,0 +1,27 @@ +package homework_4.custom_file_reader.utility_classes; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.List; +import java.util.Scanner; + +public class ScannerFileReader extends AbstractFileReader { + + @Override + public String getFileContent(File file) { + Path path = Paths.get(file.getPath()); + try (Scanner scanner = new Scanner(path)) { + List stringList = new ArrayList<>(); + while (scanner.hasNextLine()) { + stringList.add(scanner.nextLine()); + } + fillFileContent(stringList); + } catch (IOException e) { + e.printStackTrace(); + } + return fileContent; + } +} diff --git a/src/main/java/homework_4/singleton/MySingleton.java b/src/main/java/homework_4/singleton/MySingleton.java new file mode 100644 index 00000000..66f0151f --- /dev/null +++ b/src/main/java/homework_4/singleton/MySingleton.java @@ -0,0 +1,18 @@ +package homework_4.singleton; + +public class MySingleton { + private static MySingleton mySingleton; + + private String singletonName; + + private MySingleton(String singletonName) { + this.singletonName = singletonName; + } + + public static MySingleton getInstance(String singletonName) { + if (mySingleton == null) { + mySingleton = new MySingleton(singletonName); + } + return mySingleton; + } +} 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..ffe024f2 --- /dev/null +++ b/src/main/java/homework_5/custom_regex_matcher/CustomRegexMatcher.java @@ -0,0 +1,42 @@ +package homework_5.custom_regex_matcher; + +import base.BaseClazz; + +import java.util.Scanner; +import java.util.regex.Pattern; + +public class CustomRegexMatcher extends BaseClazz { + + @Override + public void run() { + System.out.println("Enter the phone number"); + System.out.println(isValid(initPhoneNumber())); + } + + private String initPhoneNumber() { + String phoneNumber = ""; + try (Scanner scanner = new Scanner(System.in)) { + if (scanner.hasNextLine()) { + phoneNumber = scanner.nextLine().trim(); + } + } + return phoneNumber; + } + + /* + * String has: + * Starts with +7 or 8; + * First group - it is mobile operator code. It should contain three or more digits and it can be wrapped in parentheses; + * Last three groups should contains 3, 2 and 2 digits respectively. These groups can be splitted with the help of dash or space + * */ + @Override + protected boolean isValid(String... arg) { + if (arg.length > 1) return false; + Pattern pattern = Pattern.compile("^(\\+7|8)" + + "\\s?((\\((?=\\w{3}\\))\\w{3}\\))|\\w{3})\\s?" + + "(\\d{3})[\\-\\s]?" + + "(\\d{2})[\\-\\s]?" + + "(\\d{2})"); + return pattern.matcher(arg[0]).matches(); + } +} diff --git a/src/main/java/homework_5/custom_regex_matcher/Main.java b/src/main/java/homework_5/custom_regex_matcher/Main.java new file mode 100644 index 00000000..e1e20462 --- /dev/null +++ b/src/main/java/homework_5/custom_regex_matcher/Main.java @@ -0,0 +1,8 @@ +package homework_5.custom_regex_matcher; + +public class Main { + + public static void main(String[] args) { + new CustomRegexMatcher().run(); + } +} diff --git a/src/main/java/homework_5/power_of_number/Main.java b/src/main/java/homework_5/power_of_number/Main.java new file mode 100644 index 00000000..89300565 --- /dev/null +++ b/src/main/java/homework_5/power_of_number/Main.java @@ -0,0 +1,8 @@ +package homework_5.power_of_number; + +public class Main { + + public static void main(String[] args) { + new PowerOfNumber().run(); + } +} 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..1aee2b37 --- /dev/null +++ b/src/main/java/homework_5/power_of_number/PowerOfNumber.java @@ -0,0 +1,56 @@ +package homework_5.power_of_number; + +import base.BaseClazz; + +import java.math.BigInteger; +import java.util.Scanner; +import java.util.stream.IntStream; + +public class PowerOfNumber extends BaseClazz { + + private static final String ERROR_MESSAGE = "Only 2 non-negative integers are allowed"; + + @Override + public void run() { + System.out.println("Enter the number and degree"); + System.out.println(printPowResult()); + } + + private String printPowResult() { + String inputStr = ""; + try (Scanner scanner = new Scanner(System.in)) { + if (scanner.hasNextLine()) { + inputStr = scanner.nextLine().trim(); + } + } + if (isValid(inputStr.split("\\s"))) { + BigInteger a = new BigInteger(inputStr.split("\\s")[0]); + BigInteger b = new BigInteger(inputStr.split("\\s")[1]); + return String.valueOf(pow(a, b)); + } else { + return ANSI_RED + ERROR_MESSAGE + ANSI_RESET; + } + } + + private BigInteger pow(BigInteger a, BigInteger b) { + if (b.compareTo(BigInteger.valueOf(0)) == 0) { + return BigInteger.valueOf(1); + } + BigInteger newB = b.subtract(BigInteger.valueOf(1)); + return a.multiply(pow(a, newB)); + } + + @Override + protected boolean isValid(String... inputStr) { + if (inputStr.length != 2) { + return false; + } + if (!(inputStr[0].chars().allMatch(Character::isDigit) && + inputStr[1].chars().allMatch(Character::isDigit))) { + return false; + } + return IntStream.of(Integer.parseInt(inputStr[0])).allMatch(elem -> elem + 1 > 0) && + IntStream.of(Integer.parseInt(inputStr[1])).allMatch(elem -> elem + 1 > 0); + } + +} diff --git a/src/main/java/homework_6/Main.java b/src/main/java/homework_6/Main.java new file mode 100644 index 00000000..725bd6af --- /dev/null +++ b/src/main/java/homework_6/Main.java @@ -0,0 +1,40 @@ +package homework_6; + +import homework_6.map_problems.MapProblemsCollisionGenerator; +import homework_6.map_problems.MapProblemsMutableGenerator; + +import java.awt.*; +import java.util.HashMap; +import java.util.Map; + + +//сделано в срок, писал в личку +public class Main { + + public static void main(String[] args) { + + new Main().runMapProblemsMutable(); + new Main().runMapProblemsCollision(); + + } + + private void runMapProblemsMutable() { + MapProblemsMutableGenerator val = new MapProblemsMutableGenerator("Cat", 1, new Color(183, 86, 192)); + Map map = new HashMap<>(); + map.put(val, 123); + val.setClazzAge(21); + System.out.println("map.containsKey(val) = " + map.containsKey(val)); + } + + private void runMapProblemsCollision() { + MapProblemsCollisionGenerator val1 = new MapProblemsCollisionGenerator("Cat", 1, new Color(183, 86, 192)); + MapProblemsCollisionGenerator val2 = new MapProblemsCollisionGenerator("Dog", 2, new Color(197, 193, 78)); + Map map = new HashMap<>(); + + map.put(val1, "Murzik"); + map.put(val2, "Sharik"); + //now we have only 1 bucket + } + + +} diff --git a/src/main/java/homework_6/map_problems/MapProblemsCollisionGenerator.java b/src/main/java/homework_6/map_problems/MapProblemsCollisionGenerator.java new file mode 100644 index 00000000..505f5601 --- /dev/null +++ b/src/main/java/homework_6/map_problems/MapProblemsCollisionGenerator.java @@ -0,0 +1,31 @@ +package homework_6.map_problems; + +import java.awt.*; + +public class MapProblemsCollisionGenerator extends MapProblemsGenerator { + + public MapProblemsCollisionGenerator(String clazzName, int clazzAge, Color clazzColor) { + super(clazzName, clazzAge, clazzColor); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + MapProblemsCollisionGenerator that = (MapProblemsCollisionGenerator) o; + return clazzAge == that.clazzAge && clazzName.equals(that.clazzName) && clazzColor.equals(that.clazzColor); + } + @Override + public int hashCode() { + return 1; + } + + @Override + public String toString() { + return "MapProblemsCollisionGenerator{" + + "clazzName='" + clazzName + '\'' + + ", clazzAge=" + clazzAge + + ", clazzColor=" + clazzColor + + '}'; + } +} diff --git a/src/main/java/homework_6/map_problems/MapProblemsGenerator.java b/src/main/java/homework_6/map_problems/MapProblemsGenerator.java new file mode 100644 index 00000000..988e1248 --- /dev/null +++ b/src/main/java/homework_6/map_problems/MapProblemsGenerator.java @@ -0,0 +1,41 @@ +package homework_6.map_problems; + +import java.awt.*; + +public abstract class MapProblemsGenerator { + + protected String clazzName; + protected int clazzAge; + protected Color clazzColor; + + public MapProblemsGenerator(String clazzName, int clazzAge, Color clazzColor) { + this.clazzName = clazzName; + this.clazzAge = clazzAge; + this.clazzColor = clazzColor; + } + + public String getClazzName() { + return clazzName; + } + + public void setClazzName(String clazzName) { + this.clazzName = clazzName; + } + + public int getClazzAge() { + return clazzAge; + } + + public void setClazzAge(int clazzAge) { + this.clazzAge = clazzAge; + } + + public Color getClazzColor() { + return clazzColor; + } + + public void setClazzColor(Color clazzColor) { + this.clazzColor = clazzColor; + } + +} diff --git a/src/main/java/homework_6/map_problems/MapProblemsMutableGenerator.java b/src/main/java/homework_6/map_problems/MapProblemsMutableGenerator.java new file mode 100644 index 00000000..01258344 --- /dev/null +++ b/src/main/java/homework_6/map_problems/MapProblemsMutableGenerator.java @@ -0,0 +1,33 @@ +package homework_6.map_problems; + +import java.awt.*; +import java.util.Random; + +public class MapProblemsMutableGenerator extends MapProblemsGenerator { + + public MapProblemsMutableGenerator(String clazzName, int clazzAge, Color clazzColor) { + super(clazzName, clazzAge, clazzColor); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + MapProblemsMutableGenerator that = (MapProblemsMutableGenerator) o; + return clazzAge == that.clazzAge && clazzName.equals(that.clazzName) && clazzColor.equals(that.clazzColor); + } + + @Override + public int hashCode() { + return Integer.hashCode(clazzAge) + clazzName.hashCode(); + } + + @Override + public String toString() { + return "MapProblemsMutableGenerator{" + + "clazzName='" + clazzName + '\'' + + ", clazzAge=" + clazzAge + + ", clazzColor=" + clazzColor + + '}'; + } +} diff --git a/src/main/java/homework_7/Main.java b/src/main/java/homework_7/Main.java new file mode 100644 index 00000000..66c6a0bf --- /dev/null +++ b/src/main/java/homework_7/Main.java @@ -0,0 +1,28 @@ +package homework_7; + +import homework_7.function.KittenToCatFunction; +import homework_7.model.Sex; +import homework_7.model.cat_model.Cat; +import homework_7.model.cat_model.MilitaryCat; +import homework_7.model.kitten_model.Kitten; + +import java.util.Random; + +import static homework_7.model.Sex.*; + +public class Main { + + public static void main(String[] args) { + + KittenToCatFunction kittenToCatFunction = Main::toCat; + Kitten kitten = new Kitten("Nikita", 0, MALE); + System.out.println(kittenToCatFunction.grow(kitten)); + } + + private static Cat toCat(Kitten kitten) { + String catName = (kitten.getSex().equals(MALE) ? "Mr. " : "Ms. ") + kitten.getFirstName(); + int catAge = new Random().nextInt(82) + 18; + return new Cat(catName, catAge, kitten.getSex(), "student"); + } + +} diff --git a/src/main/java/homework_7/function/KittenToCatFunction.java b/src/main/java/homework_7/function/KittenToCatFunction.java new file mode 100644 index 00000000..105be45e --- /dev/null +++ b/src/main/java/homework_7/function/KittenToCatFunction.java @@ -0,0 +1,11 @@ +package homework_7.function; + +import homework_7.model.cat_model.Cat; +import homework_7.model.kitten_model.Kitten; + +@FunctionalInterface +public interface KittenToCatFunction { + + C grow(K kitten); + +} diff --git a/src/main/java/homework_7/model/Sex.java b/src/main/java/homework_7/model/Sex.java new file mode 100644 index 00000000..2f42039e --- /dev/null +++ b/src/main/java/homework_7/model/Sex.java @@ -0,0 +1,17 @@ +package homework_7.model; + +public enum Sex { + + MALE ("male"), + FEMALE ("female"); + + private String sex; + + Sex(String sex) { + this.sex = sex; + } + + public String getSex() { + return sex; + } +} diff --git a/src/main/java/homework_7/model/cat_model/Cat.java b/src/main/java/homework_7/model/cat_model/Cat.java new file mode 100644 index 00000000..e658111b --- /dev/null +++ b/src/main/java/homework_7/model/cat_model/Cat.java @@ -0,0 +1,67 @@ +package homework_7.model.cat_model; + +import homework_7.model.Sex; + +public class Cat { + + protected String firstName; + protected int age; + protected Sex sex; + protected String worker; + + public Cat(String firstName, int age, Sex sex) { + this.firstName = firstName; + this.age = age; + this.sex = sex; + this.worker = "unemployed"; + } + + public Cat(String firstName, int age, Sex sex, String worker) { + this.firstName = firstName; + this.age = age; + this.sex = sex; + this.worker = worker; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public Sex getSex() { + return sex; + } + + public void setSex(Sex sex) { + this.sex = sex; + } + + public String getWorker() { + return worker; + } + + public void setWorker(String worker) { + this.worker = worker; + } + + @Override + public String toString() { + return "Cat{" + + "firstName='" + firstName + '\'' + + ", age=" + age + + ", sex=" + sex + + ", worker='" + worker + '\'' + + '}'; + } +} diff --git a/src/main/java/homework_7/model/cat_model/MilitaryCat.java b/src/main/java/homework_7/model/cat_model/MilitaryCat.java new file mode 100644 index 00000000..1abc2ee6 --- /dev/null +++ b/src/main/java/homework_7/model/cat_model/MilitaryCat.java @@ -0,0 +1,15 @@ +package homework_7.model.cat_model; + +import homework_7.model.Sex; + +public class MilitaryCat extends Cat { + + public MilitaryCat(String firstName, int age, Sex sex, String worker) { + super(firstName, age, sex, "Military"); + } + + public MilitaryCat(String name, int age, Sex sex) { + super(name, age, sex, "Military"); + } + +} diff --git a/src/main/java/homework_7/model/kitten_model/Kitten.java b/src/main/java/homework_7/model/kitten_model/Kitten.java new file mode 100644 index 00000000..a01d5d97 --- /dev/null +++ b/src/main/java/homework_7/model/kitten_model/Kitten.java @@ -0,0 +1,50 @@ +package homework_7.model.kitten_model; + +import homework_7.model.Sex; + +public class Kitten { + + protected String firstName; + protected int age; + protected Sex sex; + + public Kitten(String name, int age, Sex sex) { + if (age > 18) throw new IllegalArgumentException("too old for kitten"); + this.firstName = name; + this.age = age; + this.sex = sex; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public Sex getSex() { + return sex; + } + + public void setSex(Sex sex) { + this.sex = sex; + } + + @Override + public String toString() { + return "Kitten{" + + "firstName='" + firstName + '\'' + + ", age=" + age + + ", sex=" + sex + + '}'; + } +} diff --git a/src/main/resources/custom_file_reader/file.txt b/src/main/resources/custom_file_reader/file.txt new file mode 100644 index 00000000..78ce3d5f --- /dev/null +++ b/src/main/resources/custom_file_reader/file.txt @@ -0,0 +1 @@ +"Нет никого, кто любил бы боль саму по себе, кто искал бы её и кто хотел бы иметь её просто потому, что это боль.." \ No newline at end of file diff --git a/src/test/java/base/UnitBaseFileMode.java b/src/test/java/base/UnitBaseFileMode.java new file mode 100644 index 00000000..9264eb86 --- /dev/null +++ b/src/test/java/base/UnitBaseFileMode.java @@ -0,0 +1,27 @@ +package base; + +import java.io.BufferedWriter; +import java.io.FileWriter; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Paths; + +public class UnitBaseFileMode extends UnitBase { + + public void createAndFillTempFile(String fileName, String content) { + try (BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));) { + writer.write(content); + } catch (IOException e) { + e.printStackTrace(); + } + } + + public void deleteTempFile(String fileName) { + try { + Files.deleteIfExists(Paths.get(fileName)); + } catch (IOException e) { + e.printStackTrace(); + } + } + +} diff --git a/src/test/java/base/UnitBaseMode.java b/src/test/java/base/UnitBaseMode.java new file mode 100644 index 00000000..1b3145f2 --- /dev/null +++ b/src/test/java/base/UnitBaseMode.java @@ -0,0 +1,21 @@ +package base; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +public abstract class UnitBaseMode extends UnitBase { + + // can be used to invoke method for object your class under test + // 1st arg - obj your class under test, 2nd arg - called method, 3rd arg - message to remove from output + protected void run(Object object, String methodName, String stringToDel) { + try { + Method method = object.getClass().getMethod(methodName); + method.invoke(object); + } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) { + e.printStackTrace(); + } + + removeFromOutput(stringToDel); + } + +} diff --git a/src/test/java/homework_1/MainTest.java b/src/test/java/homework_1/MainTest.java new file mode 100644 index 00000000..df682467 --- /dev/null +++ b/src/test/java/homework_1/MainTest.java @@ -0,0 +1,59 @@ +package homework_1; + +import base.UnitBase; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; + +class MainTest extends UnitBase { + + @Test + void mainTestValidArg() { + String[] inputArg = {"a", "aa", "aaa", "aaaa", "aaaaa"}; + + String[] expectedArray = { + "a: 1 letters", + "aa: 2 letters", + "aaa: 3 letters", + "aaaa: 4 letters", + "aaaaa: 5 letters"}; + Main.main(inputArg); + + assertArrayEquals(expectedArray, getOutputLines()); + } + + @Test + void mainTestValidArg2() { + String[] inputArg = {"1"}; + + String[] expectedArray = {"1: 1 letters"}; + Main.main(inputArg); + + assertArrayEquals(expectedArray, getOutputLines()); + } + + @Test + void mainTestEmptyArg() { + String[] inputArg = {}; + + Main.main(inputArg); + printOut(); + + assertEquals("", getOutput()); + } + + @Test + void mainTestWithErr() { + String[] inputArg = {"a", "aa", "aaa", "error", "ааааа"}; + + String[] expectedArray = { + "a: 1 letters", + "aa: 2 letters", + "aaa: 3 letters", + "\033[0;31mAlarm!\033[0m"}; + Main.main(inputArg); + + assertArrayEquals(expectedArray, getOutputLines()); + } +} \ 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..56b8cf69 --- /dev/null +++ b/src/test/java/homework_2/pyramid_printer/PyramidPrinterTest.java @@ -0,0 +1,64 @@ +package homework_2.pyramid_printer; + +import base.UnitBaseMode; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.*; + +class PyramidPrinterTest extends UnitBaseMode { + + private final PyramidPrinter pyramidPrinter = new PyramidPrinter(); + private final String METHOD_NAME = "run"; + private final String STRING_TO_DEL = "Enter the number"; + + @Test + void runTest() { + setInput("0"); + + run(pyramidPrinter, METHOD_NAME, STRING_TO_DEL); + + assertEquals("", getOutput()); + } + + @Test + void runTest1() { + setInput("1"); + String[] expectedArray = {"x"}; + + run(pyramidPrinter, METHOD_NAME, STRING_TO_DEL); + + assertArrayEquals(expectedArray, getOutputLines()); + } + + @Test + void runTest2() { + setInput("2"); + String[] expectedArray = {"x", "xx"}; + + run(pyramidPrinter, METHOD_NAME, STRING_TO_DEL); + + assertArrayEquals(expectedArray, getOutputLines()); + } + + @Test + void runTest10() { + setInput("10"); + String[] expectedArray = {"x", "xx", "xxx", "xxxx", "xxxxx", "xxxxxx", "xxxxxxx", "xxxxxxxx", "xxxxxxxxx", "xxxxxxxxxx"}; + + run(pyramidPrinter, METHOD_NAME, STRING_TO_DEL); + + assertArrayEquals(expectedArray, getOutputLines()); + } + + @ParameterizedTest + @ValueSource(strings = {"-1", "asd", "123456789012345678901234567890"}) + void runTestInvalidArg(String input) { + setInput(input); + + run(pyramidPrinter, METHOD_NAME, STRING_TO_DEL); + + assertTrue(getOutput().contains("Only 1 non-negative integer is allowed as passed parameter")); + } +} \ No newline at end of file diff --git a/src/test/java/homework_2/random_chars_table/RandomCharsTableCreatorTest.java b/src/test/java/homework_2/random_chars_table/RandomCharsTableCreatorTest.java new file mode 100644 index 00000000..65093709 --- /dev/null +++ b/src/test/java/homework_2/random_chars_table/RandomCharsTableCreatorTest.java @@ -0,0 +1,47 @@ +package homework_2.random_chars_table; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.Arrays; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class RandomCharsTableCreatorTest { + + private List evenLettersArrayList; + private List oddLettersArrayList; + + @BeforeEach + void setUp() { + evenLettersArrayList = Arrays.asList(new Character[]{66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90}); + oddLettersArrayList = Arrays.asList(new Character[]{65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89}); + } + + @Test + void initTableTest1() { + char[][] charsTable = RandomCharsTableCreator.initAndFillTable(10, 20); + + assertEquals(10, charsTable.length); + for (char[] chars : charsTable) { + assertEquals(20, chars.length); + for (char ch : chars) { + assertTrue(evenLettersArrayList.contains(ch) || oddLettersArrayList.contains(ch)); + } + } + } + + @Test + void initTableTest2() { + char[][] charsTable = RandomCharsTableCreator.initAndFillTable(14, 124); + + assertEquals(14, charsTable.length); + for (char[] chars : charsTable) { + assertEquals(124, chars.length); + for (char ch : chars) { + assertTrue(evenLettersArrayList.contains(ch) || oddLettersArrayList.contains(ch)); + } + } + } +} \ 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..5b16f880 --- /dev/null +++ b/src/test/java/homework_2/random_chars_table/RandomCharsTableTest.java @@ -0,0 +1,163 @@ +package homework_2.random_chars_table; + +import base.UnitBaseMode; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.Arrays; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; + +class RandomCharsTableTest extends UnitBaseMode { + + private final RandomCharsTable randomCharsTable = new RandomCharsTable(); + private final String METHOD_NAME = "run"; + private final String STRING_TO_DEL = "Enter width, height and parity"; + private List evenLettersArrayList; + private List oddLettersArrayList; + + @BeforeEach + void setUp() { + evenLettersArrayList = Arrays.asList(new Character[]{66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90}); + oddLettersArrayList = Arrays.asList(new Character[]{65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89}); + } + + @Test + void runTestValidArg() { + setInput("2 1 even"); + + run(randomCharsTable, METHOD_NAME, STRING_TO_DEL); + printOut(); + + assertTrue(isValidLetters(Arrays.copyOf(getOutputLines(), getOutputLines().length - 1), 1)); + assertTrue(isEvenLetters(getOutputLines()[getOutputLines().length - 1])); + assertEquals(2 + 1, getOutputLines().length); + assertTrue(getOutput().contains("even letters -")); + } + + @Test + void runTestValidArg2() { + setInput("1 2 even"); + + run(randomCharsTable, METHOD_NAME, STRING_TO_DEL); + printOut(); + + assertTrue(isValidLetters(Arrays.copyOf(getOutputLines(), getOutputLines().length - 1), 2)); + assertTrue(isEvenLetters(getOutputLines()[getOutputLines().length - 1])); + assertEquals(2, getOutputLines().length); + assertTrue(getOutput().contains("even letters -")); + } + + @Test + void runTestValidArg3() { + setInput("2 3 even"); + + run(randomCharsTable, METHOD_NAME, STRING_TO_DEL); + printOut(); + + assertTrue(isValidLetters(Arrays.copyOf(getOutputLines(), getOutputLines().length - 1), 3)); + assertTrue(isEvenLetters(getOutputLines()[getOutputLines().length - 1])); + assertEquals(3, getOutputLines().length); + assertTrue(getOutput().contains("even letters - ")); + } + + @Test + void runTestValidArg4() { + setInput("2 1 odd"); + + run(randomCharsTable, METHOD_NAME, STRING_TO_DEL); + printOut(); + + assertTrue(isValidLetters(Arrays.copyOf(getOutputLines(), getOutputLines().length - 1), 1)); + assertTrue(isOddLetters(getOutputLines()[getOutputLines().length - 1])); + assertEquals(3, getOutputLines().length); + assertTrue(getOutput().contains("odd letters -")); + } + + @Test + void runTestValidArg5() { + setInput("1 2 odd"); + + run(randomCharsTable, METHOD_NAME, STRING_TO_DEL); + printOut(); + + assertTrue(isValidLetters(Arrays.copyOf(getOutputLines(), getOutputLines().length - 1), 2)); + assertTrue(isOddLetters(getOutputLines()[getOutputLines().length - 1])); + assertEquals(2, getOutputLines().length); + assertTrue(getOutput().contains("odd letters -")); + } + + @Test + void runTestValidArg6() { + setInput("2 3 odd"); + + run(randomCharsTable, METHOD_NAME, STRING_TO_DEL); + printOut(); + + assertTrue(isValidLetters(Arrays.copyOf(getOutputLines(), getOutputLines().length - 1), 3)); + assertTrue(isOddLetters(getOutputLines()[getOutputLines().length - 1])); + assertEquals(3, getOutputLines().length); + assertTrue(getOutput().contains("odd letters -")); + } + + @Test + void runTestValidArg7() { + setInput("10 20 odd"); + + run(randomCharsTable, METHOD_NAME, STRING_TO_DEL); + printOut(); + + assertTrue(isValidLetters(Arrays.copyOf(getOutputLines(), getOutputLines().length - 1), 20)); + assertTrue(isOddLetters(getOutputLines()[getOutputLines().length - 1])); + assertEquals(11, getOutputLines().length); + assertTrue(getOutput().contains("odd letters -")); + } + + @ParameterizedTest + @ValueSource(strings = {"0 1 odd", "1 0 odd", "0 1 even", "1 0 even", "1 1 od", "0 odd", "odd", "-1 3 odd", "3 -1 even"}) + void runTestInvalidArg(String input) { + setInput(input); + + run(randomCharsTable, METHOD_NAME, STRING_TO_DEL); + + assertTrue(getOutput().contains("Passed parameters should match the format [positive integer] [positive integer] [even|odd]")); + } + + private boolean isValidLetters(String[] outputLines, int width) { + for (String s : outputLines) { + s = s.replaceAll("\\|+", ""); + if (s.length() != width) { + return false; + } + for (int i = 0; i < s.length(); i++) { + if (!evenLettersArrayList.contains(s.charAt(i)) && !oddLettersArrayList.contains(s.charAt(i))) { + return false; + } + } + } + return true; + } + + private boolean isEvenLetters(String lastString) { + lastString = lastString.replaceAll("(even letters -)|(\\s+)|(,+)", ""); + for (int i = 0; i < lastString.length(); i++) { + if (oddLettersArrayList.contains(lastString.charAt(i))) { + return false; + } + } + return true; + } + + private boolean isOddLetters(String lastString) { + lastString = lastString.replaceAll("(odd letters -)|(\\s+)|(,+)", ""); + for (int i = 0; i < lastString.length(); i++) { + if (evenLettersArrayList.contains(lastString.charAt(i))) { + return false; + } + } + return true; + } +} \ No newline at end of file diff --git a/src/test/java/homework_2/traffic_light/TrafficLightExtraModeTest.java b/src/test/java/homework_2/traffic_light/TrafficLightExtraModeTest.java new file mode 100644 index 00000000..f675b2ff --- /dev/null +++ b/src/test/java/homework_2/traffic_light/TrafficLightExtraModeTest.java @@ -0,0 +1,78 @@ +package homework_2.traffic_light; + +import base.UnitBaseMode; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.*; + +class TrafficLightExtraModeTest extends UnitBaseMode { + + private final TrafficLightExtraMode trafficLightExtraMode = new TrafficLightExtraMode(); + private final String METHOD_NAME = "run"; + private final String STRING_TO_DEL = "Enter the number"; + + @ParameterizedTest + @ValueSource(strings = { + "23:01:00", "15:00:08", "07:00:16", "00:00:24", + "21:02:02", "13:01:10", "05:01:18", "01:50:26", + "19:03:04", "11:02:12", "03:10:20", "10:59:28", + "17:04:06", "09:03:14", "23:00:22", "23:12:32" + }) + void runTestGreenLight(String input) { + setInput(input); + + run(trafficLightExtraMode, METHOD_NAME, STRING_TO_DEL); + + printOut(); + + assertTrue(getOutput().contains("Green light")); + } + + @ParameterizedTest + @ValueSource(strings = { + "23:59:35", "15:59:39", "07:59:58", "00:59:37", + "21:12:36", "13:59:55", "05:59:59", "01:59:38", + "19:34:37", "11:59:56", "03:59:35", "10:59:39", + "17:25:38", "09:59:57", "23:59:36", "12:59:35" + }) + void runTestYellowLight(String input) { + setInput(input); + + run(trafficLightExtraMode, METHOD_NAME, STRING_TO_DEL); + + printOut(); + + assertTrue(getOutput().contains("Yellow light")); + } + + @ParameterizedTest + @ValueSource(strings = { + "23:59:40", "15:59:44", "07:59:48", "00:59:52", + "21:12:41", "13:59:45", "05:59:49", "01:59:53", + "19:34:42", "11:59:46", "03:59:50", "10:59:54", + "17:25:43", "09:59:47", "23:59:51", "12:59:40" + }) + void runTestRedLight(String input) { + setInput(input); + + run(trafficLightExtraMode, METHOD_NAME, STRING_TO_DEL); + + printOut(); + + assertTrue(getOutput().contains("Red light")); + } + + @ParameterizedTest + @ValueSource(strings = { + "24:00:00", "00:60:01", "00:01:60", "01:0:00", "3:59:59", + "3:59:9", "359:59", "35959", "asd", ":59:59" + }) + void runTestInvalidArg(String input) { + setInput(input); + + run(trafficLightExtraMode, METHOD_NAME, STRING_TO_DEL); + + assertTrue(getOutput().contains("Only hh:mm:ss input format (hh < 24, mm < 60, ss < 60)")); + } +} \ 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..eb5791af --- /dev/null +++ b/src/test/java/homework_2/traffic_light/TrafficLightTest.java @@ -0,0 +1,62 @@ +package homework_2.traffic_light; + +import base.UnitBaseMode; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.*; + +class TrafficLightTest extends UnitBaseMode { + + private final TrafficLight trafficLight = new TrafficLight(); + private final String METHOD_NAME = "run"; + private final String STRING_TO_DEL = "Enter the number"; + + @ParameterizedTest + @ValueSource(strings = {"0", "5", "61"}) + void runTestValidArg1(String input) { + setInput(input); + + run(trafficLight, METHOD_NAME, STRING_TO_DEL); + + assertTrue(getOutput().contains("Green light")); + } + + @Test + void runTestValidArg2() { + setInput("35"); + + run(trafficLight, METHOD_NAME, STRING_TO_DEL); + + assertTrue(getOutput().contains("Yellow light")); + } + + @Test + void runTestValidArg3() { + setInput("54"); + + run(trafficLight, METHOD_NAME, STRING_TO_DEL); + + assertTrue(getOutput().contains("Red light")); + } + + @Test + void runTestValidArg4() { + setInput("86401"); + + run(trafficLight, METHOD_NAME, STRING_TO_DEL); + + assertTrue(getOutput().contains("Day is over")); + } + + @ParameterizedTest + @ValueSource(strings = {"-12", "12345678901234567890123456", "asd"}) + void runTestInvalidArg(String inputString) { + setInput(inputString); + + run(trafficLight, METHOD_NAME, STRING_TO_DEL); + + assertTrue(getOutput().contains("Only 1 non-negative integer is allowed as passed parameter")); + } +} \ No newline at end of file diff --git a/src/test/java/homework_4/custom_annotation/annotations/XmlConverterTest.java b/src/test/java/homework_4/custom_annotation/annotations/XmlConverterTest.java new file mode 100644 index 00000000..4852d1bf --- /dev/null +++ b/src/test/java/homework_4/custom_annotation/annotations/XmlConverterTest.java @@ -0,0 +1,29 @@ +package homework_4.custom_annotation.annotations; + +import homework_4.custom_annotation.Cat; +import homework_4.custom_annotation.custom_exception.XmlSerializationException; +import org.junit.jupiter.api.Test; + +import java.util.Locale; + +import static org.junit.jupiter.api.Assertions.*; + +class XmlConverterTest { + + @Test + void givenObject_whenConvertToXml_thenThrows() throws XmlSerializationException { + Object o = new Object(); + XmlConverter xmlConverter = new XmlConverter(); + assertThrows(XmlSerializationException.class, () -> { + xmlConverter.convertToXml(o); + }); + } + + @Test + void givenCat_whenConvertToXml_thenValidCatForXml() { + Cat cat = new Cat("Epam", "1", "Intern"); + XmlConverter xmlConverter = new XmlConverter(); + assertEquals("epam1intern".toLowerCase(Locale.ROOT), xmlConverter.convertToXml(cat)); + } + +} \ 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..f91ae849 --- /dev/null +++ b/src/test/java/homework_4/custom_file_reader/CustomFileReaderTest.java @@ -0,0 +1,187 @@ +package homework_4.custom_file_reader; + +import base.UnitBaseFileMode; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.*; + +class CustomFileReaderTest extends UnitBaseFileMode { + + @AfterEach + void delTempFile() { + deleteTempFile("./src/main/resources/custom_file_reader/tempFile.txt"); + } + + @ParameterizedTest + @MethodSource("testValidValue") + void givenContent_whenRun1_thenExpected(String filePath, String content, String expected) { + createAndFillTempFile(filePath, content); + new CustomFileReader(filePath).run1(); + + assertEquals(expected, getOutput()); + } + + @ParameterizedTest + @MethodSource("testEmpty") + void givenContent_whenRun1_thenEmpty(String filePath, String content) { + createAndFillTempFile(filePath, content); + new CustomFileReader(filePath).run1(); + + assertEquals("", getOutput()); + } + + @ParameterizedTest + @MethodSource("testFileNotFound") + void givenWrongFileName_whenRun1_thenFileNotFound(String filePath, String content) { + createAndFillTempFile("./src/main/resources/custom_file_reader/tempFile.txt", content); + new CustomFileReader(filePath).run1(); + + assertEquals("File not found in path", getOutput()); + } + + @ParameterizedTest + @MethodSource("testValidValue") + void givenContent_whenRun2_thenExpected(String filePath, String content, String expected) { + createAndFillTempFile(filePath, content); + new CustomFileReader(filePath).run2(); + + assertEquals(expected, getOutput()); + } + + @ParameterizedTest + @MethodSource("testEmpty") + void givenContent_whenRun2_thenEmpty(String filePath, String content) { + createAndFillTempFile(filePath, content); + new CustomFileReader(filePath).run2(); + + assertEquals("", getOutput()); + } + + @ParameterizedTest + @MethodSource("testFileNotFound") + void givenWrongFileName_whenRun2_thenFileNotFound(String filePath, String content) { + createAndFillTempFile("./src/main/resources/custom_file_reader/tempFile.txt", content); + new CustomFileReader(filePath).run2(); + + assertEquals("File not found in path", getOutput()); + } + + + @ParameterizedTest + @MethodSource("testValidValue") + void givenContent_whenRun3_thenExpected(String filePath, String content, String expected) { + createAndFillTempFile(filePath, content); + new CustomFileReader(filePath).run3(); + + assertEquals(expected, getOutput()); + } + + @ParameterizedTest + @MethodSource("testEmpty") + void givenContent_whenRun3_thenEmpty(String filePath, String content) { + createAndFillTempFile(filePath, content); + new CustomFileReader(filePath).run3(); + + assertEquals("", getOutput()); + } + + @ParameterizedTest + @MethodSource("testFileNotFound") + void givenWrongFileName_whenRun3_thenFileNotFound(String filePath, String content) { + createAndFillTempFile("./src/main/resources/custom_file_reader/tempFile.txt", content); + new CustomFileReader(filePath).run3(); + + assertEquals("File not found in path", getOutput()); + } + + + @ParameterizedTest + @MethodSource("testValidValue") + void givenContent_whenRun4_thenExpected(String filePath, String content, String expected) { + createAndFillTempFile(filePath, content); + new CustomFileReader(filePath).run4(); + + assertEquals(expected, getOutput()); + } + + @ParameterizedTest + @MethodSource("testEmpty") + void givenContent_whenRun4_thenEmpty(String filePath, String content) { + createAndFillTempFile(filePath, content); + new CustomFileReader(filePath).run4(); + + assertEquals("", getOutput()); + } + + @ParameterizedTest + @MethodSource("testFileNotFound") + void givenWrongFileName_whenRun4_thenFileNotFound(String filePath, String content) { + createAndFillTempFile("./src/main/resources/custom_file_reader/tempFile.txt", content); + new CustomFileReader(filePath).run4(); + + assertEquals("File not found in path", getOutput()); + } + + @ParameterizedTest + @MethodSource("testValidValue") + void givenContent_whenRun5_thenExpected(String filePath, String content, String expected) { + createAndFillTempFile(filePath, content); + new CustomFileReader(filePath).run5(); + + assertEquals(expected, getOutput()); + } + + @ParameterizedTest + @MethodSource("testEmpty") + void givenContent_whenRun5_thenEmpty(String filePath, String content) { + createAndFillTempFile(filePath, content); + new CustomFileReader(filePath).run5(); + + assertEquals("", getOutput()); + } + + @ParameterizedTest + @MethodSource("testFileNotFound") + void givenWrongFileName_whenRun5_thenFileNotFound(String filePath, String content) { + createAndFillTempFile("./src/main/resources/custom_file_reader/tempFile.txt", content); + new CustomFileReader(filePath).run5(); + + assertEquals("File not found in path", getOutput()); + } + + private static Stream testFileNotFound() { + return Stream.of( + Arguments.of("/src/main/resources/custom_file_reader/file.txt", "1,2,3,4,5,6,7,\n8,9."), + Arguments.of("./sr/main/resources/custom_file_reader/file.txt", "..1,,"), + Arguments.of("./src/mai/resources/custom_file_reader/file.txt", "zxc01"), + Arguments.of("./src/main/resource/custom_file_reader/file.txt", "1! abcdefg"), + Arguments.of("./src/main/resources/custom_filereader/file.txt", "1!. qwerty, abcdefg."), + Arguments.of("./src/main/resources/custom_file_reader/testFiletxt", "1!. qwerty,\n abcdefg.") + ); + } + + private static Stream testEmpty() { + return Stream.of( + Arguments.of("./src/main/resources/custom_file_reader/tempFile.txt", ""), + Arguments.of("./src/main/resources/custom_file_reader/tempFile.txt", ".."), + Arguments.of("./src/main/resources/custom_file_reader/tempFile.txt", ",,"), + Arguments.of("./src/main/resources/custom_file_reader/tempFile.txt", "..,,"), + Arguments.of("./src/main/resources/custom_file_reader/tempFile.txt", "..,,") + ); + } + + private static Stream testValidValue() { + return Stream.of( + Arguments.of("./src/main/resources/custom_file_reader/tempFile.txt", "1,2,3,4,5,6,7,\n8,9.", "1234567\n89"), + Arguments.of("./src/main/resources/custom_file_reader/tempFile.txt", "zxc01", "zxc01"), + Arguments.of("./src/main/resources/custom_file_reader/tempFile.txt", "1! abcdefg", "1! abcdefg"), + Arguments.of("./src/main/resources/custom_file_reader/tempFile.txt", "1!. qwerty, abcdefg.", "1! qwerty abcdefg") + ); + } + +} \ No newline at end of file diff --git a/src/test/java/homework_4/singleton/MySingletonTest.java b/src/test/java/homework_4/singleton/MySingletonTest.java new file mode 100644 index 00000000..340bb2a5 --- /dev/null +++ b/src/test/java/homework_4/singleton/MySingletonTest.java @@ -0,0 +1,18 @@ +package homework_4.singleton; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.*; + +class MySingletonTest { + + @ParameterizedTest + @ValueSource(strings = {"1st", "2nd", "3rd"}) + void test(String input) { + MySingleton mySingleton = MySingleton.getInstance("Singleton"); + + assertEquals(mySingleton.hashCode(), MySingleton.getInstance(input).hashCode()); + } + +} \ 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..4d6ed618 --- /dev/null +++ b/src/test/java/homework_5/custom_regex_matcher/CustomRegexMatcherTest.java @@ -0,0 +1,71 @@ +package homework_5.custom_regex_matcher; + +import base.UnitBase; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.*; + +class CustomRegexMatcherTest extends UnitBase { + + @ParameterizedTest + @MethodSource + void runTestValidInput(String input) { + setInput(input); + + new CustomRegexMatcher().run(); + printOut(); + removeFromOutput("Enter the phone number"); + + assertEquals(getOutput(), "true"); + } + + @ParameterizedTest + @MethodSource + void runTestInvalidInput(String input) { + setInput(input); + + new CustomRegexMatcher().run(); + printOut(); + removeFromOutput("Enter the phone number"); + + assertEquals(getOutput(), "false"); + } + + private static Stream runTestValidInput() { + return Stream.of( + Arguments.of("8(499)1111111"), + Arguments.of("+7(499)111-11-11"), + Arguments.of("+7(499)1111111"), + Arguments.of("8(499)111 11 11"), + Arguments.of("+7(499)111 11 11"), + Arguments.of("8 499 111-11-11"), + Arguments.of("84991111111"), + Arguments.of("+7 111 111 11 11") + ); + } + + private static Stream runTestInvalidInput() { + return Stream.of( + Arguments.of("8(905 336 52 45"), + Arguments.of("8 905) 336 52 45"), + Arguments.of("8(905)336 52 5"), + Arguments.of("8(905)336 2 45"), + Arguments.of(" "), + Arguments.of(""), + Arguments.of("8(905)33 52 45"), + Arguments.of("8(90)336 52 45"), + Arguments.of("+8(905)336 52 45"), + Arguments.of("+(905)336 52 45"), + Arguments.of("8(4991111111"), + Arguments.of("8499)1111111"), + Arguments.of("8(499)1 111111"), + Arguments.of("49)1 111111"), + Arguments.of("(905)336 52 45") + ); + } + +} \ 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..1249d04b --- /dev/null +++ b/src/test/java/homework_5/power_of_number/PowerOfNumberTest.java @@ -0,0 +1,74 @@ +package homework_5.power_of_number; + +import base.UnitBase; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class PowerOfNumberTest extends UnitBase { + + @ParameterizedTest + @MethodSource + void runTestValidInput(String input, String result) { + setInput(input); + + new PowerOfNumber().run(); + printOut(); + removeFromOutput("Enter the number and degree"); + + assertEquals(getOutput(), result); + } + + @ParameterizedTest + @MethodSource + void runTestInvalidInput(String input) { + setInput(input); + + new PowerOfNumber().run(); + printOut(); + removeFromOutput("Enter the number and degree"); + + assertTrue(getOutput().contains("Only 2 non-negative integers are allowed")); + } + + private static Stream runTestInvalidInput() { + return Stream.of( + Arguments.of("-2 0"), + Arguments.of("2 -1"), + Arguments.of("-2 -2"), + Arguments.of("a 3"), + Arguments.of("2 a"), + Arguments.of("a a"), + Arguments.of("2"), + Arguments.of(""), + Arguments.of("2 8 9") + ); + } + + private static Stream runTestValidInput() { + return Stream.of( + Arguments.of("2 0", "1"), + Arguments.of("2 1", "2"), + Arguments.of("2 2", "4"), + Arguments.of("2 3", "8"), + Arguments.of("2 4", "16"), + Arguments.of("2 5", "32"), + Arguments.of("2 6", "64"), + Arguments.of("2 7", "128"), + Arguments.of("2 8", "256"), + Arguments.of("2 9", "512"), + Arguments.of("2 10", "1024"), + Arguments.of("10 2", "100"), + Arguments.of("10 3", "1000"), + Arguments.of("10 4", "10000"), + Arguments.of("10 10", "10000000000"), + Arguments.of("11 10", "25937424601") + ); + } + +} \ No newline at end of file