diff --git a/README.md b/README.md index 5d686e9f..b383b1ec 100644 --- a/README.md +++ b/README.md @@ -1,9 +1,29 @@ # Java Core June 2021 -## *Nikolaev Artem* +## *Zaytsev Artem* | 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 | +| HW_1 | [Console printer](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/main/java/homework_1) | The app that reads input arguments and prints them, until "error" argument | +| HW_2.1 | [Traffic Light](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/main/java/Homework_2/traffic_light) | The app that returns the color of the traffic light depending on the number of seconds from the beginning of the day | +| HW_2.2 | [Pyramid Printer](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/main/java/Homework_2/pyramid_printer) | The app that "builds" a pyramid with the given base | +| HW_2.3 | [Random Chars Table](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/main/java/Homework_2/random_chars_table) | The app that "builds" a table of chars, end print the letters which meet a given strategy (even/odd)| +| HW_3 | [ImmutableClass](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/main/java/homework_3) | ImmutableClass (MyImmutableElectricGuitarESP class)| +| HW_3.1 | [Traffic Light Tests](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/test/java/homework_2/traffic_light) | Tests for "Traffic Light" Application| +| HW_3.2 | [Pyramid Printer Tests](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/test/java/homework_2/pyramid_printer) | Tests for "Pyramid Printer" Application | +| HW_3.3 | [Random Chars Table Tests](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/test/java/homework_2/random_chars_table) | Tests for "Random Chars Table" Application| +| HW_4.1 | [Custom_File_Reader](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/main/java/homework_4/custom_file_reader) | Custom_File_Reader task| +| HW_4.1_Tests | [Custom_File_Reader Tests](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/test/java/homework_4/custom_file_reader) | Tests for Custom_File_Reader| +| HW_4.2 | [Singleton](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/main/java/homework_4/singleton) | Singleton task| +| HW_4.2_Tests | [Singleton Tests](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/test/java/homework_4/singleton) | Tests for Singleton| +| HW_4.3 | [Custom_Annotation](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/main/java/homework_4/custom_annotation) | Custom_Annotation task| +| HW_4.3_Tests | [Custom_Annotation Tests](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/test/java/homework_4/custom_annotation) | Tests for Custom_Annotation | +| HW_5.1 | [Power Of Number](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/main/java/homework_5/power_of_number) | Power Of Number task| +| HW_5.1_Tests | [Power Of Number Tests](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/test/java/homework_5/power_of_number) | Tests for Power Of Number task| +| HW_5.2 | [Custom Regex Matcher](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/main/java/homework_5/custom_regex_matcher) | Custom Regex Matcher task| +| HW_5.2_Tests | [Custom Regex Matcher Tests](https://github.com/NikolaevArtem/Java_Core_June_2021/tree/feature/ZaytsevArtem/src/test/java/homework_5/custom_regex_matcher) | Tests for Custom Regex Matcher task| -[Link to markdown giude](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) + +[Link to my codingbat result page](https://codingbat.com/done?user=zarp1986@gmail.com&tag=4480593357) + +[Link to markdown guide](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) diff --git a/build.gradle b/build.gradle index b91dc843..f1be108b 100644 --- a/build.gradle +++ b/build.gradle @@ -10,8 +10,11 @@ repositories { } dependencies { + implementation 'junit:junit:4.12' + implementation 'junit:junit:4.12' 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/src/main/java/homework_1/Main.java b/src/main/java/homework_1/Main.java index 07c029a2..bc96080f 100644 --- a/src/main/java/homework_1/Main.java +++ b/src/main/java/homework_1/Main.java @@ -1,9 +1,29 @@ package homework_1; public class Main { + protected static final String RED_COLOR = "\033[31m"; + protected static final String GREEN_COLOR = "\033[32m"; + protected static final String RESET_COLOR = "\033[0m"; public static void main(String[] args) { - System.out.println("Hello homework!"); - } -} + int k = args.length; + if (k == 0) { + System.out.println(GREEN_COLOR + "Application has been called " + RED_COLOR + "without " + GREEN_COLOR + "the arguments!" + RESET_COLOR); + } else { + for (int i = 0; i < k; i++) { + if (args[i].equals("error")) { + //https://stackoverflow.com/questions/565252/how-to-set-a-strings-color + System.out.println(RED_COLOR + "Alarm!" + RESET_COLOR); + //exit from the loop + break; + } + else { + String s = "letter"; + if (args[i].length() > 1) {s = s + "s";} + System.out.println(args[i] + ": " + args[i].length() + " " + s); + } + } + } + } +} \ No newline at end of file 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..74e81c55 --- /dev/null +++ b/src/main/java/homework_2/pyramid_printer/Main.java @@ -0,0 +1,9 @@ +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..74f15d91 --- /dev/null +++ b/src/main/java/homework_2/pyramid_printer/PyramidPrinter.java @@ -0,0 +1,41 @@ +package homework_2.pyramid_printer; + +import java.util.Scanner; + +public class PyramidPrinter { + protected final String ERROR_MSG = "Only 1 non-negative integer is allowed as passed parameter! Please, try again"; + int base; + + public void run() { + System.out.println("Enter the base of the pyramid, valid value is integer:"); + readAndValidateInput(); + drawPyramid(base); + + } + + protected void readAndValidateInput() { + try (Scanner scanner = new Scanner(System.in)){ + String s = scanner.nextLine(); + if (s.matches("\\d+")) { + base = Integer.parseInt(s); + } else { + throw new IllegalArgumentException(); + } + } + catch (IllegalArgumentException e){ + System.out.println(ERROR_MSG); + } + + } + + protected void drawPyramid(int base){ + for (int i = 0; i < base; 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/Main.java b/src/main/java/homework_2/random_chars_table/Main.java new file mode 100644 index 00000000..580b2df4 --- /dev/null +++ b/src/main/java/homework_2/random_chars_table/Main.java @@ -0,0 +1,9 @@ +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..ddcf2824 --- /dev/null +++ b/src/main/java/homework_2/random_chars_table/RandomCharsTable.java @@ -0,0 +1,105 @@ +package homework_2.random_chars_table; + + +import java.util.Scanner; + +public class RandomCharsTable { + protected static final int MIN_ASCII_CODE = 65; + protected static final int MAX_ASCII_CODE = 90; + protected static final String ERR_MSG = "Passed parameters should match the format [positive integer] [positive integer] [even|odd]"; + int cols = 0; int rows = 0; + String strategy = ""; + boolean exceptionWasThrown; + + public void run(){ + System.out.println("Enter the dimensions of matrix and required strategy : two integers and required strategy - even|odd, delimiter - space character))"); + readAndValidateInput(); + if (exceptionWasThrown) { + System.out.println(ERR_MSG); + } else { + int [][] matrix = createCharsTable(cols, rows); + printCharsTable(matrix, strategy); + } + + } + + protected void readAndValidateInput (){ + try (Scanner scanner = new Scanner(System.in)) { + int paramCount = 0; + String tempStr = ""; + String inString = scanner.nextLine(); + if (inString.matches("\\d+\\s\\d+\\s[odevn]{3,4}")){ + for (int i = 0; i < inString.length(); i++) { + char c = inString.charAt(i); + if (c != ' ') { + tempStr = tempStr + c; + } + else { + if (paramCount == 0) { + cols = Integer.parseInt(tempStr); + paramCount++; + tempStr = ""; + continue; + } + if (paramCount == 1) { + rows = Integer.parseInt(tempStr); + paramCount++; + tempStr = ""; + } + } + } + } + else { + throw new IllegalArgumentException(); + } + strategy = tempStr; + if ((!strategy.equals("even") && !strategy.equals("odd")) || cols <= 0 || rows <= 0) { + throw new IllegalArgumentException(); + } + } catch (RuntimeException e) { + exceptionWasThrown = true; + } + + } + + public int[][] createCharsTable(int col, int row){ + int [][] matrix = new int[col][row]; + for (int i = 0; i < col; i++){ + for (int j = 0; j < row; j++){ + matrix [i][j] = rnd(MIN_ASCII_CODE, MAX_ASCII_CODE); + } + } + return matrix; + + } + + public void printCharsTable (int[][] matrix, String strategy){ + String tempStr; + boolean evStrat = strategy.equals("even"); + String stratHeader = (evStrat) ? "Even letters - " : "Odd letters - "; + String stratRes = ""; + for (int i = 0; i < matrix.length; i++ ) { + tempStr = ""; + for (int j = 0; j < matrix[0].length; j++){ + tempStr = tempStr + (char) matrix[i][j] + "|"; + if (evStrat && matrix[i][j] % 2 == 0) { + stratRes = (stratRes.equals("")) ? (char) matrix[i][j] + "," : stratRes + " " + (char) matrix[i][j] + ","; + } + if (!evStrat && matrix[i][j] % 2 == 1) { + stratRes = (stratRes.equals("")) ? (char) matrix[i][j] + "," : stratRes + " " + (char) matrix[i][j] + ","; + } + } + System.out.println("|" + tempStr); + } + stratRes = (stratRes.length() > 1) ? stratRes.substring(0, stratRes.length() - 1) : stratRes; + System.out.println(stratHeader + stratRes); + + } + + public static int rnd(int min, int max) { + max -= min; + return (int) (Math.random() * ++max) + min; + + } + +} 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..792e8ea9 --- /dev/null +++ b/src/main/java/homework_2/traffic_light/Main.java @@ -0,0 +1,9 @@ +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..f554c012 --- /dev/null +++ b/src/main/java/homework_2/traffic_light/TrafficLight.java @@ -0,0 +1,63 @@ +package homework_2.traffic_light; + +import java.util.Scanner; + + +public class TrafficLight { + protected static final String RED_COLOUR = "\u001B[31m"; + protected static final String GREEN_COLOUR = "\u001B[32m"; + protected static final String YELLOW_COLOUR = "\u001B[33m"; + protected static final String RESET_COLOUR = "\u001B[0m"; + protected static final String ERR_MSG = "Only 1 non-negative integer is allowed as passed parameter! Please, try again"; + int seconds; + boolean exceptionWasThrown; + + public void run(){ + System.out.println("Enter the time (valid range is from 0 to 86399 ):"); + readAndValidateInput(); + if (exceptionWasThrown) { + System.out.println(ERR_MSG); + } else { + showingTrafficLightColor(seconds); + } + + } + + protected void readAndValidateInput () throws RuntimeException { + try (Scanner scanner = new Scanner(System.in)) { + String s = scanner.nextLine(); + if (!s.matches("\\d+")) { + throw new RuntimeException(); + } + else seconds = Integer.parseInt(s); + } + catch (RuntimeException e){ + exceptionWasThrown = true; + } + + } + + protected void showingTrafficLightColor(int sec){ + if (sec > 86399){ + System.out.println("The day is over"); + return; + } + sec = sec % 60; + String res = "unknown error("; + //YELLOW color + if ((sec >= 35 && sec < 40) || (sec >= 55 && sec < 60)) { + res = YELLOW_COLOUR + "YELLOW" + RESET_COLOUR; + } + //GREEN color + if (sec >= 0 && sec < 35) { + res = GREEN_COLOUR + "GREEN" + RESET_COLOUR; + } + //RED color + if (sec >= 40 && sec < 55) { + res = RED_COLOUR + "RED" + RESET_COLOUR; + } + System.out.println(res); + + } + +} diff --git a/src/main/java/homework_3/MyImmutableElectricGuitarESP.java b/src/main/java/homework_3/MyImmutableElectricGuitarESP.java new file mode 100644 index 00000000..6315b136 --- /dev/null +++ b/src/main/java/homework_3/MyImmutableElectricGuitarESP.java @@ -0,0 +1,90 @@ +package homework_3; + + + +/* +Immutable class means that once an object is created, we cannot change its content. In Java, all the wrapper classes (like Integer, Boolean, Byte, Short) and String class is immutable. We can create our own immutable class as well. + +Following are the requirements: + +- 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 MyImmutableElectricGuitarESP { + + private final boolean hasActivePickups; + private final int yearOfManufacture; + private final String brandOfPickups; + + public MyImmutableElectricGuitarESP(boolean hasActivePickups) { + this.hasActivePickups = hasActivePickups; + this.yearOfManufacture = 2004; + this.brandOfPickups = "EMG"; + } + + public MyImmutableElectricGuitarESP(int yearOfManufacture) { + this.yearOfManufacture = yearOfManufacture; + this.brandOfPickups = "Gibson"; + this.hasActivePickups = false; + } + + public MyImmutableElectricGuitarESP(String brandOfPickups) { + this.brandOfPickups = brandOfPickups; + this.hasActivePickups = false; + this.yearOfManufacture = 2006; + } + + public MyImmutableElectricGuitarESP(boolean hasActivePickups, int yearOfManufacture, String brandOfPickups) { + this.hasActivePickups = hasActivePickups; + this.yearOfManufacture = yearOfManufacture; + this.brandOfPickups = brandOfPickups; + } + + public boolean isHasActivePickups() { + return hasActivePickups; + } + + public int getYearOfManufacture() { + return yearOfManufacture; + } + + public String getBrandOfPickups() { + return brandOfPickups; + } + + public MyImmutableElectricGuitarESP getNewMyImmutableElectricGuitarESP(boolean newHasActivePickups){ + return new MyImmutableElectricGuitarESP(newHasActivePickups); + } + + public MyImmutableElectricGuitarESP getNewMyImmutableElectricGuitarESP(int newYearOfManufacture){ + return new MyImmutableElectricGuitarESP(newYearOfManufacture); + } + + public MyImmutableElectricGuitarESP getNewMyImmutableElectricGuitarESP(String newBrandOfPickups){ + return new MyImmutableElectricGuitarESP(newBrandOfPickups); + } + + public MyImmutableElectricGuitarESP getNewMyImmutableElectricGuitarESP(boolean newHasActivePickups, int newYearOfManufacture, String newBrandOfPickups){ + return new MyImmutableElectricGuitarESP(newHasActivePickups, newYearOfManufacture, newBrandOfPickups); + } + + public MyImmutableElectricGuitarESP getNewMyImmutableElectricGuitarESP(MyImmutableElectricGuitarESP previousMyImmutableElectricGuitarESP, boolean newHasActivePickups){ + return new MyImmutableElectricGuitarESP(newHasActivePickups, previousMyImmutableElectricGuitarESP.getYearOfManufacture(), previousMyImmutableElectricGuitarESP.getBrandOfPickups()); + } + + public MyImmutableElectricGuitarESP getNewMyImmutableElectricGuitarESP(MyImmutableElectricGuitarESP previousMyImmutableElectricGuitarESP, int newYearOfManufacture){ + return new MyImmutableElectricGuitarESP(previousMyImmutableElectricGuitarESP.isHasActivePickups(), newYearOfManufacture, previousMyImmutableElectricGuitarESP.getBrandOfPickups()); + } + + public MyImmutableElectricGuitarESP getNewMyImmutableElectricGuitarESP(MyImmutableElectricGuitarESP previousMyImmutableElectricGuitarESP, String newBrandOfPickups){ + return new MyImmutableElectricGuitarESP(previousMyImmutableElectricGuitarESP.isHasActivePickups(), previousMyImmutableElectricGuitarESP.getYearOfManufacture(), newBrandOfPickups); + } + +} diff --git a/src/main/java/homework_4/custom_annotation/Guitar.java b/src/main/java/homework_4/custom_annotation/Guitar.java new file mode 100644 index 00000000..91192bf4 --- /dev/null +++ b/src/main/java/homework_4/custom_annotation/Guitar.java @@ -0,0 +1,53 @@ +package homework_4.custom_annotation; + + +@GuitarDefault +public class Guitar { + private String model; + private String manufacturer; + private Integer yearOfManufacture; + private Integer serialNumber; + + public Guitar() { + GuitarDefault gD = this.getClass().getAnnotation(GuitarDefault.class); + this.model = gD.model(); + this.manufacturer = gD.manufacturer(); + this.yearOfManufacture = gD.yearOfManufacture(); + this.serialNumber = gD.serialNumber(); + + } + + public Guitar(String model, String manufacturer, Integer yearOfManufacture, Integer serialNumber) { + GuitarDefault gD = this.getClass().getAnnotation(GuitarDefault.class); + if (model == null || model.isEmpty()) { + this.model = gD.model(); + } else { + this.model = model; + } + + if (manufacturer == null || manufacturer.isEmpty()) { + this.manufacturer = gD.manufacturer(); + } else { + this.manufacturer = manufacturer; + } + + if (yearOfManufacture == null || yearOfManufacture <= 1200) { + this.yearOfManufacture = gD.yearOfManufacture(); + } else { + this.yearOfManufacture = yearOfManufacture; + } + + if (serialNumber == null || serialNumber < 0) { + this.serialNumber = gD.serialNumber(); + } else { + this.serialNumber = serialNumber; + } + + } + + public String toString() { + String s = "Model of guitar: " + model + "; Manufacturer: " + manufacturer + "; year: " + yearOfManufacture + "; S/N: " + serialNumber; + return s; + } + +} diff --git a/src/main/java/homework_4/custom_annotation/GuitarDefault.java b/src/main/java/homework_4/custom_annotation/GuitarDefault.java new file mode 100644 index 00000000..47bb5845 --- /dev/null +++ b/src/main/java/homework_4/custom_annotation/GuitarDefault.java @@ -0,0 +1,18 @@ +package homework_4.custom_annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +//https://skillbox.ru/media/base/kak-napisat-annotatsiyu-na-java-za-5-shagov/ +//https://web-shpargalka.ru/java-annotacii-zachem-oni-nuzhny.php +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.TYPE) + +public @interface GuitarDefault { + String manufacturer() default "A&M guitars"; + String model() default "Sophia"; + int yearOfManufacture() default 2015; + int serialNumber() default 101; +} diff --git a/src/main/java/homework_4/custom_annotation/Main.java b/src/main/java/homework_4/custom_annotation/Main.java new file mode 100644 index 00000000..d21dd73f --- /dev/null +++ b/src/main/java/homework_4/custom_annotation/Main.java @@ -0,0 +1,10 @@ +package homework_4.custom_annotation; + +public class Main { + public static void main(String[] args) { + Guitar guitar1 = new Guitar(); + System.out.println(guitar1); + Guitar guitar2 = new Guitar("Mh-250", "ESP-LTD", 2004, 719); + System.out.println(guitar2); + } +} 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..5d1b4521 --- /dev/null +++ b/src/main/java/homework_4/custom_file_reader/CustomFileReader.java @@ -0,0 +1,64 @@ +package homework_4.custom_file_reader; + +import java.awt.datatransfer.StringSelection; +import java.io.*; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Scanner; + +public class CustomFileReader { + private static final String FILE_PATH = "src/main/resources/custom_file_reader/File_for_CustomFileReader_Task.txt"; + private static final String ERROR_MSG = "Something went wrong: can't find the file or can't read it"; + +// BufferedReader + public void run1() { + try (BufferedReader reader = new BufferedReader(new FileReader(FILE_PATH))) { + String s; + while ((s = reader.readLine()) != null) { + System.out.println(removeDotsAndCommas(s)); + } + + } catch (Exception e) { + System.out.println(ERROR_MSG); + } + + } + +// Scanner + public void run2() { + try (Scanner scanner = new Scanner(new File(FILE_PATH))) { + String s; + while (scanner.hasNextLine()) { + s = scanner.nextLine(); + System.out.println(removeDotsAndCommas(s)); + } + + } catch (IOException e) { + System.out.println(ERROR_MSG); + } + + } + +// NIO + public void run3() { + Path path = Paths.get(FILE_PATH); + try (BufferedReader reader = Files.newBufferedReader(path)){ + String s; + while ((s = reader.readLine()) != null){ + System.out.println(removeDotsAndCommas(s)); + } + } catch (IOException e) { + System.out.println(ERROR_MSG); + } + + } + + + + + private String removeDotsAndCommas (String s) { + return s.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..75dd9a6d --- /dev/null +++ b/src/main/java/homework_4/custom_file_reader/Main.java @@ -0,0 +1,12 @@ +package homework_4.custom_file_reader; + +public class Main { + public static void main(String[] args) { + CustomFileReader customFileReader = new CustomFileReader(); + customFileReader.run1(); + customFileReader.run2(); + customFileReader.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..f3584ebe --- /dev/null +++ b/src/main/java/homework_4/singleton/Main.java @@ -0,0 +1,7 @@ +package homework_4.singleton; + +public class Main { + public static void main(String[] args) { + + } +} 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..82cd4f3c --- /dev/null +++ b/src/main/java/homework_4/singleton/Singleton.java @@ -0,0 +1,13 @@ +package homework_4.singleton; + +public class Singleton { + + private static Singleton instance = new Singleton(); + private Singleton() { + + } + public static Singleton getInstance() { + return instance; + } + +} 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..9552fec5 --- /dev/null +++ b/src/main/java/homework_5/custom_regex_matcher/CustomRegexMatcher.java @@ -0,0 +1,33 @@ +package homework_5.custom_regex_matcher; + +import java.util.Scanner; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +public class CustomRegexMatcher { + private static final String GREETING = "Enter the car's number:"; +// the expression on the line below (with Russian characters) worked correctly, but then stopped working correctly. I do not know why: +// private static final String REGEX = "([ABCEHKMOPTXYabcehkmoptxy]|[АВЕКМНОРСТУХавекмнорстух])\\d{3}([ABCEHKMOPTXYabcehkmoptxy]|[АВЕКМНОРСТУХавекмнорстух]){2}\\d{2,3}"; + private static final String REGEX = "[ABCEHKMOPTXYabcehkmoptxy]\\d{3}[ABCEHKMOPTXYabcehkmoptxy]{2}\\d{2,3}"; + private boolean matchingToRegex = false; + + public void run() { + System.out.println(GREETING); + readValidInput(); + System.out.println(matchingToRegex); + + } + + private void readValidInput() { + try (Scanner scanner = new Scanner(System.in)) { + String s = scanner.nextLine(); + Pattern pattern = Pattern.compile(REGEX); + Matcher matcher = pattern.matcher(s); + if (matcher.find()) { + matchingToRegex = true; + } + } + + } + +} 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..f8b52c06 --- /dev/null +++ b/src/main/java/homework_5/custom_regex_matcher/Main.java @@ -0,0 +1,7 @@ +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..930f2040 --- /dev/null +++ b/src/main/java/homework_5/power_of_number/Main.java @@ -0,0 +1,7 @@ +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..6c40d126 --- /dev/null +++ b/src/main/java/homework_5/power_of_number/PowerOfNumber.java @@ -0,0 +1,49 @@ +package homework_5.power_of_number; + +import java.util.Scanner; + +public class PowerOfNumber { + private static final String GREETING = "Enter two non-negative integers (the number and the desired power for it), split with blank:"; + private static final String ERROR_MSG = "Only 2 non-negative integers are allowed!"; + private int a, b; + private boolean inputIsValid = true; + + public void run(){ + System.out.println(GREETING); + readValidInput(); + if (inputIsValid) { + int res = powerOfInt(a, b); + System.out.println(res); + } + + } + + private void readValidInput() { + try (Scanner scanner = new Scanner(System.in)) { + String s = scanner.nextLine(); + if (s.matches("\\d+\\s\\d+")) { + a = Integer.parseInt(s.split("\\s")[0]); + b = Integer.parseInt(s.split("\\s")[1]); + if (a < 0 || b < 0) { + throw new IllegalArgumentException(); + } + } else { + throw new IllegalArgumentException(); + } + } + catch (RuntimeException e){ + System.out.println(ERROR_MSG); + inputIsValid = false; + } + + } + + private int powerOfInt(int n, int pow) { + if (pow == 0) { + return 1; + } + return n * powerOfInt(n, pow - 1); + + } + +} diff --git a/src/main/resources/custom_file_reader/File_for_CustomFileReader_Task.txt b/src/main/resources/custom_file_reader/File_for_CustomFileReader_Task.txt new file mode 100644 index 00000000..f0d429cb --- /dev/null +++ b/src/main/resources/custom_file_reader/File_for_CustomFileReader_Task.txt @@ -0,0 +1,5 @@ +qweqwe|, +|...fasdfsdf|,|.|, +aeaf;elkfjvna;ewlkfj +xcvbsdfjk|...,,, +...,,, \ No newline at end of file diff --git a/src/main/resources/custom_file_reader/File_for_CustomFileReader_Test.txt b/src/main/resources/custom_file_reader/File_for_CustomFileReader_Test.txt new file mode 100644 index 00000000..92ca8475 --- /dev/null +++ b/src/main/resources/custom_file_reader/File_for_CustomFileReader_Test.txt @@ -0,0 +1,4 @@ +qweqwe| +|fasdfsdf||| +aeaf;elkfjvna;ewlkfj +xcvbsdfjk| 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..370ab399 --- /dev/null +++ b/src/test/java/homework_2/pyramid_printer/PyramidPrinterTest.java @@ -0,0 +1,93 @@ +package homework_2.pyramid_printer; + +import base.UnitBase; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class PyramidPrinterTest extends UnitBase { + private final String GREET = "Enter the base of the pyramid, valid value is integer:"; + private final String HINT = "Only 1 non-negative integer is allowed as passed parameter! Please, try again"; + PyramidPrinter pyramidPrinter = new PyramidPrinter(); + + + @Test + void given0_whenOk_then_0 (){ + setInput("0"); + pyramidPrinter.run(); + printOut(); + removeFromOutput(GREET); + assertEquals("", getOutputLines()[0]); + } + + @Test + void given1_whenOk_then_1 (){ + setInput("1"); + pyramidPrinter.run(); + printOut(); + removeFromOutput(GREET); + assertEquals("x", getOutputLines()[0]); + } + + @Test + void given2_whenOk_then_2 (){ + setInput("2"); + pyramidPrinter.run(); + printOut(); + removeFromOutput(GREET); + assertEquals("x", getOutputLines()[0]); + assertEquals("xx", getOutputLines()[1]); + } + + @Test + void given5_whenOk_then_5 (){ + setInput("5"); + pyramidPrinter.run(); + printOut(); + removeFromOutput(GREET); + assertEquals("x", getOutputLines()[0]); + assertEquals("xx", getOutputLines()[1]); + assertEquals("xxx", getOutputLines()[2]); + assertEquals("xxxx", getOutputLines()[3]); + assertEquals("xxxxx", getOutputLines()[4]); + + } + + @Test + void givenString_whenBad_then_Hint (){ + setInput("Qwe"); + pyramidPrinter.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + } + + @Test + void givenFractal_whenBad_then_Hint (){ + setInput("2.5"); + pyramidPrinter.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + } + + @Test + void givenNegative_whenBad_then_Hint (){ + setInput("-5"); + pyramidPrinter.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + } + + @Test + void givenBigInt_whenBad_then_Hint (){ + setInput("99999999999999999999999999999"); + pyramidPrinter.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + } + +} 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..1f56435d --- /dev/null +++ b/src/test/java/homework_2/random_chars_table/RandomCharsTableTest.java @@ -0,0 +1,182 @@ +package homework_2.random_chars_table; + +import base.UnitBase; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +import java.util.*; + + +public class RandomCharsTableTest extends UnitBase { + protected final String GREET = "Enter the dimensions of matrix and required strategy : two integers and required strategy - even|odd, delimiter - space character))"; + protected final String HINT = "Passed parameters should match the format [positive integer] [positive integer] [even|odd]"; + protected HashSet validLetters; + protected HashSet evenLetters; + protected HashSet oddLetters; + protected RandomCharsTable randomCharsTable = new RandomCharsTable(); + + @BeforeEach + protected void initializeForTests (){ + validLetters = new HashSet<>(); + evenLetters = new HashSet<>(); + oddLetters = new HashSet<>(); + for (int i = 65; i <= 90; i++){ + validLetters.add((char) i); + if (i % 2 == 0) { + evenLetters.add((char) i); + } + else { + oddLetters.add((char) i); + } + } + + } + private boolean isValidCharTableDelimiters(String str, Character delimiterChar){ + for (int i = 0; i < str.length(); i = i + 2) { + if (str.charAt(i) != delimiterChar) { + return false; + } + } + return true; + + } + + private boolean isValidCharTable(String[] strings, int rows, int cols){ + if (strings.length -1 != rows){ + return false; + } + for (int i = 0; i < strings.length - 1; i++) { + String currStr = strings[i]; + if (!isValidCharTableDelimiters(currStr,'|')){ + return false; + } + currStr = currStr.replaceAll( "\\|+",""); + if ( (cols != currStr.length())){ + return false; + } + for (char c : currStr.toCharArray()) { + if (!validLetters.contains(c)){ + return false; + } + } + } + return true; + + } + private boolean isValidLastStringForEven(String str){ + str = str.replaceAll("(Even letters -)|(\\s+)|(,+)", ""); + for (char c : str.toCharArray()) { + if (oddLetters.contains(c)){ + return false; + } + } + return true; + + } + private boolean isValidLastStringForOdd(String str){ + str = str.replaceAll("(Odd letters -)|(\\s+)|(,+)", ""); + for (char c : str.toCharArray()) { + if (evenLetters.contains(c)){ + return false; + } + } + return true; + + } + + @Test + void given2_2_even_whenOk_thenOk (){ + setInput("2 2 even"); + randomCharsTable.run(); + printOut(); + removeFromOutput(GREET); + assertTrue(isValidCharTable(getOutputLines(), 2, 2)); + assertTrue(isValidLastStringForEven(getOutputLines()[getOutputLines().length-1])); + + } + + @Test + void given2_3_odd_whenOk_thenOk (){ + setInput("2 3 odd"); + randomCharsTable.run(); + printOut(); + removeFromOutput(GREET); + assertTrue(isValidCharTable(getOutputLines(), 2, 3)); + assertTrue(isValidLastStringForOdd(getOutputLines()[getOutputLines().length-1])); + + } + + @Test + void given15_10_odd_whenOk_thenOk (){ + setInput("15 10 odd"); + randomCharsTable.run(); + printOut(); + removeFromOutput(GREET); + assertTrue(isValidCharTable(getOutputLines(),15, 10)); + assertTrue(isValidLastStringForOdd(getOutputLines()[getOutputLines().length-1])); + + } + + @Test + void given0_1_odd_whenBad_thenHint (){ + setInput("0 1 odd"); + randomCharsTable.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + + } + + @Test + void given0_1_even_whenBad_thenHint (){ + setInput("0 1 even"); + randomCharsTable.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + + } + + @Test + void given5_5_event_whenBad_thenHint (){ + setInput("5 5 event"); + randomCharsTable.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + + } + + @Test + void given3_5_add_whenBad_thenHint (){ + setInput("3 5 add"); + randomCharsTable.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + + } + + @Test + void givenNegative_5_odd_whenBad_thenHint (){ + setInput("-3 5 odd"); + randomCharsTable.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + + } + + @Test + void given5_Negative_even_whenBad_thenHint (){ + setInput("5 -5 even"); + randomCharsTable.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + + } + +} 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..69e1eaca --- /dev/null +++ b/src/test/java/homework_2/traffic_light/TrafficLightTest.java @@ -0,0 +1,97 @@ +package homework_2.traffic_light; + +import base.UnitBase; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + + +public class TrafficLightTest extends UnitBase { + private final String GREET = "Enter the time (valid range is from 0 to 86399 ):"; + private final String HINT = "Only 1 non-negative integer is allowed as passed parameter! Please, try again"; + TrafficLight trafficLight = new TrafficLight(); + + @Test + void given0_whenOk_then_Green (){ + setInput("0"); + trafficLight.run(); + printOut(); + removeFromOutput(GREET); + assertTrue(getOutputLines()[0].contains("GREEN")); + } + + @Test + void given5_whenOk_then_Green (){ + setInput("5"); + trafficLight.run(); + printOut(); + removeFromOutput(GREET); + assertTrue(getOutputLines()[0].contains("GREEN")); + } + + @Test + void given35_whenOk_then_Yellow (){ + setInput("35"); + trafficLight.run(); + printOut(); + removeFromOutput(GREET); + assertTrue(getOutputLines()[0].contains("YELLOW")); + } + + @Test + void given54_whenOk_then_Red (){ + setInput("54"); + trafficLight.run(); + printOut(); + removeFromOutput(GREET); + assertTrue(getOutputLines()[0].contains("RED")); + } + + @Test + void given86401_whenOk_then_TheDayIsOver (){ + setInput("86401"); + trafficLight.run(); + printOut(); + removeFromOutput(GREET); + assertTrue(getOutputLines()[0].contains("The day is over")); + } + + + @Test + void givenString_whenBad_then_Hint (){ + setInput("Qwe"); + trafficLight.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + } + + @Test + void givenFractal_whenBad_then_Hint (){ + setInput("2.5"); + trafficLight.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + } + + @Test + void givenNegative_whenBad_then_Hint (){ + setInput("-5"); + trafficLight.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + } + + @Test + void givenBigInt_whenBad_then_Hint (){ + setInput("99999999999999999999999999999"); + trafficLight.run(); + printOut(); + removeFromOutput(GREET); + assertEquals(HINT, getOutputLines()[0]); + } + +} + + diff --git a/src/test/java/homework_4/custom_annotation/GuitarTest.java b/src/test/java/homework_4/custom_annotation/GuitarTest.java new file mode 100644 index 00000000..39e70292 --- /dev/null +++ b/src/test/java/homework_4/custom_annotation/GuitarTest.java @@ -0,0 +1,22 @@ +package homework_4.custom_annotation; + +import base.UnitBase; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +public class GuitarTest extends UnitBase { + private static final String GUITAR_WITH_ANNOTATION = "Model of guitar: Sophia; Manufacturer: A&M guitars; year: 2015; S/N: 101"; + private static final String GUITAR_FOR_TEST = "Model of guitar: Mh-250; Manufacturer: ESP-LTD; year: 2004; S/N: 719"; + + @Test + public void AnnotationTest () { + Guitar annotationGuitar = new Guitar(); + Assertions.assertEquals(GUITAR_WITH_ANNOTATION, annotationGuitar.toString()); + } + + @Test + public void CorrectGuitarTest () { + Guitar correctGuitar = new Guitar("Mh-250", "ESP-LTD", 2004, 719); + Assertions.assertEquals(GUITAR_FOR_TEST, correctGuitar.toString()); + } +} 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..fe8d6414 --- /dev/null +++ b/src/test/java/homework_4/custom_file_reader/CustomFileReaderTest.java @@ -0,0 +1,50 @@ +package homework_4.custom_file_reader; + +import base.UnitBase; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Arrays; + +public class CustomFileReaderTest extends UnitBase { + private static final String FILE_PATH = "src/main/resources/custom_file_reader/File_for_CustomFileReader_Test.txt"; + Path path = Paths.get(FILE_PATH); + CustomFileReader customFileReader = new CustomFileReader(); + + + @Test + public void run1Test() { + customFileReader.run1(); + try { + Assertions.assertEquals(Files.readAllLines(path), Arrays.asList(getOutputLines())); + } catch (IOException e) { + e.printStackTrace(); + } + } + + @Test + public void run2Test() { + customFileReader.run2(); + try { + Assertions.assertEquals(Files.readAllLines(path), Arrays.asList(getOutputLines())); + } catch (IOException e) { + e.printStackTrace(); + } + } + + @Test + public void run3Test() { + customFileReader.run3(); + try { + Assertions.assertEquals(Files.readAllLines(path), Arrays.asList(getOutputLines())); + } catch (IOException e) { + e.printStackTrace(); + } + } + + +} 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..eb09906b --- /dev/null +++ b/src/test/java/homework_4/singleton/SingletonTest.java @@ -0,0 +1,18 @@ +package homework_4.singleton; + +import base.UnitBase; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +public class SingletonTest extends UnitBase { + + + @Test + public void SingletonMainTest (){ + Singleton singleton1 = Singleton.getInstance(); + Singleton singleton2 = Singleton.getInstance(); + Assertions.assertEquals(singleton1, singleton2); + Assertions.assertSame(singleton1, singleton2); + } + +} 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..836d148e --- /dev/null +++ b/src/test/java/homework_5/custom_regex_matcher/CustomRegexMatcherTest.java @@ -0,0 +1,86 @@ +package homework_5.custom_regex_matcher; + +import base.UnitBase; +import org.junit.jupiter.api.Assertions; +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; + +public class CustomRegexMatcherTest extends UnitBase { + private final String GREETING = "Enter the car's number:"; + CustomRegexMatcher customRegexMatcher = new CustomRegexMatcher(); + + /* + @ParameterizedTest + @MethodSource ("rightRussianCases") + public void givenRightCarNumbers_whenRussian_thenTrueResult (String input, String expected) { + setInput(input); + customRegexMatcher.run(); + getOutput(); + removeFromOutput(GREETING); + Assertions.assertEquals(expected, getOutputLines() [0]); + + } + + static Stream rightRussianCases() { + return Stream.of( + Arguments.of("Р386АВ14", "true"), + Arguments.of("Р386ав114", "true"), + Arguments.of("Р386Ав14", "true"), + Arguments.of("О770ЕХ14", "true"), + Arguments.of("о770ЕХ14", "true"), + Arguments.of("о770ех114", "true") + ); + } + */ + + @ParameterizedTest + @MethodSource ("rightEnglishCases") + public void givenRightCarNumbers_whenEnglish_thenTrueResult (String input, String expected) { + setInput(input); + customRegexMatcher.run(); + getOutput(); + removeFromOutput(GREETING); + Assertions.assertEquals(expected, getOutputLines() [0]); + + } + + static Stream rightEnglishCases() { + return Stream.of( + Arguments.of("P386AB14", "true"), + Arguments.of("p386ab114", "true"), + Arguments.of("P386Ab14", "true"), + Arguments.of("O770EX14", "true"), + Arguments.of("o770Ex14", "true"), + Arguments.of("o770ex114", "true") + ); + } + + @ParameterizedTest + @MethodSource ("wrongRussianAndEnglishCases") + public void givenWrongCarNumbers_whenEnglishAndRussian_thenFalseResult (String input, String expected) { + setInput(input); + customRegexMatcher.run(); + getOutput(); + removeFromOutput(GREETING); + Assertions.assertEquals(expected, getOutputLines() [0]); + + } + + static Stream wrongRussianAndEnglishCases() { + return Stream.of( + Arguments.of("G386AB14", "false"), + Arguments.of("п386ab114", "false"), + Arguments.of("P386Ав1114", "false"), + Arguments.of("O770EX4", "false"), + Arguments.of("o770Ex", "false"), + Arguments.of("GS386AB14", "false"), + Arguments.of("G386ABs14", "false"), + Arguments.of("o77чex114", "false") + ); + } + + +} 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..d107e7ac --- /dev/null +++ b/src/test/java/homework_5/power_of_number/PowerOfNumberTest.java @@ -0,0 +1,63 @@ +package homework_5.power_of_number; + +import base.UnitBase; +import org.junit.jupiter.api.Assertions; +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; + +public class PowerOfNumberTest extends UnitBase { + private final String GREETING = "Enter two non-negative integers (the number and the desired power for it), split with blank:"; + private final String ERROR_MSG = "Only 2 non-negative integers are allowed!"; + PowerOfNumber powerOfNumber = new PowerOfNumber(); + + @ParameterizedTest + @MethodSource ("rightCases") + public void givenRightInt_whenOk_thenCalculatedResults (String input, String expected) { + setInput(input); + powerOfNumber.run(); + getOutput(); + removeFromOutput(GREETING); + Assertions.assertEquals(expected, getOutputLines() [0]); + } + + static Stream rightCases() { + return Stream.of( + Arguments.of("2 2", "4"), + Arguments.of("3 3", "27"), + Arguments.of("0 0", "1"), + Arguments.of("5 0", "1"), + Arguments.of("0 5", "0"), + Arguments.of("1 1", "1") + ); + } + + @ParameterizedTest + @MethodSource ("wrongCases") + public void givenWrongInput_whenOk_thenErrorMessage (String input) { + setInput(input); + powerOfNumber.run(); + getOutput(); + removeFromOutput(GREETING); + Assertions.assertEquals(ERROR_MSG, getOutputLines() [0]); + } + + static Stream wrongCases() { + return Stream.of( + Arguments.of(""), + Arguments.of(" "), + Arguments.of("2 b"), + Arguments.of("a 2"), + Arguments.of("2 2"), + Arguments.of("3 3 "), + Arguments.of("-1 0"), + Arguments.of("5 -0"), + Arguments.of("3.5 1"), + Arguments.of("1 1.5") + + ); + } + +}