diff --git a/README.md b/README.md index 5d686e9f..88de9ef4 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,22 @@ # Java Core June 2021 -## *Nikolaev Artem* +## *Anton Segodnik* | 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/AntonSegodnik/src/main/java/homework_1) | The app that reads input arguments and prints them, until "error" argument | +|HW2 | [pyramid_printer](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/AntonSegodnik/src/main/java/homework_2/pyramid_printer) | The app that reads input arguments and prints pyramid | +|HW2 | [random_chars_table](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/AntonSegodnik/src/main/java/homework_2/random_chars_table) | The app that reads input arguments and creates random table | +|HW2 | [traffic_light](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/AntonSegodnik/src/main/java/homework_2/traffic_light) | The app that reads input arguments and prints traffic light | +|HW3 | [immutable class](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/AntonSegodnik/src/main/java/homework_3) | The app that reads input arguments and prints traffic light | +|HW4 | [customAnnotation](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/AntonSegodnik/src/main/java/homework_4/customAnnotation) | The app create object with default value from constructor using annotation | +|HW4 | [customFileReader](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/AntonSegodnik/src/main/java/homework_4/customFileReader) | The app that reads from file | +|HW4 | [singleton](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/AntonSegodnik/src/main/java/homework_4/singleton) | The singleton app | +|HW5 | [customRegexMatcher](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/AntonSegodnik/src/main/java/homework_5/customRegexMatcher) | The app | +|HW5 | [PowerOfNumber](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/AntonSegodnik/src/main/java/homework_5/PowerOfNumber) | The app | +|HW6 | [MapProblemsCollisionGenerator](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/AntonSegodnik/src/main/java/homework_6/MapProblemsCollisionGenerator) | The app | +|HW6 | [MapProblemsMutableGenerator](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/AntonSegodnik/src/main/java/homework_6/MapProblemsMutableGenerator) | The app | +|HW7 | [KittenToCatFunction](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/AntonSegodnik/src/main/java/homework_7) | The app | -[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 CodingBat](https://codingbat.com/done?user=segodnik@gmail.com&tag=8130222420) diff --git a/build.gradle b/build.gradle index b91dc843..762cbf03 100644 --- a/build.gradle +++ b/build.gradle @@ -10,10 +10,13 @@ repositories { } dependencies { + implementation 'org.jetbrains:annotations:20.1.0' 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 { useJUnitPlatform() } \ No newline at end of file diff --git a/gradlew b/gradlew old mode 100644 new mode 100755 diff --git a/src/main/java/SeaBattle/GenerateShips.java b/src/main/java/SeaBattle/GenerateShips.java new file mode 100644 index 00000000..33684b73 --- /dev/null +++ b/src/main/java/SeaBattle/GenerateShips.java @@ -0,0 +1,92 @@ +package SeaBattle; + +import java.util.Random; + +public class GenerateShips { + + static int FIELD_SIZE = 10; + + public char[][] createBoardWithShips() { + GenerateShips generateShips = new GenerateShips(); + int[][] field = new int[FIELD_SIZE][FIELD_SIZE]; + generateShips.fillField(field, 4); + generateShips.fillField(field, 3); + generateShips.fillField(field, 3); + generateShips.fillField(field, 2); + generateShips.fillField(field, 2); + generateShips.fillField(field, 2); + generateShips.fillField(field, 1); + generateShips.fillField(field, 1); + generateShips.fillField(field, 1); + generateShips.fillField(field, 1); + + char map[][] = new char[FIELD_SIZE][FIELD_SIZE]; + for(int i = 0; i < FIELD_SIZE; i++) { + for(int j = 0; j < FIELD_SIZE; j++) { + map[i][j] = field[i][j] == 0 || field[i][j] == 9 ? '_' : '0'; + } + } + return map; + } + + void fillField(int [][] fields, int shipLength) { + + Random random = new Random(); + int[][] field = fields; + while(true) { + int x = random.nextInt(field.length); + int y = random.nextInt(field.length); + boolean vertical = random.nextBoolean(); + + if(vertical) { + if(y + shipLength > FIELD_SIZE) { + y -= shipLength; + } + } else if(x + shipLength > FIELD_SIZE) { + x -= shipLength; + } + boolean isFree = true; + if(vertical) { + for(int m = y; m < y + shipLength; m++) { + if(field[m][x] != 0) { + isFree = false; + break; + } + } + } else { + for(int n = x; n < x + shipLength; n++) { + if(field[y][n] != 0) { + isFree = false; + break; + } + } + } + if(!isFree) { + continue; + } + + if(vertical) { + for(int m = Math.max(0, x - 1); m < Math.min(FIELD_SIZE, x + 2); m++) { + for(int n = Math.max(0, y - 1); n < Math.min(FIELD_SIZE, y + shipLength + 1); n++) { + field[n][m] = 9; + } + } + } else { + for(int m = Math.max(0, y - 1); m < Math.min(FIELD_SIZE, y + 2); m++) { + for(int n = Math.max(0, x - 1); n < Math.min(FIELD_SIZE, x + shipLength + 1); n++) { + field[m][n] = 9; + } + } + } + for(int j = 0; j < shipLength; j++) { + field[y][x] = shipLength; + if(vertical) { + y++; + } else { + x++; + } + } + break; + } + } +} diff --git a/src/main/java/SeaBattle/InputValidator.java b/src/main/java/SeaBattle/InputValidator.java new file mode 100644 index 00000000..cf00f60b --- /dev/null +++ b/src/main/java/SeaBattle/InputValidator.java @@ -0,0 +1,23 @@ +package SeaBattle; + +public interface InputValidator { + + static boolean isInvalidInputData(int col, int row, char[][] board) { + if(row < 0 || row > 9) { + System.out.println("Invalid input, allowed values like 'a5'"); + return true; + } else if(col == -1) { + System.out.println("Invalid input, please repeat input "); + return true; + } else if(board[row][col] == 'x' || board[row][col] == 'X') { + System.out.println("Already bombed, please repeat input "); + return true; + } else if(board[row][col] == '0') { + System.out.println("HIT!"); + board[row][col] = 'X'; + } else { + board[row][col] = 'x'; + } + return false; + } +} diff --git a/src/main/java/SeaBattle/Main.java b/src/main/java/SeaBattle/Main.java new file mode 100644 index 00000000..bfedd0e7 --- /dev/null +++ b/src/main/java/SeaBattle/Main.java @@ -0,0 +1,10 @@ +package SeaBattle; + +public class Main { + + public static void main(String[] args) { + + StartGame startGame = new StartGame(); + startGame.startGame(); + } +} diff --git a/src/main/java/SeaBattle/PrintArray.java b/src/main/java/SeaBattle/PrintArray.java new file mode 100644 index 00000000..a91dab79 --- /dev/null +++ b/src/main/java/SeaBattle/PrintArray.java @@ -0,0 +1,16 @@ +package SeaBattle; + +import java.util.Arrays; +import java.util.concurrent.atomic.AtomicInteger; + +import static SeaBattle.StartGame.currentCountOfShots; + +interface PrintArray { + + static void printBoard(char[][] map) { + AtomicInteger i = new AtomicInteger(1); + System.out.println("Current board: x - miss, X - HIT!, Current Round = " + currentCountOfShots + "\n A B C D E F G H I J "); + Arrays.stream(map) + .forEach(m -> System.out.println( i.getAndIncrement() + " " + Arrays.toString(m).replace(",", "").replace("0", "_"))); + } +} diff --git a/src/main/java/SeaBattle/StartGame.java b/src/main/java/SeaBattle/StartGame.java new file mode 100644 index 00000000..2e23a990 --- /dev/null +++ b/src/main/java/SeaBattle/StartGame.java @@ -0,0 +1,44 @@ +package SeaBattle; + +import java.util.Scanner; + +import static SeaBattle.InputValidator.isInvalidInputData; +import static SeaBattle.WinnerChecker.isWinnerExist; + +public class StartGame { + + private static final String LETTERS = "ABCDEFGHIJ"; + static final int COUNT = 70; + static int currentCountOfShots = 0; + + public void startGame() { + System.out.println("Game on! \n You should shoot all ships in " + COUNT + " rounds"); + GenerateShips test = new GenerateShips(); + char[][] board = test.createBoardWithShips(); + + while(true) { + PrintArray.printBoard(board); + + Scanner in = new Scanner(System.in); + try { + String playerChoice = in.next(); + + int col = LETTERS.indexOf(playerChoice.toUpperCase().charAt(0)); + int row = Integer.parseInt(playerChoice.substring(1)) - 1; + + if(isInvalidInputData(col, row, board)) { + continue; + } + currentCountOfShots++; + + if(isWinnerExist(board, currentCountOfShots)) { + return; + } + + } catch(NumberFormatException e) { + System.out.println("Invalid input, please enter in format e.g. 'A5'"); + in.next(); + } + } + } +} diff --git a/src/main/java/SeaBattle/WinnerChecker.java b/src/main/java/SeaBattle/WinnerChecker.java new file mode 100644 index 00000000..6ef67c25 --- /dev/null +++ b/src/main/java/SeaBattle/WinnerChecker.java @@ -0,0 +1,20 @@ +package SeaBattle; + +import java.util.Arrays; + +import static SeaBattle.StartGame.COUNT; + +public interface WinnerChecker { + + static boolean isWinnerExist(char[][] board, int currentShot) { + if(Arrays.stream(board).flatMap((item)->new String(item).chars().mapToObj(a->(char)a)).noneMatch(e -> e == '0')){ + System.out.println("Game Over, you are winner !!!"); + return true; + } + if(COUNT <= currentShot){ + System.out.println("Your shells are out, try again"); + return true; + } + return false; + } +} diff --git a/src/main/java/homework_1/Main.java b/src/main/java/homework_1/Main.java index 07c029a2..5beb91c6 100644 --- a/src/main/java/homework_1/Main.java +++ b/src/main/java/homework_1/Main.java @@ -1,9 +1,18 @@ package homework_1; public class Main { + public static final String ANSI_RESET = "\u001B[0m"; + public static final String ANSI_RED = "\u001B[31m"; public static void main(String[] args) { - System.out.println("Hello homework!"); + + for (String i: args) { + if(i.equals("error")){ + System.out.println(ANSI_RED + "Alarm!" + ANSI_RESET); + break; + } + System.out.println(i + ": " + i.length()); + } } } diff --git a/src/main/java/homework_2/pyramid_printer/InputPyramidReader.java b/src/main/java/homework_2/pyramid_printer/InputPyramidReader.java new file mode 100644 index 00000000..76eea796 --- /dev/null +++ b/src/main/java/homework_2/pyramid_printer/InputPyramidReader.java @@ -0,0 +1,24 @@ +package homework_2.pyramid_printer; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +public class InputPyramidReader { + + public int bufferReaderForPyramid() { + try(BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + int i = Integer.parseInt(reader.readLine()); + if(i < 0) { + System.out.println("Error, negative numbers are not valid"); + } else { + return i; + } + } catch(NumberFormatException ex) { + System.out.println("Error, only numbers are allowed"); + } catch(IOException e) { + System.out.println("System Error"); + } + return 0; + } +} 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..9cd98626 --- /dev/null +++ b/src/main/java/homework_2/pyramid_printer/Main.java @@ -0,0 +1,11 @@ +package homework_2.pyramid_printer; + +import java.io.IOException; + +public class Main { + + public static void main(String[] args) throws IOException { + PyramidPrinter pyramidPrinter = new PyramidPrinter(); + 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..f03c2a19 --- /dev/null +++ b/src/main/java/homework_2/pyramid_printer/PyramidPrinter.java @@ -0,0 +1,16 @@ +package homework_2.pyramid_printer; + +public class PyramidPrinter { + + public void run() { + InputPyramidReader IOHelperForPyramid = new InputPyramidReader(); + int pyramidLength = IOHelperForPyramid.bufferReaderForPyramid(); + + for(int i = 0; i < pyramidLength; i++) { + for(int j = 0; j <= i; j++) { + System.out.print("x"); + } + System.out.println(); + } + } +} diff --git a/src/main/java/homework_2/random_chars_table/InputData.java b/src/main/java/homework_2/random_chars_table/InputData.java new file mode 100644 index 00000000..ea1cb424 --- /dev/null +++ b/src/main/java/homework_2/random_chars_table/InputData.java @@ -0,0 +1,14 @@ +package homework_2.random_chars_table; + +public class InputData { + + public int row; + public int column; + public String type; + + public InputData(int row, int column, String type) { + this.row = row; + this.column = column; + this.type = type; + } +} diff --git a/src/main/java/homework_2/random_chars_table/InputRandomCharsReader.java b/src/main/java/homework_2/random_chars_table/InputRandomCharsReader.java new file mode 100644 index 00000000..4bc2e0f4 --- /dev/null +++ b/src/main/java/homework_2/random_chars_table/InputRandomCharsReader.java @@ -0,0 +1,17 @@ +package homework_2.random_chars_table; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +public class InputRandomCharsReader { + + public String bufferReaderConsoleForRandom() { + try(BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + return reader.readLine(); + } catch(IOException ex) { + System.out.println("System Error"); + return ""; + } + } +} 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..aaab9316 --- /dev/null +++ b/src/main/java/homework_2/random_chars_table/Main.java @@ -0,0 +1,11 @@ +package homework_2.random_chars_table; + +import java.io.IOException; + +public class Main { + + public static void main(String[] args) throws IOException { + RandomCharsTable randomCharsTable = new RandomCharsTable(); + randomCharsTable.run(); + } +} diff --git a/src/main/java/homework_2/random_chars_table/ParserError.java b/src/main/java/homework_2/random_chars_table/ParserError.java new file mode 100644 index 00000000..910c7d83 --- /dev/null +++ b/src/main/java/homework_2/random_chars_table/ParserError.java @@ -0,0 +1,9 @@ +package homework_2.random_chars_table; + +public class ParserError extends Exception { + + public ParserError(String errorMessage) { + super(errorMessage); + } +} + diff --git a/src/main/java/homework_2/random_chars_table/ParserInputData.java b/src/main/java/homework_2/random_chars_table/ParserInputData.java new file mode 100644 index 00000000..6b33b5c2 --- /dev/null +++ b/src/main/java/homework_2/random_chars_table/ParserInputData.java @@ -0,0 +1,33 @@ +package homework_2.random_chars_table; + +public class ParserInputData { + + public InputData parserInputRandomData(String input) throws ParserError { + + String[] arrayWithInputData = input.trim().split(" "); + try { + + if(arrayWithInputData.length != 3) { + throw new ParserError("Should be typed 3 parameters (e.g. 3 3 odd)"); + } + + int row = Integer.parseInt(arrayWithInputData[0]); + int column = Integer.parseInt(arrayWithInputData[1]); + + String typeOfParity = arrayWithInputData[2]; + + if(row < 0 || column < 0) { + throw new ParserError("negative isn't allowed"); + } + + if(!typeOfParity.equals("even") && !typeOfParity.equals("odd")) { + throw new ParserError("Wrong type parameter"); + } + + return new InputData(row, column, typeOfParity); + + } catch(NumberFormatException ex) { + throw new ParserError("Invalid data"); + } + } +} 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..3e681ebc --- /dev/null +++ b/src/main/java/homework_2/random_chars_table/RandomCharsTable.java @@ -0,0 +1,49 @@ +package homework_2.random_chars_table; + +import java.util.ArrayList; +import java.util.List; + +public class RandomCharsTable { + + public void run() { + InputRandomCharsReader randomIOHelper = new InputRandomCharsReader(); + + try { + String inputString = randomIOHelper.bufferReaderConsoleForRandom(); + InputData inputData = new ParserInputData().parserInputRandomData(inputString); + returnAnswer(generateArrays(inputData.row, inputData.column), inputData.type); + } catch(ParserError ex) { + System.out.print(ex.getMessage()); + return; + } + } + + private char[][] generateArrays(int j, int k) { + char[][] arr = new char[j][k]; + for(int row = 0; row < j; row++) { + for(int col = 0; col < k; col++) { + arr[row][col] = (char) (Math.random() * 26 + 'A'); + } + } + return arr; + } + + private void returnAnswer(char[][] arr, String type) { + List result = new ArrayList<>(); + String array = ""; + for(int row = 0; row < arr.length; row++) { + for(int col = 0; col < arr[row].length; col++) { + + array += "|" + arr[row][col] + "|"; + + if((type.equals("even") && arr[row][col] % 2 == 0) || (type.equals("odd") && arr[row][col] % 2 != 0)) { + result.add(String.valueOf(arr[row][col])); + } + } + array += "\n"; + } + + System.out.println(array); + System.out.println(type + " letters - " + String.join(", ", result)); + } +} diff --git a/src/main/java/homework_2/traffic_light/InputTrafficLightReader.java b/src/main/java/homework_2/traffic_light/InputTrafficLightReader.java new file mode 100644 index 00000000..cd16740b --- /dev/null +++ b/src/main/java/homework_2/traffic_light/InputTrafficLightReader.java @@ -0,0 +1,27 @@ +package homework_2.traffic_light; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +public class InputTrafficLightReader { + + public int bufferReaderConsole() { + try(BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + + int i = Integer.parseInt(reader.readLine()); + if(i < 0) { + System.out.println("Error, negative numbers are not allowed"); + } else if(i >= 86400) { + System.out.println("Error, the day is over"); + } + return i; + } catch(NumberFormatException ex) { + System.out.println("Error, invalid data format, please enter integer"); + return -1; + } catch(IOException e) { + System.out.println("System error"); + return -1; + } + } +} 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..b7776d6e --- /dev/null +++ b/src/main/java/homework_2/traffic_light/Main.java @@ -0,0 +1,11 @@ +package homework_2.traffic_light; + +public class Main { + + public static void main(String[] args) { + + TrafficLight traffic_light = new TrafficLight(); + traffic_light.run(); + } +} +//Цикл светофора - 60 секунд. С 0 <= light < 35 зеленый, 35 <= light < 40 желтый, 40 <= light < 55 красный, 55 <= light < 60 желтый. \ No newline at end of file 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..4fb780d5 --- /dev/null +++ b/src/main/java/homework_2/traffic_light/TrafficLight.java @@ -0,0 +1,27 @@ +package homework_2.traffic_light; + +public class TrafficLight { + + private static final String ANSI_RESET = "\u001B[0m"; + private static final String ANSI_STRIKEOUT_RED = "\u001B[31;9m"; + private static final String ANSI_STRIKEOUT_GREEN = "\u001B[32;9m"; + private static final String ANSI_STRIKEOUT_YELLOW = "\u001B[33;9m"; + + public void run() { + InputTrafficLightReader IOHelper = new InputTrafficLightReader(); + checkColor(IOHelper.bufferReaderConsole()); + } + + private void checkColor(int time) { + if(time < 0 || time >= 86400) return; + + int sec = time % 60; + if(sec < 35) { + System.out.println(ANSI_STRIKEOUT_GREEN + "Green" + ANSI_RESET); + } else if(sec < 40 || sec >= 55) { + System.out.println(ANSI_STRIKEOUT_YELLOW + "Yellow" + ANSI_RESET); + } else { + System.out.println(ANSI_STRIKEOUT_RED + "Red" + ANSI_RESET); + } + } +} diff --git a/src/main/java/homework_3/ImmutableClass.java b/src/main/java/homework_3/ImmutableClass.java new file mode 100644 index 00000000..4bdbca9f --- /dev/null +++ b/src/main/java/homework_3/ImmutableClass.java @@ -0,0 +1,61 @@ +package homework_3; + +// The class must be declared as final (So that child classes can’t be created) +// Data members in the class must be declared as private (So that direct access is not allowed) +// Data members in the class must be declared as final (So that we can’t change the value of it after object creation) +// A parameterized constructor should initialize all the fields performing a deep copy (So that data members can’t be modified with object reference) +// Deep Copy of objects should be performed in the getter methods (To return a copy rather than returning the actual object reference) +// No setters (To not have the option to change the value of the instance variable) + +public final class ImmutableClass { + + private final String string; + private final int intVal; + private final StringBuilder stringBuilder; + + private ImmutableClass(String string, int intVal, StringBuilder stringBuilder) { + this.string = string; + this.intVal = intVal; + this.stringBuilder = new StringBuilder(stringBuilder); + } + + private ImmutableClass() { + this.string = "defaultVal"; + this.intVal = 0; + this.stringBuilder = new StringBuilder("defaultValue"); + } + + @Override + public String toString() { + return "ImmutableClass{" + + "string='" + string + '\'' + + ", intVal=" + intVal + + ", stringBuilder=" + stringBuilder + + '}'; + } + + public String getString() { + return string; + } + + public StringBuilder getStringBuilder() { + return new StringBuilder(stringBuilder); + } + public ImmutableClass createNewObj() { + return new ImmutableClass(); + } + + public static void main(String[] args) { + StringBuilder secondName = new StringBuilder("SecondName"); + ImmutableClass item = new ImmutableClass("Name", 12, secondName); + + System.out.println("Just created item: " + item); + System.out.println(item.getStringBuilder()); + + System.out.println(""); + + secondName.append("NEW"); + System.out.println("Item after changes: " + item); + System.out.println( "from object = " + item.getStringBuilder() + "; from variable = " + secondName); + } +} \ No newline at end of file diff --git a/src/main/java/homework_4/customAnnotation/Cat.java b/src/main/java/homework_4/customAnnotation/Cat.java new file mode 100644 index 00000000..3140a41b --- /dev/null +++ b/src/main/java/homework_4/customAnnotation/Cat.java @@ -0,0 +1,20 @@ +package homework_4.customAnnotation; + +import java.lang.reflect.Constructor; + + +public class Cat { + + String testValue; + + @MyAnnotation + public Cat() { + try { + Constructor constructor = this.getClass().getConstructor(null); + MyAnnotation myAnnotation = (MyAnnotation) constructor.getAnnotation(MyAnnotation.class); + this.testValue = myAnnotation.value(); + } catch(NoSuchMethodException e) { + e.printStackTrace(); + } + } +} diff --git a/src/main/java/homework_4/customAnnotation/Main.java b/src/main/java/homework_4/customAnnotation/Main.java new file mode 100644 index 00000000..558fcfe6 --- /dev/null +++ b/src/main/java/homework_4/customAnnotation/Main.java @@ -0,0 +1,9 @@ +package homework_4.customAnnotation; + +public class Main { + + public static void main(String[] args) { + Cat cat = new Cat(); + System.out.println(cat.testValue); + } +} diff --git a/src/main/java/homework_4/customAnnotation/MyAnnotation.java b/src/main/java/homework_4/customAnnotation/MyAnnotation.java new file mode 100644 index 00000000..866364bf --- /dev/null +++ b/src/main/java/homework_4/customAnnotation/MyAnnotation.java @@ -0,0 +1,9 @@ +package homework_4.customAnnotation; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +public @interface MyAnnotation { + String value() default "defValue"; +} diff --git a/src/main/java/homework_4/customFileReader/CustomFileReader.java b/src/main/java/homework_4/customFileReader/CustomFileReader.java new file mode 100644 index 00000000..2870b08a --- /dev/null +++ b/src/main/java/homework_4/customFileReader/CustomFileReader.java @@ -0,0 +1,65 @@ +package homework_4.customFileReader; + +import java.io.*; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.List; +import java.util.Scanner; + +public class CustomFileReader { + + private String path; + + public CustomFileReader(String file) { + this.path = file; + } + + public void run1() { + String line; + try(BufferedReader reader = new BufferedReader(new FileReader(path))) { + while((line = reader.readLine()) != null) { + System.out.println(line.replaceAll("[,.]", "")); + } + + } catch(IOException ex) { + System.out.println(ex.getMessage()); + } + } + + public void run2() { + StringBuilder line = new StringBuilder(); + Scanner scanner = null; + try { + scanner = new Scanner(new File(path)); + scanner.useDelimiter(""); + while(scanner.hasNext()) { + line.append(scanner.next()); + } + System.out.println(line.toString().replaceAll("[,.]", "")); + + } catch(FileNotFoundException ex) { + System.out.println(ex.getMessage()); + } finally { + if(scanner != null) { + scanner.close(); + } + } + } + + //NIO + public void run3() { + Path path = Paths.get(this.path); + try { + List read = Files.readAllLines(path); + + for(String list : read) { + System.out.println(list.replaceAll("[,.]", "")); + } + + } catch(IOException ex) { + System.out.println("Internal Error"); + } + } + +} diff --git a/src/main/java/homework_4/customFileReader/Main.java b/src/main/java/homework_4/customFileReader/Main.java new file mode 100644 index 00000000..f8212fa0 --- /dev/null +++ b/src/main/java/homework_4/customFileReader/Main.java @@ -0,0 +1,12 @@ +package homework_4.customFileReader; + +public class Main { + + public static void main(String[] args) { + String path = "src/main/resources/custom_file_reader.txt"; + CustomFileReader fileRiders = new CustomFileReader(path); + fileRiders.run1(); + fileRiders.run2(); + fileRiders.run3(); + } +} diff --git a/src/main/java/homework_4/singleton/Main.java b/src/main/java/homework_4/singleton/Main.java new file mode 100644 index 00000000..f948b675 --- /dev/null +++ b/src/main/java/homework_4/singleton/Main.java @@ -0,0 +1,11 @@ +package homework_4.singleton; + +public class Main { + + public static void main(String[] args) { + Singleton singleton = Singleton.getInstance(); + Singleton singleton2 = Singleton.getInstance(); + System.out.println(singleton.getName() + " " + singleton.getId()); + System.out.println(singleton2.getName() + " " + singleton2.getId()); + } +} diff --git a/src/main/java/homework_4/singleton/Singleton.java b/src/main/java/homework_4/singleton/Singleton.java new file mode 100644 index 00000000..349d5059 --- /dev/null +++ b/src/main/java/homework_4/singleton/Singleton.java @@ -0,0 +1,28 @@ +package homework_4.singleton; + +public final class Singleton { + + private static Singleton instance; + private final int id; + private final String name; + + public int getId() { + return id; + } + + public String getName() { + return name; + } + + private Singleton(int id, String name) { + this.id = id; + this.name = name; + } + + public static Singleton getInstance() { + if(instance == null) { + instance = new Singleton(1, "Chel"); + } + return instance; + } +} diff --git a/src/main/java/homework_5/customRegexMatcher/CustomRegexMatcher.java b/src/main/java/homework_5/customRegexMatcher/CustomRegexMatcher.java new file mode 100644 index 00000000..785d9cc3 --- /dev/null +++ b/src/main/java/homework_5/customRegexMatcher/CustomRegexMatcher.java @@ -0,0 +1,11 @@ +package homework_5.customRegexMatcher; + +import java.util.regex.Pattern; + +public class CustomRegexMatcher { + + public void run(String str) { + System.out.println(Pattern.matches("(GET |POST |PUT |DELETE )\\/api/v1/.*", str)); + } + +} diff --git a/src/main/java/homework_5/customRegexMatcher/Main.java b/src/main/java/homework_5/customRegexMatcher/Main.java new file mode 100644 index 00000000..b2de480c --- /dev/null +++ b/src/main/java/homework_5/customRegexMatcher/Main.java @@ -0,0 +1,11 @@ +package homework_5.customRegexMatcher; + +public class Main { + public static void main(String[] args) { + + String string = "192.168.00.00 - - [10/Jun/2021:07:21:22 +0000] PUT /api/v1/user/favorites HTTP/1.1 200 45 https://test.lab/login"; + + CustomRegexMatcher customRegexMatcher = new CustomRegexMatcher(); + customRegexMatcher.run(string); + } +} diff --git a/src/main/java/homework_5/powerOfNumber/Main.java b/src/main/java/homework_5/powerOfNumber/Main.java new file mode 100644 index 00000000..70ec4b00 --- /dev/null +++ b/src/main/java/homework_5/powerOfNumber/Main.java @@ -0,0 +1,16 @@ +package homework_5.powerOfNumber; + +public class Main { + public static void main(String[] args) { + PowerOfNumber powerOfNumber = new PowerOfNumber(); +// System.out.println (powerOfNumber.recursion (2, 2)); +// System.out.println (powerOfNumber.recursion (2, 1)); +// System.out.println (powerOfNumber.recursion (2, 0)); +// System.out.println (powerOfNumber.recursion (0, 2)); +// System.out.println (Math.pow(2,2)); +// System.out.println (Math.pow(2,1)); +// System.out.println (Math.pow(2,0)); +// System.out.println (Math.pow(0,2)); + powerOfNumber.run(); + } +} diff --git a/src/main/java/homework_5/powerOfNumber/PowerOfNumber.java b/src/main/java/homework_5/powerOfNumber/PowerOfNumber.java new file mode 100644 index 00000000..6b971bff --- /dev/null +++ b/src/main/java/homework_5/powerOfNumber/PowerOfNumber.java @@ -0,0 +1,51 @@ +package homework_5.powerOfNumber; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; + +public class PowerOfNumber { + + private int number; + private int power; + + private int recursion(int firstNumber, int secondNumber) { + if(secondNumber < 1) return 1; + return firstNumber * recursion(firstNumber, secondNumber - 1); + } + + public void run() { + String inputString = bufferReaderConsole(); + if(validator(inputString)) { + System.out.println(recursion(number, power)); + } else { + System.out.println("Only 2 non-negative integers are allowed"); + } + } + + private String bufferReaderConsole() { + try(BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) { + return reader.readLine(); + } catch(IOException ex) { + return ""; + } + } + + public boolean validator(String input) { + try { + String[] arr = input.split(" "); + if(arr.length != 2) { + return false; + } + number = Integer.parseInt(arr[0]); + power = Integer.parseInt(arr[1]); + if(number < 0 || power < 0) { + return false; + } + } catch(NumberFormatException | NullPointerException ex) { + return false; + } + return true; + } + +} diff --git a/src/main/java/homework_6/Main.java b/src/main/java/homework_6/Main.java new file mode 100644 index 00000000..67e38173 --- /dev/null +++ b/src/main/java/homework_6/Main.java @@ -0,0 +1,23 @@ +package homework_6; + +import java.util.HashMap; + +public class Main { + + public static void main(String[] args) { + HashMap map = new HashMap<>(); + MapProblemsCollisionGenerator k1 = new MapProblemsCollisionGenerator(1, "firstKey"); + MapProblemsCollisionGenerator k2 = new MapProblemsCollisionGenerator(2, "secondKey"); + + System.out.println("storing value for k1"); + map.put(k1, "firstValue"); + System.out.println("storing value for k2"); + map.put(k2, "secondValue"); + + System.out.println("retrieving value for k1"); + String v1 = map.get(k1); + System.out.println("retrieving value for k2"); + String v2 = map.get(k2); + + } +} diff --git a/src/main/java/homework_6/MapProblemsCollisionGenerator.java b/src/main/java/homework_6/MapProblemsCollisionGenerator.java new file mode 100644 index 00000000..b4df5465 --- /dev/null +++ b/src/main/java/homework_6/MapProblemsCollisionGenerator.java @@ -0,0 +1,35 @@ +package homework_6; + +import java.util.Objects; + +public class MapProblemsCollisionGenerator { + + private final String name; + private final int id; + public MapProblemsCollisionGenerator(int id, String name) { + this.id = id; + this.name = name; + } + + @Override + public boolean equals(Object o) { + System.out.println("Calling equals() for key: " + o); + if(this == o) return true; + if(o == null || getClass() != o.getClass()) return false; + MapProblemsCollisionGenerator that = (MapProblemsCollisionGenerator) o; + return id == that.id && Objects.equals(name, that.name); + } + + @Override + public int hashCode() { + return 1; + } + + @Override + public String toString() { + return "MapProblemsMutableGenerator{" + + "name='" + name + '\'' + + ", id=" + id + + '}'; + } +} diff --git a/src/main/java/homework_6/MapProblemsMutableGenerator.java b/src/main/java/homework_6/MapProblemsMutableGenerator.java new file mode 100644 index 00000000..3b87eed0 --- /dev/null +++ b/src/main/java/homework_6/MapProblemsMutableGenerator.java @@ -0,0 +1,40 @@ +package homework_6; + +import java.util.Objects; + +public class MapProblemsMutableGenerator { + + private StringBuilder name; + + public MapProblemsMutableGenerator(String name) { + this.name = new StringBuilder(name); + } + + public StringBuilder getName() { + return name; + } + + public void setName(String name) { + this.name = new StringBuilder(name); + } + + @Override + public boolean equals(Object o) { + if(this == o) return true; + if(o == null || getClass() != o.getClass()) return false; + MapProblemsMutableGenerator that = (MapProblemsMutableGenerator) o; + return name.toString().equals(that.name.toString()); + } + + @Override + public int hashCode() { + return Objects.hash(name); + } + + @Override + public String toString() { + return "MapProblemsMutableGenerator{" + + "stringBuilder=" + name + + '}'; + } +} diff --git a/src/main/java/homework_6/MutableMain.java b/src/main/java/homework_6/MutableMain.java new file mode 100644 index 00000000..6f743674 --- /dev/null +++ b/src/main/java/homework_6/MutableMain.java @@ -0,0 +1,23 @@ +package homework_6; + +import java.util.HashMap; + +public class MutableMain { + public static void main(String[] args) { + + HashMap map = new HashMap(); + + MapProblemsMutableGenerator key = new MapProblemsMutableGenerator("name"); + MapProblemsMutableGenerator key2 = new MapProblemsMutableGenerator("name"); + + System.out.println(key.equals(key2)); + + map.put(key, 1); + System.out.println(1 == map.get(key)); + + key.setName("NewName"); + + System.out.println(key.getName()); + System.out.println(map.get(key)); + } +} diff --git a/src/main/java/homework_7/Cat.java b/src/main/java/homework_7/Cat.java new file mode 100644 index 00000000..eee5e3c8 --- /dev/null +++ b/src/main/java/homework_7/Cat.java @@ -0,0 +1,36 @@ +package homework_7; + +public class Cat { + + private int age; + private String name; + + public Cat(int age, String name) { + this.age = age; + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + @Override + public String toString() { + return "Cat{" + + "age=" + age + + ", name='" + name + '\'' + + '}'; + } +} diff --git a/src/main/java/homework_7/Kitten.java b/src/main/java/homework_7/Kitten.java new file mode 100644 index 00000000..93f93424 --- /dev/null +++ b/src/main/java/homework_7/Kitten.java @@ -0,0 +1,36 @@ +package homework_7; + +public class Kitten { + + private int age; + private String name; + + public Kitten(int age, String name) { + this.age = age; + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + @Override + public String toString() { + return "Kitten{" + + "age=" + age + + ", name='" + name + '\'' + + '}'; + } +} diff --git a/src/main/java/homework_7/KittenToCatFunction.java b/src/main/java/homework_7/KittenToCatFunction.java new file mode 100644 index 00000000..57446e39 --- /dev/null +++ b/src/main/java/homework_7/KittenToCatFunction.java @@ -0,0 +1,6 @@ +package homework_7; + +@FunctionalInterface +public interface KittenToCatFunction { + Cat grow(Kitten kitten); +} diff --git a/src/main/java/homework_7/Main.java b/src/main/java/homework_7/Main.java new file mode 100644 index 00000000..763f09fc --- /dev/null +++ b/src/main/java/homework_7/Main.java @@ -0,0 +1,15 @@ +package homework_7; + +public class Main { + + public static void main(String[] args) { + + Kitten kitten = new Kitten(1, "LittleCat"); + KittenToCatFunction func = x -> new Cat(x.getAge() + 5, "Old" + x.getName()); + + Cat cat = func.grow(kitten); + System.out.println(cat); + System.out.println(cat.getClass()); + System.out.println(kitten); + } +} diff --git a/src/main/resources/custom_file_reader.txt b/src/main/resources/custom_file_reader.txt new file mode 100644 index 00000000..f9d7b97c --- /dev/null +++ b/src/main/resources/custom_file_reader.txt @@ -0,0 +1,3 @@ +asdas dasd.as. d,as.d asdasdas.d +test +asd.as, dasd \ No newline at end of file diff --git a/src/test/java/SeaBattle/GenerateShipsTest.java b/src/test/java/SeaBattle/GenerateShipsTest.java new file mode 100644 index 00000000..79fbdb60 --- /dev/null +++ b/src/test/java/SeaBattle/GenerateShipsTest.java @@ -0,0 +1,43 @@ +package SeaBattle; + +import org.junit.jupiter.api.Test; + +import java.util.Arrays; + +import static SeaBattle.GenerateShips.FIELD_SIZE; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class GenerateShipsTest { + + + @Test + void testCreateShipWith1Size() { + int[][] arr = new int[FIELD_SIZE][FIELD_SIZE]; + + GenerateShips generateShips = new GenerateShips(); + generateShips.fillField(arr, 1); + System.out.println(Arrays.deepToString(arr)); + assertEquals(1, (int) Arrays.stream(arr).flatMapToInt(Arrays::stream).filter(x -> x == 1).count()); + assertTrue(Arrays.stream(arr).flatMapToInt(Arrays::stream).filter(x -> x == 9).count() >= 3); + } + + @Test + void testCreateShipWith4Size() { + int[][] arr = new int[FIELD_SIZE][FIELD_SIZE]; + GenerateShips generateShips = new GenerateShips(); + generateShips.fillField(arr, 4); + assertEquals(4, (int) Arrays.stream(arr).flatMapToInt(Arrays::stream).filter(x -> x == 4).count()); + assertTrue(Arrays.stream(arr).flatMapToInt(Arrays::stream).filter(x -> x == 9).count() >= 6); + } + + @Test + void testCreateBoardWithAllShips() { + GenerateShips generateShips = new GenerateShips(); + char[][] arr = generateShips.createBoardWithShips(); + assertEquals(20, (int) Arrays.stream(arr) + .flatMap((item) -> new String(item).chars().mapToObj(a -> (char) a)) + .filter(x -> x == '0').count()); + } + +} diff --git a/src/test/java/SeaBattle/InputValidatorTest.java b/src/test/java/SeaBattle/InputValidatorTest.java new file mode 100644 index 00000000..f7652793 --- /dev/null +++ b/src/test/java/SeaBattle/InputValidatorTest.java @@ -0,0 +1,43 @@ +package SeaBattle; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.Arrays; +import java.util.stream.Stream; + +import static SeaBattle.GenerateShips.FIELD_SIZE; +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class InputValidatorTest { + + static char[][] arr = new char[FIELD_SIZE][FIELD_SIZE]; + + @Test + void testGiven1() { + System.out.println(Arrays.deepToString(arr)); + assertEquals(true, InputValidator.isInvalidInputData(-1, 2, arr)); + } + + public static Stream ints() { + return Stream.of( + Arguments.of(false, 1, 1, arr), + Arguments.of(true, 1, -1, arr), + Arguments.of(true, -1, 1, arr), + Arguments.of(true, 1, 10, arr), + Arguments.of(true, 5, 5, arr), + Arguments.of(true, 6, 6, arr), + Arguments.of(false, 9, 1, arr) + ); + } + + @ParameterizedTest + @MethodSource("ints") + void boardGeneratorTestInt(boolean ex, int x, int y, char[][] arr) { + arr[5][5] = 'x'; + arr[6][6] = 'X'; + assertEquals(ex, InputValidator.isInvalidInputData(x, y, arr)); + } +} diff --git a/src/test/java/SeaBattle/WinnerCheckerTest.java b/src/test/java/SeaBattle/WinnerCheckerTest.java new file mode 100644 index 00000000..46ccb936 --- /dev/null +++ b/src/test/java/SeaBattle/WinnerCheckerTest.java @@ -0,0 +1,37 @@ +package SeaBattle; + +import org.junit.jupiter.api.Test; +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 SeaBattle.GenerateShips.FIELD_SIZE; +import static SeaBattle.StartGame.COUNT; +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class WinnerCheckerTest { + + static char[][] arr = new char[FIELD_SIZE][FIELD_SIZE]; + + public static Stream ints() { + return Stream.of( + Arguments.of(true, COUNT, arr), + Arguments.of(true, 1, arr) + ); + } + + @ParameterizedTest + @MethodSource("ints") + void isWinnerExistTest(boolean ex, int x, char[][] arr) { + boolean act = WinnerChecker.isWinnerExist(arr, x); + assertEquals(ex, act); + } + + @Test void isWinnerExistTestWithShip() { + arr[5][5] = '0'; + boolean act = WinnerChecker.isWinnerExist(arr, 3); + assertEquals(false, act); + } +} diff --git a/src/test/java/base/UnitBase.java b/src/test/java/base/UnitBase.java index 97e2685b..5178e63e 100644 --- a/src/test/java/base/UnitBase.java +++ b/src/test/java/base/UnitBase.java @@ -1,13 +1,11 @@ package base; -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.io.InputStream; -import java.io.PrintStream; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; +import java.io.*; + + public abstract class UnitBase { protected ByteArrayOutputStream mockedOut = new ByteArrayOutputStream(); @@ -58,16 +56,4 @@ protected void printOut() { System.setOut(new PrintStream(mockedOut)); } -// @Test -// void example() { -// setInput("2"); -// -// new PyramidPrinter().run(); -// printOut(); -// removeFromOutput("Please input number"): -// -// assertEquals("x", getOutputLines()[0]); -// assertEquals("xx", getOutputLines()[1]); -// } - } diff --git a/src/test/java/homework_2/pyramid_printer/PyramidPrinter_test.java b/src/test/java/homework_2/pyramid_printer/PyramidPrinter_test.java new file mode 100644 index 00000000..6ec5e5ec --- /dev/null +++ b/src/test/java/homework_2/pyramid_printer/PyramidPrinter_test.java @@ -0,0 +1,89 @@ +package homework_2.pyramid_printer; + +import base.UnitBase; +import org.junit.jupiter.api.Test; + +import java.io.IOException; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class PyramidPrinter_test extends UnitBase { + + @Test + void testGivenZero() throws IOException { + + setInput("0"); + + PyramidPrinter pyramidPrinter2 = new PyramidPrinter(); + pyramidPrinter2.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals("", getOutputLines()[0]); +} + + @Test + public void testInput2() throws IOException { + setInput("2"); + + PyramidPrinter pyramidPrinter = new PyramidPrinter(); + pyramidPrinter.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals("x", getOutputLines()[0]); + assertEquals("xx", getOutputLines()[1]); +} + + @Test + public void testInput3() throws IOException { + setInput("3"); + + PyramidPrinter pyramidPrinter = new PyramidPrinter(); + pyramidPrinter.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals("x", getOutputLines()[0]); + assertEquals("xx", getOutputLines()[1]); + assertEquals("xxx", getOutputLines()[2]); + } + + @Test + public void testInputNegative1() throws IOException { + setInput("-1"); + + PyramidPrinter pyramidPrinter = new PyramidPrinter(); + pyramidPrinter.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals("Error, negative numbers are not valid", getOutputLines()[0]); + } + + @Test + public void testInputBig1234567890123456() throws IOException { + setInput("1234567890123456"); + + PyramidPrinter pyramidPrinter = new PyramidPrinter(); + pyramidPrinter.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals("Error, only numbers are allowed", getOutputLines()[0]); + } + + @Test + public void testInputText() throws IOException { + setInput("text"); + + PyramidPrinter pyramidPrinter = new PyramidPrinter(); + pyramidPrinter.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals("Error, only numbers are allowed", getOutputLines()[0]); + } + +} + diff --git a/src/test/java/homework_2/random_chars_printer/RandomCharsPrinter.java b/src/test/java/homework_2/random_chars_printer/RandomCharsPrinter.java new file mode 100644 index 00000000..adb1abd4 --- /dev/null +++ b/src/test/java/homework_2/random_chars_printer/RandomCharsPrinter.java @@ -0,0 +1,77 @@ +package homework_2.random_chars_printer; + +import base.UnitBase; +import homework_2.random_chars_table.RandomCharsTable; +import org.junit.jupiter.api.Test; + +import java.io.IOException; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class RandomCharsPrinter extends UnitBase { + + @Test + public void testInput2x2Odd() throws IOException { + setInput("2 2 odd"); + + RandomCharsTable randomCharsTable = new RandomCharsTable(); + randomCharsTable.run(); + printOut(); + removeFromOutput("Please input number"); + + assertTrue(getOutputLines()[3].contains("odd letters -")); + } + + @Test + public void testInput2x2Even() throws IOException { + setInput("2 2 even"); + + RandomCharsTable randomCharsTable = new RandomCharsTable(); + randomCharsTable.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals(6, getOutputLines()[0].length()); + assertEquals(6, getOutputLines()[1].length()); + assertEquals(0, getOutputLines()[2].length()); + assertTrue(getOutputLines()[3].contains("even letters -")); + } + + @Test + public void testInputNegativeRow() throws IOException { + setInput("-2 2 even"); + + RandomCharsTable randomCharsTable = new RandomCharsTable(); + randomCharsTable.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals("negative isn't allowed", getOutputLines()[0]); + } + + @Test + public void testInputNegativeColumn() throws IOException { + setInput("2 -2 odd"); + + RandomCharsTable randomCharsTable = new RandomCharsTable(); + randomCharsTable.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals("negative isn't allowed", getOutputLines()[0]); + } + + @Test + public void testInputWrongOperator() throws IOException { + setInput("2 2 asd"); + + RandomCharsTable randomCharsTable = new RandomCharsTable(); + randomCharsTable.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals("Wrong type parameter", getOutputLines()[0]); + } + +} diff --git a/src/test/java/homework_2/trafficLighter/TrafficLighter.java b/src/test/java/homework_2/trafficLighter/TrafficLighter.java new file mode 100644 index 00000000..536b9c68 --- /dev/null +++ b/src/test/java/homework_2/trafficLighter/TrafficLighter.java @@ -0,0 +1,110 @@ +package homework_2.trafficLighter; + +import base.UnitBase; +import homework_2.traffic_light.TrafficLight; +import org.junit.jupiter.api.Test; + +import java.io.IOException; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class TrafficLighter extends UnitBase { + + @Test + public void testInput61ToSeeGreen() throws IOException { + setInput("61"); + + TrafficLight traffic_light = new TrafficLight (); + traffic_light.run(); + printOut(); + removeFromOutput("Please input number"); + + assertTrue(getOutputLines()[0].contains("Green")); + } + + @Test + public void testInput86400() throws IOException { + setInput("86400"); + + TrafficLight traffic_light = new TrafficLight (); + traffic_light.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals("Error, the day is over", getOutputLines()[0]); + } + + @Test + public void testInputZero() throws IOException { + setInput("0"); + + TrafficLight traffic_light = new TrafficLight (); + traffic_light.run(); + printOut(); + removeFromOutput("Please input number"); + + assertTrue(getOutputLines()[0].contains("Green")); + } + + @Test + public void testInputNegativeValue() throws IOException { + setInput("-2"); + + TrafficLight traffic_light = new TrafficLight (); + traffic_light.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals("Error, negative numbers are not allowed", getOutputLines()[0]); + } + + @Test + public void testInput45() throws IOException { + setInput("45"); + + TrafficLight traffic_light = new TrafficLight (); + traffic_light.run(); + printOut(); + removeFromOutput("Please input number"); + + assertTrue(getOutputLines()[0].contains("Red")); + } + + @Test + public void testInput39() throws IOException { + setInput("39"); + + TrafficLight traffic_light = new TrafficLight (); + traffic_light.run(); + printOut(); + removeFromOutput("Please input number"); + + assertTrue(getOutputLines()[0].contains("Yellow")); + } + + @Test + public void testInput55() throws IOException { + setInput("55"); + + TrafficLight traffic_light = new TrafficLight (); + traffic_light.run(); + printOut(); + removeFromOutput("Please input number"); + + assertTrue(getOutputLines()[0].contains("Yellow")); + } + + @Test + public void testInputText() throws IOException { + setInput("text"); + + TrafficLight traffic_light = new TrafficLight (); + traffic_light.run(); + printOut(); + removeFromOutput("Please input number"); + + assertEquals("Error, invalid data format, please enter integer", getOutputLines()[0]); + } + +} diff --git a/src/test/java/homework_4/customAnnotation/CustomAnnotationTest.java b/src/test/java/homework_4/customAnnotation/CustomAnnotationTest.java new file mode 100644 index 00000000..9786c0fc --- /dev/null +++ b/src/test/java/homework_4/customAnnotation/CustomAnnotationTest.java @@ -0,0 +1,14 @@ +package homework_4.customAnnotation; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class CustomAnnotationTest { + + @Test + void testAnnotationDefaultConstructorValue() { + Cat cat = new Cat (); + assertEquals ("defValue", cat.testValue); + } +} diff --git a/src/test/java/homework_4/customFileReader/CustomFileReaderTest.java b/src/test/java/homework_4/customFileReader/CustomFileReaderTest.java new file mode 100644 index 00000000..9f850a16 --- /dev/null +++ b/src/test/java/homework_4/customFileReader/CustomFileReaderTest.java @@ -0,0 +1,146 @@ +package homework_4.customFileReader; + +import base.UnitBase; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.io.*; +import java.nio.file.Path; +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.*; + +public class CustomFileReaderTest extends UnitBase { + + File file; + + @BeforeEach + public void setUp(@TempDir Path tempDir) { + this.file = new File ((tempDir.resolve ("textFile.txt")).toString ()); + } + + public void writeToFile(String text) { + try (BufferedWriter bw1 = new BufferedWriter (new FileWriter (file))) { + bw1.write (text); + } catch (IOException e) { + System.err.println ("Error message "); + } + } + + public static Stream testCasesInOneRow() { + return Stream.of ( + Arguments.of ("test,.test", "testtest"), + Arguments.of (",", ""), + Arguments.of (".", ""), + Arguments.of ("", ""), + Arguments.of (",....asd,. asd", "asd asd") + ); + } + + + @ParameterizedTest + @MethodSource("testCasesInOneRow") + void testRun1InputInOneRow(String in, String expected) { + writeToFile (in); + CustomFileReader fileReader = new CustomFileReader (file.getPath ()); + fileReader.run1 (); + printOut (); + + assertEquals (expected, getOutputLines ()[0]); + } + + @ParameterizedTest + @MethodSource("testCasesInOneRow") + void testRun2InputInOneRow(String in, String expected) { + writeToFile (in); + CustomFileReader fileReader = new CustomFileReader (file.getPath ()); + fileReader.run2 (); + printOut (); + + assertEquals (expected, getOutputLines ()[0]); + } + + @ParameterizedTest + @MethodSource("testCasesInOneRow") + void testRun3InputInOneRow(String in, String expected) { + writeToFile (in); + CustomFileReader fileReader = new CustomFileReader (file.getPath ()); + fileReader.run3 (); + printOut (); + + assertEquals (expected, getOutputLines ()[0]); + } + + //getOutPut using trim(), so it's remove "\n" too + public static Stream testCasesInTwoRows() { + return Stream.of ( + Arguments.of ("te\nst,.test", "te\nsttest"), + Arguments.of ("\n,", ""), + Arguments.of ("\n.\n..", ""), + Arguments.of ("\n\n", ""), + Arguments.of (",\n...\n.asd,. \nasd", "asd \nasd") + ); + } + + @ParameterizedTest + @MethodSource("testCasesInTwoRows") + void testRun1InputInTwoRow(String in, String expected) { + writeToFile (in); + CustomFileReader fileReader = new CustomFileReader (file.getPath ()); + fileReader.run1 (); + printOut (); + + assertEquals (expected, getOutput ()); + } + + @ParameterizedTest + @MethodSource("testCasesInTwoRows") + void testRun2InputInTwoRow(String in, String expected) { + writeToFile (in); + CustomFileReader fileReader = new CustomFileReader (file.getPath ()); + fileReader.run2 (); + printOut (); + + assertEquals (expected, getOutput ()); + } + + @ParameterizedTest + @MethodSource("testCasesInTwoRows") + void testRun3InputInTwoRow(String in, String expected) { + writeToFile (in); + CustomFileReader fileReader = new CustomFileReader (file.getPath ()); + fileReader.run3 (); + printOut (); + + assertEquals (expected, getOutput ()); + } + + @Test + void testRun1FileNotFound() { + + CustomFileReader fileReader = new CustomFileReader (""); + fileReader.run1 (); + String expectedMessage = "(No such file or directory)"; + assertTrue(getOutput ().contains(expectedMessage)); + } + + @Test + void testRun2FileNotFound() { + CustomFileReader fileReader = new CustomFileReader (""); + fileReader.run2 (); + String expectedMessage = "(No such file or directory)"; + assertTrue(getOutput ().contains(expectedMessage)); + } + + @Test + void testRun3FileNotFound() { + CustomFileReader fileReader = new CustomFileReader (""); + fileReader.run3 (); + String expectedMessage = "Internal Error"; + assertTrue(getOutput ().contains (expectedMessage)); + } +} diff --git a/src/test/java/homework_4/singleton/SingletonTest.java b/src/test/java/homework_4/singleton/SingletonTest.java new file mode 100644 index 00000000..6880892f --- /dev/null +++ b/src/test/java/homework_4/singleton/SingletonTest.java @@ -0,0 +1,13 @@ +package homework_4.singleton; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class SingletonTest { + + @Test + void testSingleton() { + assertTrue(Singleton.getInstance() == (Singleton.getInstance ())); + } +} diff --git a/src/test/java/homework_5/CustomRegexMatcher/CustomRegexMatcherTest.java b/src/test/java/homework_5/CustomRegexMatcher/CustomRegexMatcherTest.java new file mode 100644 index 00000000..e7e6f909 --- /dev/null +++ b/src/test/java/homework_5/CustomRegexMatcher/CustomRegexMatcherTest.java @@ -0,0 +1,36 @@ +package homework_5.CustomRegexMatcher; + +import base.UnitBase; +import homework_5.customRegexMatcher.CustomRegexMatcher; +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; + +public class CustomRegexMatcherTest extends UnitBase { + + public static Stream regex() { + return Stream.of ( + Arguments.of ("PUT /api/v1/ HTTP/1.1 200 45 https://test.lab/login", "true"), + Arguments.of ("GET 1", "false"), + Arguments.of (" GET /api/v1/", "false"), + Arguments.of ("POST /api/v1/", "true"), + Arguments.of ("POST /api/1/", "false"), + Arguments.of ("POST/api/v1/", "false"), + Arguments.of ("DELETE /api/v1/", "true"), + Arguments.of ("DELET /api/v1/", "false") + ); + } + + @ParameterizedTest + @MethodSource("regex") + void testRun1InputInOneRow(String in, String expected) { + CustomRegexMatcher customRegexMatcher = new CustomRegexMatcher (); + customRegexMatcher.run (in); + + assertEquals (expected, getOutput ()); + } +} diff --git a/src/test/java/homework_5/powerOfNumber/PowerOfNumberTest.java b/src/test/java/homework_5/powerOfNumber/PowerOfNumberTest.java new file mode 100644 index 00000000..f376fd57 --- /dev/null +++ b/src/test/java/homework_5/powerOfNumber/PowerOfNumberTest.java @@ -0,0 +1,41 @@ +package homework_5.powerOfNumber; + +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; + +public class PowerOfNumberTest extends UnitBase { + + static String expectedError = "Only 2 non-negative integers are allowed"; + + public static Stream recursionTests() { + return Stream.of ( + Arguments.of ("2 2", "4"), + Arguments.of ("2 1", "2"), + Arguments.of ("2 0", "1"), + Arguments.of ("0 2", "0"), + Arguments.of ("3 3", "27"), + Arguments.of ("asd,. asd", expectedError), + Arguments.of ("1", expectedError), + Arguments.of ("-1 2", expectedError), + Arguments.of ("", expectedError), + Arguments.of (" ", expectedError), + Arguments.of ("5. 2", expectedError) + ); + } + + @ParameterizedTest + @MethodSource("recursionTests") + void testRun1InputInOneRow(String in, String expected) { + setInput (in); + PowerOfNumber powerOfNumber = new PowerOfNumber (); + powerOfNumber.run (); + + assertEquals (expected, getOutputLines ()[0]); + } +}