├── .gitignore ├── LICENSE ├── README.md ├── pom.xml └── src ├── main └── java │ └── ru │ ├── job4j │ ├── array │ │ ├── CrossArray.java │ │ ├── Merge.java │ │ └── Sorted.java │ ├── collection │ │ ├── Article.java │ │ └── Parentheses.java │ ├── first │ │ └── Task12.java │ ├── hash │ │ ├── Task3.java │ │ ├── Task4.java │ │ └── Task5.java │ ├── io │ │ └── Shell.java │ ├── map │ │ └── PutContainsKey.java │ ├── stream │ │ └── FlatIt.java │ └── type │ │ ├── IntType.java │ │ ├── ShortType.java │ │ └── Task9.java │ └── parsentev │ ├── task_001 │ ├── Calculator.java │ └── package-info.java │ ├── task_002 │ ├── Point.java │ └── package-info.java │ ├── task_003 │ ├── Triangle.java │ └── package-info.java │ ├── task_004 │ ├── IsoscelesTriangle.java │ └── package-info.java │ ├── task_005 │ ├── RightTriangle.java │ └── package-info.java │ ├── task_006 │ ├── Square.java │ └── package-info.java │ ├── task_007 │ ├── Expression.java │ └── package-info.java │ ├── task_008 │ ├── Primes.java │ └── package-info.java │ ├── task_009 │ ├── UniqueChars.java │ └── package-info.java │ ├── task_010 │ ├── Brackets.java │ └── package-info.java │ ├── task_011 │ ├── ArrayContainsOne.java │ └── package-info.java │ ├── task_012 │ ├── SequenceArray.java │ └── package-info.java │ ├── task_013 │ ├── MonoArray.java │ └── package-info.java │ ├── task_014 │ ├── ReversePhrase.java │ └── package-info.java │ ├── task_015 │ ├── CycleShift.java │ └── package-info.java │ ├── task_016 │ ├── TicTacToe.java │ └── package-info.java │ ├── task_017 │ ├── CashMachine.java │ └── package-info.java │ ├── task_018 │ ├── Pool.java │ └── package-info.java │ ├── task_019 │ ├── Maze.java │ └── package-info.java │ └── task_020 │ ├── Combine.java │ └── package-info.java └── test └── java └── ru ├── job4j ├── array │ ├── CrossArrayTest.java │ ├── MergeTest.java │ └── SortedTest.java ├── collection │ ├── ArticleTest.java │ └── ParenthesesTest.java ├── first │ └── Task12Test.java ├── hash │ ├── Task3Test.java │ ├── Task4Test.java │ └── Task5Test.java ├── io │ └── ShellTest.java ├── map │ └── PutContainsKeyTest.java ├── stream │ └── FlatItTest.java └── type │ ├── IntTypeTest.java │ ├── ShortTypeTest.java │ └── Task9Test.java └── parsentev ├── task_001 └── CalculatorTest.java ├── task_002 └── PointTest.java ├── task_003 └── TriangleTest.java ├── task_004 └── IsoscelesTriangleTest.java ├── task_005 └── RightTriangleTest.java ├── task_006 └── SquareTest.java ├── task_007 └── ExpressionTest.java ├── task_008 └── PrimesTest.java ├── task_009 └── UniqueCharsTest.java ├── task_010 └── BracketsTest.java ├── task_011 └── ArrayContainsOneTest.java ├── task_012 └── SequenceArrayTest.java ├── task_013 └── MonoArrayTest.java ├── task_014 └── ReversePhraseTest.java ├── task_015 └── CycleShiftTest.java ├── task_016 └── TicTacToeTest.java ├── task_017 └── CashMachineTest.java ├── task_018 └── PoolTest.java ├── task_019 └── MazeTest.java └── task_020 └── CombineTest.java /.gitignore: -------------------------------------------------------------------------------- 1 | *.class 2 | *.iml 3 | .idea 4 | .iml 5 | target 6 | 7 | # Mobile Tools for Java (J2ME) 8 | .mtj.tmp/ 9 | 10 | # Package Files # 11 | *.jar 12 | *.war 13 | *.ear 14 | 15 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 16 | hs_err_pid* 17 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016 Petr Arsentev 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Профессиональное тестирование по Java 2 | 3 | Цель курса 4 | ---------- 5 | 6 | Цель курса - проверить логические и алгоритмические способности ученика заниматься профессиональным программированием. 7 | Кандидаты, полностью выполнившие все задания могут смело продолжать изучать программирование, 8 | так как у них есть хороший потенциал стать высококвалифицированными разработчиками ПО. 9 | Кандидатам, которые испытывают сложности в выполнении данных задач, следует обратить внимание 10 | на смежные области разработки ПО, такие как: QA Automation, аналитик, функциональный программист, support. 11 | 12 | Описание 13 | -------- 14 | 15 | В курсе собраны 20 задач возрастающей сложности. Каждая задача состоит из подготовленного каркаса классов и 16 | полностью написанных автоматических тестов. То есть все задания будут автоматически проверены. 17 | В данном курсе используется подход TDD. Инструменты, необходимые для прохождения курса: Maven, Git, Java 8. 18 | 19 | Для получения исходного кода нужно выполнить команду: 20 | 21 | *git clone git@github.com:peterarsentev/course_test.git* 22 | 23 | Проект собрать через maven. Задания курса находятся в отдельных пакетах 24 | 25 | */src/main/java/ru/parsentev/task_XXX/package-info.java* 26 | 27 | а так же продублированы ниже. 28 | 29 | Ученик должен ознакомиться c заданием и перейти к реализации недостающего кода и классов. 30 | После завершения реализации ученик должен зайти в папку 31 | 32 | */src/test/java/ru/parsentev/task_XXX/* 33 | 34 | и в каждом классе убрать аннотацию 35 | 36 | *@Ignore* - это аннотация используется для игнорирования тестов. 37 | 38 | После этого ученик должен перейти в корень проекта и выполнить команду 39 | 40 | *mvn clean test* 41 | 42 | Система сборки должна успешно пройти все тесты. Если тесты упали - необходимо поправить ваш код. 43 | Код тестов править нельзя. 44 | 45 | В репозитории есть две ветки 46 | 47 | - master - каркас заданий с тестами. 48 | - solution - полностью выполненные задания с тестами. 49 | 50 | Смотреть решения рекомендуется после успешной реализации кода и успешно пройденных тестов. 51 | 52 | В качестве теоретического материала для подготовки к курсу следует прочитать следующие книги: 53 | 54 | *Head First Java, 2nd Edition: Kathy Sierra, Bert Bates* 55 | 56 | *Алгоритмы. Руководство по разработке, Стивен С. Скиена* 57 | 58 | Темы необходимые для прохождения курса. 59 | 60 | - Типы данных 61 | - Арифметические операции 62 | - Операторы условия 63 | - Циклы 64 | - Массивы 65 | - Наследование 66 | - Полиморфизм 67 | - Инкапсуляция 68 | - Исключения 69 | 70 | Задания 71 | ------- 72 | 73 | 1. Реализовать программу Calculator (калькулятор). Калькулятор должен выполнять операции: 74 | сложение, вычитание, умножение, деление, возведение в степень. 75 | При выполнении деления ввести проверку на 0. 76 | Если второй аргумент 0 - нужно выкинуть исключение java.lang.IllegalStateException 77 | 78 | 2. Реализовать класс Point (точка), описывающую точку в системе координат x, y - Point(x, y). 79 | Объект точка должен иметь методы double Point#distanceTo(Point point) - метод должен вычислять расстояние 80 | между двумя точками. 81 | 82 | 3. Реализовать класс Triangle (треугольник). Треугольник должен описываться через точки в системе координат. 83 | Объект треугольник должен иметь методы: 84 | boolean exists() - проверяет существует ли треугольник или нет. 85 | double area() - вычисляет площадь треугольника. 86 | Если треугольник не существует - выбросить исключение java.lang.IllegalStateException 87 | 88 | 4. Реализовать класс IsoscelesTriangle (равнобедренный треугольник) наследуя класс треугольник из задания 3. 89 | Дополнить поведение метода boolean exists() - true, если треугольник равнобедренный. 90 | Остальное поведение оставить прежним. 91 | 92 | 5. Реализовать класс RightTriangle (прямоугольный треугольник) наследуя класс треугольник из задания 3. 93 | Дополнить поведение метода boolean exists() - true, если треугольник равносторонний. 94 | Остальное поведение оставить прежним. 95 | 96 | 6. Реализовать класс Square (квадрат), основанный на четырех точках Point(x, y). 97 | boolean exists() - проверяет существует ли квадрат или нет. 98 | 99 | 7. Реализовать класс Expression. Класс должен принимать строку из просто математического выражения 100 | и методы double calc(). Должен поддерживать операции + - / * exp. 101 | Например, "2+2" - 4, "2-2" - 0 102 | Если выражение не корректное выбросить исключение java.lang.IllegalStateException 103 | 104 | 8. Реализовать класс вычисляющий простые числа в диапазоне от 1 до N. 105 | 106 | 9. Реализовать метод подсчета уникальных символов в строке. 107 | 108 | 10. Реализовать методы проверки корректности открытых и закрытых скобок. 109 | Например, ()(()((()))) - true, ()) - false. 110 | 111 | 11. Задан массив чисел со значениями 0 и 1. Нужно проверить, что все значения в массиве равны 1. 112 | Например, [0, 1] - false, [1, 1] - true. 113 | 114 | 12. Задан массив чисел со значениями 0 и 1. 115 | Нужно проверить, что в массиве есть последовательности из трех и больше единиц. 116 | Например, [0, 1, 1] - false, [1, 1, 1] - true. 117 | 118 | 13. Задан числовой массив. Нужно проверить, что все значения в массиве одинаковые. 119 | Например, [0, 0, 0] - true, [1, 1, 1] - true, [0, 1, 1] - false. 120 | 121 | 14. Задано предложение. Нужно переставить слова в обратно порядке. 122 | Например, "программируй и зарабатывай" -> "зарабатывай и программируй". 123 | 124 | 15. Задан числовой массив. Нужно реализовать метод кольцевого сдвига на N. int[] shift(). 125 | Не использовать дополнительный массив. 126 | Например, [1, 2, 3, 4, 5] - shift(2) - [4, 5, 1, 2, 3] 127 | 128 | 16. Задан квадратный массив. Нужно проверить, что в нем есть выигрышные варианты для игры крестики-нолики. 129 | 130 | 17. Реализован банкомат размена денег. Автомат принимает бумажную купюру и обменивает на монеты. 131 | Метод должен возвращать список всех возможных вариантов размены купюры. 132 | 133 | 18. Задан двумерный массив, заполненный нулями и единицами. Нужно определить самое большое множество единиц. 134 | Множеством считается объединение единиц, которые находятся рядом друг с другом по горизонтали и(или) вертикали. 135 | Если они находятся рядом по диагонали - такое нахождение не учитывать. 136 | 137 | 19. Задан двумерный массив из единиц и нулей. Нужно найти минимальный путь от точки А до точки В. 138 | Двигаться можно только по единицам и только в вниз или вправо. 139 | 140 | 20. Задан одномерный массив. Нужно найти все возможные варианты перестановок этого массива. 141 | 142 | 21. Задан список скриптов с указанием их зависимостей. 143 | 144 | 1 - [2, 3], 145 | 2 - [4], 146 | 3 - [4, 5], 147 | 4 - [], 148 | 5 - [] 149 | 150 | Необходимо написать метод, который возвращает список всех скриптов, 151 | которые нужны для загрузки входящего скрипта. 152 | 153 | Например, чтобы выполнить скрипт 1, нужно выполнить скрипт (2, 3), 154 | которые в свою очередь зависят от 4 и 5 скрипта. 155 | 156 | List load(Map ds, Integer scriptId) 157 | 158 | 22. Задан двухмерный массив. Массив заполнен числами. По массиву двигается робот. 159 | Робот может двигаться вниз, вверх и вправо. 160 | Задача начальная точка и конечная. Перемещение из одной клетки в другую затрачивает энергию. 161 | Рассчитывается она разность модуля значений клеток. 162 | Например, ход из клетки 1 в 10 будет оцениваться в 9 единиц. 163 | 164 | Необходимо написать метод, который определяет наименее трудозатратный путь. 165 | 166 | int optimalWay(int[][] board, int sx, int sy, int fx, int fy) 167 | 168 | [1, 2, 3] 169 | [1, 3, 6] 170 | [1, 1, 5] 171 | 172 | start (0, 0), finish (3, 3). Ответ: 4. Путь 1 1 1 1 5 173 | 174 | 23. Задан двухмерный массив. Массив заполнен нулями и единицами. Робот может ходить только по единицам. 175 | Задача начальная и конечная точка. Робот может ходить вверх, вних, влево и вправо. 176 | Необходимо найти минимальный путь до конечной точки. 177 | 178 | int minWay(int[][] board, int sx, int sy, int fx, int fy) 179 | -------------------------------------------------------------------------------- /pom.xml: -------------------------------------------------------------------------------- 1 | 3 | 4.0.0 4 | ru.job4j 5 | job4j_exercises 6 | jar 7 | 2.0 8 | job4j_exercises 9 | http://job4j.ru 10 | 11 | 12 | 18 13 | 18 14 | UTF-8 15 | 16 | 17 | 18 | 19 | org.slf4j 20 | slf4j-api 21 | 1.7.36 22 | 23 | 24 | junit 25 | junit 26 | 4.13.2 27 | test 28 | 29 | 30 | org.hamcrest 31 | hamcrest-all 32 | 1.3 33 | test 34 | 35 | 36 | 37 | 38 | 39 | 40 | org.apache.maven.plugins 41 | maven-compiler-plugin 42 | 3.3 43 | 44 | 18 45 | 46 | 47 | 48 | 49 | 50 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/array/CrossArray.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.array; 2 | 3 | public class CrossArray { 4 | public static void printCrossEl(int[] left, int[] right) { 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/array/Merge.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.array; 2 | 3 | public class Merge { 4 | public static int[] merge(int[] left, int[] right) { 5 | int[] rsl = new int[left.length + right.length]; 6 | return rsl; 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/array/Sorted.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.array; 2 | 3 | public class Sorted { 4 | public static boolean isSorted(int[] array) { 5 | return false; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/collection/Article.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.collection; 2 | 3 | public class Article { 4 | public static boolean generateBy(String origin, String line) { 5 | return false; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/collection/Parentheses.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.collection; 2 | 3 | public class Parentheses { 4 | public static boolean valid(char[] data) { 5 | return false; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/first/Task12.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.first; 2 | 3 | public class Task12 { 4 | public static void main(String[] args) { 5 | 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/hash/Task3.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.hash; 2 | 3 | import java.util.List; 4 | 5 | public class Task3 { 6 | public static List extractDuplicates(List left, List right) { 7 | return List.of(); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/hash/Task4.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.hash; 2 | 3 | import java.util.List; 4 | 5 | public class Task4 { 6 | public static List extractUnique(List left, List right) { 7 | return List.of(); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/hash/Task5.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.hash; 2 | 3 | import java.util.List; 4 | 5 | public class Task5 { 6 | public static List multiAssign(List tasks) { 7 | return List.of(); 8 | } 9 | 10 | public record Task(Integer taskId, Integer assignId) { 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/io/Shell.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.io; 2 | 3 | public class Shell { 4 | 5 | public void cd(String path) { 6 | } 7 | 8 | public String pwd() { 9 | return null; 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/map/PutContainsKey.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.map; 2 | 3 | import java.util.HashMap; 4 | import java.util.List; 5 | import java.util.Map; 6 | import java.util.Objects; 7 | 8 | public class PutContainsKey { 9 | 10 | public static Map addNewElementWithoutCheck(List list) { 11 | Map result = new HashMap<>(); 12 | for (User user : list) { 13 | result.put(user.id, user); 14 | } 15 | return result; 16 | } 17 | 18 | public static Map addNewElementWithCheck(List list) { 19 | Map result = new HashMap<>(); 20 | for (User user : list) { 21 | result.put(user.id, user); 22 | } 23 | return result; 24 | } 25 | 26 | public record User(int id, String name) { 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/stream/FlatIt.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.stream; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Iterator; 5 | import java.util.List; 6 | 7 | public class FlatIt { 8 | public static List flatten(Iterator> it) { 9 | return new ArrayList<>(); 10 | } 11 | 12 | public static void main(String[] args) { 13 | int rsl = "Patrova".compareTo("Petrov"); 14 | System.out.println(rsl); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/type/IntType.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.type; 2 | 3 | import java.util.Scanner; 4 | 5 | public class IntType { 6 | public static void main(String[] args) { 7 | Scanner in = new Scanner(System.in); 8 | int value = in.nextInt(); 9 | System.out.println(value); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/type/ShortType.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.type; 2 | 3 | import java.util.Scanner; 4 | 5 | public class ShortType { 6 | public static void main(String[] args) { 7 | Scanner in = new Scanner(System.in); 8 | int value = in.nextShort(); 9 | System.out.println(value); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/main/java/ru/job4j/type/Task9.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.type; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Task9 { 6 | public static void main(String[] args) { 7 | Scanner input = new Scanner(System.in); 8 | int a = input.nextInt(); 9 | int b = input.nextInt(); 10 | // YOUR CODE 11 | System.out.println(a + b); 12 | System.out.println(a - b); 13 | System.out.println(a * b); 14 | System.out.println(a / b); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_001/Calculator.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_001; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | 6 | import static org.slf4j.LoggerFactory.getLogger; 7 | 8 | /** 9 | * @author parsentev 10 | * @since 18.07.2016 11 | */ 12 | public class Calculator { 13 | private static final Logger log = getLogger(Calculator.class); 14 | 15 | public double getResult() { 16 | throw new UnsupportedOperationException(); 17 | } 18 | 19 | public void add(double first, double second) { 20 | throw new UnsupportedOperationException(); 21 | } 22 | 23 | public void substract(double first, double second) { 24 | throw new UnsupportedOperationException(); 25 | } 26 | 27 | public void multiple(double first, double second) { 28 | throw new UnsupportedOperationException(); 29 | } 30 | 31 | public void div(double first, double second) { 32 | throw new UnsupportedOperationException(); 33 | } 34 | 35 | public void expand(double first, double second) { 36 | throw new UnsupportedOperationException(); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_001/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Реализовать программу калькулятор. Калькулятор должен выполнять операции: 3 | * сложение, вычитание, умножение, деление, возведение в степень. 4 | * При выполнении деления ввести проверку на 0. 5 | * Если второй аргумент 0 нужно выкинуть исключение java.lang.IllegalStateException 6 | * 7 | * @author parsentev 8 | * @since 18.07.2016 9 | */ 10 | package ru.parsentev.task_001; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_002/Point.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_002; 2 | 3 | import org.slf4j.Logger; 4 | 5 | import static org.slf4j.LoggerFactory.getLogger; 6 | 7 | /** 8 | * Class Point defines a point in coordination system (x, y). 9 | * @author parsentev 10 | * @since 19.07.2016 11 | */ 12 | public class Point { 13 | private static final Logger log = getLogger(Point.class); 14 | 15 | private final int x; 16 | private final int y; 17 | 18 | public Point(final int x, final int y) { 19 | this.x = x; 20 | this.y = y; 21 | } 22 | 23 | public double distanceTo(final Point point) { 24 | throw new UnsupportedOperationException(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_002/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Реализовать класс точку, описывающую точку в системе координат x, y - Point(x, y). 3 | * объект точка должен иметь методы double Point#distanceTo(Point point) - метод должен вычислять расстояние 4 | * между двумя точками 5 | * 6 | * @author parsentev 7 | * @since 19.07.2016 8 | */ 9 | package ru.parsentev.task_002; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_003/Triangle.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_003; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | import ru.parsentev.task_002.Point; 6 | 7 | import static org.slf4j.LoggerFactory.getLogger; 8 | 9 | /** 10 | * TODO: comment 11 | * 12 | * @author parsentev 13 | * @since 28.07.2016 14 | */ 15 | public class Triangle { 16 | private static final Logger log = getLogger(Triangle.class); 17 | 18 | protected final Point first; 19 | protected final Point second; 20 | protected final Point third; 21 | 22 | public Triangle(final Point first, final Point second, final Point third) { 23 | this.first = first; 24 | this.second = second; 25 | this.third = third; 26 | } 27 | 28 | public boolean exists() { 29 | throw new UnsupportedOperationException(); 30 | } 31 | 32 | public double area() { 33 | throw new UnsupportedOperationException(); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_003/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Реализовать класс треугольник. Треугольник должен описываться через точки в системе координат. 3 | * Объект треугольник должен иметь методы: 4 | * boolean exists() - проверяет существует ли треугольник или нет. 5 | * double area() - вычисляет площадь треугольника. 6 | * Если треугольник не существует выбросить исключение java.lang.IllegalStateException 7 | * 8 | * @author parsentev 9 | * @since 19.07.2016 10 | */ 11 | package ru.parsentev.task_003; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_004/IsoscelesTriangle.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_004; 2 | 3 | import org.slf4j.Logger; 4 | import ru.parsentev.task_002.Point; 5 | import ru.parsentev.task_003.Triangle; 6 | 7 | import static org.slf4j.LoggerFactory.getLogger; 8 | 9 | /** 10 | * TODO: comment 11 | * 12 | * @author parsentev 13 | * @since 28.07.2016 14 | */ 15 | public class IsoscelesTriangle extends Triangle { 16 | private static final Logger log = getLogger(IsoscelesTriangle.class); 17 | 18 | public IsoscelesTriangle(Point first, Point second, Point third) { 19 | super(first, second, third); 20 | } 21 | 22 | @Override 23 | public boolean exists() { 24 | return super.exists(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_004/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Реализовать класс равнобедренный треугольник наследуя класс треугольник из задания 3. 3 | * Дополнить поведение метода boolean exists() - true, если треугольник равнобедренный. 4 | * Остальное поведение оставить прежним. 5 | * 6 | * @author parsentev 7 | * @since 19.07.2016 8 | */ 9 | package ru.parsentev.task_004; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_005/RightTriangle.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_005; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | import ru.parsentev.task_002.Point; 6 | import ru.parsentev.task_003.Triangle; 7 | 8 | import java.math.BigDecimal; 9 | import java.math.RoundingMode; 10 | 11 | import static java.lang.Math.abs; 12 | import static java.lang.Math.pow; 13 | import static java.lang.Math.sqrt; 14 | import static org.slf4j.LoggerFactory.getLogger; 15 | 16 | /** 17 | * TODO: comment 18 | * 19 | * @author parsentev 20 | * @since 28.07.2016 21 | */ 22 | public class RightTriangle extends Triangle { 23 | private static final Logger log = getLogger(RightTriangle.class); 24 | 25 | public RightTriangle(Point first, Point second, Point third) { 26 | super(first, second, third); 27 | } 28 | 29 | @Override 30 | public boolean exists() { 31 | return super.exists(); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_005/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Реализовать класс прямоугольный треугольник наследуя класс треугольник из задания 3. 3 | * Дополнить поведение метода boolean exists() - true, если треугольник прямоугольный. 4 | * Остальное поведение оставить прежним. 5 | * 6 | * @author parsentev 7 | * @since 19.07.2016 8 | */ 9 | package ru.parsentev.task_005; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_006/Square.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_006; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | import ru.parsentev.task_002.Point; 6 | 7 | import static org.slf4j.LoggerFactory.getLogger; 8 | 9 | /** 10 | * TODO: comment 11 | * 12 | * @author parsentev 13 | * @since 28.07.2016 14 | */ 15 | public class Square { 16 | private static final Logger log = getLogger(Square.class); 17 | 18 | private final Point first; 19 | private final Point second; 20 | private final Point third; 21 | private final Point fourth; 22 | 23 | public Square(final Point first, final Point second, final Point third, final Point fourth) { 24 | this.first = first; 25 | this.second = second; 26 | this.third = third; 27 | this.fourth = fourth; 28 | } 29 | 30 | public boolean exists() { 31 | throw new UnsupportedOperationException(); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_006/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Реализовать класс квадрат основанный на четырех точках Point(x, y). 3 | * boolean exists() - проверяет существует ли квадрат или нет. 4 | * 5 | * @author parsentev 6 | * @since 19.07.2016 7 | */ 8 | package ru.parsentev.task_006; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_007/Expression.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_007; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | 6 | import static org.slf4j.LoggerFactory.getLogger; 7 | 8 | /** 9 | * TODO: comment 10 | * 11 | * @author parsentev 12 | * @since 28.07.2016 13 | */ 14 | public class Expression { 15 | private static final Logger log = getLogger(Expression.class); 16 | 17 | private final String expr; 18 | 19 | public Expression(final String expr) { 20 | this.expr = expr; 21 | } 22 | 23 | public double calc() { 24 | throw new UnsupportedOperationException(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_007/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Реализовать класс Expression. Класс должен принимать строку из просто математического выражения 3 | * и методы double calc(). Должен поддерживать операции + - / * exp. 4 | * Например, "2+2" - 4, "2-2" - 0 5 | * Если выражение не корректное выбросить исключение java.lang.IllegalStateException 6 | * 7 | * @author parsentev 8 | * @since 19.07.2016 9 | */ 10 | package ru.parsentev.task_007; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_008/Primes.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_008; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | 6 | import java.util.List; 7 | 8 | import static org.slf4j.LoggerFactory.getLogger; 9 | 10 | /** 11 | * TODO: comment 12 | * 13 | * @author parsentev 14 | * @since 28.07.2016 15 | */ 16 | public class Primes { 17 | private static final Logger log = getLogger(Primes.class); 18 | 19 | private final int limit; 20 | 21 | public Primes(final int limit) { 22 | this.limit = limit; 23 | } 24 | 25 | public List calc() { 26 | throw new UnsupportedOperationException(); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_008/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Реализовать класс вычисляющий простые числа до N. 3 | * 4 | * @author parsentev 5 | * @since 19.07.2016 6 | */ 7 | package ru.parsentev.task_008; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_009/UniqueChars.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_009; 2 | 3 | /** 4 | * TODO: comment 5 | * 6 | * @author parsentev 7 | * @since 28.07.2016 8 | */ 9 | public class UniqueChars { 10 | private final String line; 11 | 12 | public UniqueChars(final String line) { 13 | this.line = line; 14 | } 15 | 16 | public int unique() { 17 | throw new UnsupportedOperationException(); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_009/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Реализовать метод подсчета уникальных символов в строке. 3 | * 4 | * @author parsentev 5 | * @since 19.07.2016 6 | */ 7 | package ru.parsentev.task_009; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_010/Brackets.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_010; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | import static org.slf4j.LoggerFactory.getLogger; 6 | 7 | /** 8 | * TODO: comment 9 | * 10 | * @author parsentev 11 | * @since 28.07.2016 12 | */ 13 | public class Brackets { 14 | private static final Logger log = getLogger(Brackets.class); 15 | private final String line; 16 | 17 | public Brackets(final String line) { 18 | this.line = line; 19 | } 20 | 21 | public boolean isCorrect() { 22 | throw new UnsupportedOperationException(); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_010/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Реализовать методы проверки корректности открытых и закрытых скобок. 3 | * Например, ()(()((()))) - true, ()) - false 4 | * 5 | * @author parsentev 6 | * @since 19.07.2016 7 | */ 8 | package ru.parsentev.task_010; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_011/ArrayContainsOne.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_011; 2 | 3 | import org.slf4j.Logger; 4 | 5 | import static org.slf4j.LoggerFactory.getLogger; 6 | 7 | /** 8 | * TODO: comment 9 | * 10 | * @author parsentev 11 | * @since 28.07.2016 12 | */ 13 | public class ArrayContainsOne { 14 | private static final Logger log = getLogger(ArrayContainsOne.class); 15 | private final int[] values; 16 | 17 | public ArrayContainsOne(final int[] values) { 18 | this.values = values; 19 | } 20 | 21 | public boolean containsOnlyOne() { 22 | throw new UnsupportedOperationException(); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_011/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Задан массив чисел со значениями 0 и 1. Нужно проверить, что все значения в массиве равны 1. 3 | * Например, [0, 1] - false, [1, 1] - true. 4 | * 5 | * @author parsentev 6 | * @since 19.07.2016 7 | */ 8 | package ru.parsentev.task_011; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_012/SequenceArray.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_012; 2 | 3 | import org.slf4j.Logger; 4 | 5 | import static org.slf4j.LoggerFactory.getLogger; 6 | 7 | /** 8 | * TODO: comment 9 | * 10 | * @author parsentev 11 | * @since 28.07.2016 12 | */ 13 | public class SequenceArray { 14 | private static final Logger log = getLogger(SequenceArray.class); 15 | 16 | private final int[] values; 17 | 18 | public SequenceArray(final int[] values) { 19 | this.values = values; 20 | } 21 | 22 | public boolean containsOneSequence() { 23 | throw new UnsupportedOperationException(); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_012/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Задан массив чисел со значениями 0 и 1. 3 | * Нужно проверить, что в массиве есть последовательности из трех и больше единиц. 4 | * Например, [0, 1, 1] - false, [1, 1, 1] - true, 5 | * 6 | * @author parsentev 7 | * @since 19.07.2016 8 | */ 9 | package ru.parsentev.task_012; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_013/MonoArray.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_013; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | 6 | import static org.slf4j.LoggerFactory.getLogger; 7 | 8 | /** 9 | * TODO: comment 10 | * 11 | * @author parsentev 12 | * @since 28.07.2016 13 | */ 14 | public class MonoArray { 15 | private static final Logger log = getLogger(MonoArray.class); 16 | 17 | private final int[] values; 18 | 19 | public MonoArray(final int[] values) { 20 | this.values = values; 21 | } 22 | 23 | public boolean exists() { 24 | throw new UnsupportedOperationException(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_013/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Задан числовой массив. Нужно проверить, что все значения в массиве одинаковые. 3 | * Например, [0, 0, 0] - true, [1, 1, 1] - true, [0, 1, 1] - false. 4 | * 5 | * @author parsentev 6 | * @since 19.07.2016 7 | */ 8 | package ru.parsentev.task_013; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_014/ReversePhrase.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_014; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | 6 | import static org.slf4j.LoggerFactory.getLogger; 7 | 8 | /** 9 | * TODO: comment 10 | * 11 | * @author parsentev 12 | * @since 28.07.2016 13 | */ 14 | public class ReversePhrase { 15 | private static final Logger log = getLogger(ReversePhrase.class); 16 | private final String line; 17 | 18 | public ReversePhrase(final String line) { 19 | this.line = line; 20 | } 21 | 22 | public String reverse() { 23 | throw new UnsupportedOperationException(); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_014/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Задано предложение. Нужно переставить слова в обратно порядке. 3 | * Например, "программируй и зарабатывай" -> "зарабатывай и программируй" 4 | * 5 | * @author parsentev 6 | * @since 19.07.2016 7 | */ 8 | package ru.parsentev.task_014; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_015/CycleShift.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_015; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | 6 | import static org.slf4j.LoggerFactory.getLogger; 7 | 8 | /** 9 | * TODO: comment 10 | * 11 | * @author parsentev 12 | * @since 28.07.2016 13 | */ 14 | public class CycleShift { 15 | private static final Logger log = getLogger(CycleShift.class); 16 | 17 | private final int[] values; 18 | 19 | public CycleShift(final int[] values) { 20 | this.values = values; 21 | } 22 | 23 | public int[] shift(int position) { 24 | throw new UnsupportedOperationException(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_015/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Задан числовой массив. Нужно реализовать метод кольцевого двига на N. int[] shift(). 3 | * Не использовать дополнительный массив. 4 | * Например, [1, 2, 3, 4, 5] - shift(2) - [4, 5, 1, 2, 3] 5 | * 6 | * @author parsentev 7 | * @since 19.07.2016 8 | */ 9 | package ru.parsentev.task_015; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_016/TicTacToe.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_016; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | 6 | import static org.slf4j.LoggerFactory.getLogger; 7 | 8 | /** 9 | * TODO: comment 10 | * 11 | * @author parsentev 12 | * @since 28.07.2016 13 | */ 14 | public class TicTacToe { 15 | private static final Logger log = getLogger(TicTacToe.class); 16 | 17 | private final int[][] values; 18 | 19 | public TicTacToe(final int[][] values) { 20 | this.values = values; 21 | } 22 | 23 | public boolean hasWinner() { 24 | throw new UnsupportedOperationException(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_016/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Задан квадратный массив. Нужно проверить, что в нем есть выигрышные варианты для игры крестики-нолики. 3 | * 4 | * @author parsentev 5 | * @since 19.07.2016 6 | */ 7 | package ru.parsentev.task_016; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_017/CashMachine.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_017; 2 | 3 | import org.slf4j.Logger; 4 | 5 | import java.util.List; 6 | 7 | import static org.slf4j.LoggerFactory.getLogger; 8 | 9 | /** 10 | * TODO: comment 11 | * 12 | * @author parsentev 13 | * @since 28.07.2016 14 | */ 15 | public class CashMachine { 16 | private static final Logger log = getLogger(CashMachine.class); 17 | 18 | private final int[] values; 19 | 20 | public CashMachine(final int[] values) { 21 | this.values = values; 22 | } 23 | 24 | public List> exchange(int note) { 25 | throw new UnsupportedOperationException(); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_017/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Реализован банкомат размена денег. Автомат принимает бумажную купюру и обменивает на монеты. 3 | * Метод должен возвращать список всех возможных вариантов размены купюры. 4 | * 5 | * @author parsentev 6 | * @since 19.07.2016 7 | */ 8 | package ru.parsentev.task_017; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_018/Pool.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_018; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | 6 | import static org.slf4j.LoggerFactory.getLogger; 7 | 8 | /** 9 | * TODO: comment 10 | * 11 | * @author parsentev 12 | * @since 28.07.2016 13 | */ 14 | public class Pool { 15 | private static final Logger log = getLogger(Pool.class); 16 | 17 | private final int[][] values; 18 | 19 | public Pool(final int[][] values) { 20 | this.values = values; 21 | } 22 | 23 | public int maxUnion() { 24 | throw new UnsupportedOperationException(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_018/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Задан двойной массив, заполненный нулями и единицами. Нужно определить самое большое множество единиц. 3 | * Множеством считается объединение единиц, которые соприкасаются друг с другом. 4 | * Диагональное соприкосновение не учитывать. 5 | * 6 | * @author parsentev 7 | * @since 19.07.2016 8 | */ 9 | package ru.parsentev.task_018; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_019/Maze.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_019; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | import ru.parsentev.task_002.Point; 6 | 7 | import java.util.List; 8 | 9 | import static org.slf4j.LoggerFactory.getLogger; 10 | 11 | /** 12 | * TODO: comment 13 | * 14 | * @author parsentev 15 | * @since 28.07.2016 16 | */ 17 | public class Maze { 18 | private static final Logger log = getLogger(Maze.class); 19 | 20 | private final int[][] values; 21 | 22 | public Maze(final int[][] values) { 23 | this.values = values; 24 | } 25 | 26 | public List solution(Point start, Point finish) { 27 | throw new UnsupportedOperationException(); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_019/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Задан двойной массив из единиц и нулей. Нужно найти минимальный путь от точки А до точки В. 3 | * Двигаться можно только по единицам и только по вертикали или горизонтали. 4 | * 5 | * @author parsentev 6 | * @since 19.07.2016 7 | */ 8 | package ru.parsentev.task_019; -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_020/Combine.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_020; 2 | 3 | import org.slf4j.Logger; 4 | import org.slf4j.LoggerFactory; 5 | 6 | import java.util.List; 7 | 8 | import static org.slf4j.LoggerFactory.getLogger; 9 | 10 | /** 11 | * TODO: comment 12 | * 13 | * @author parsentev 14 | * @since 28.07.2016 15 | */ 16 | public class Combine { 17 | private static final Logger log = getLogger(Combine.class); 18 | 19 | private final int[] values; 20 | 21 | public Combine(final int[] values) { 22 | this.values = values; 23 | } 24 | 25 | public List> generate() { 26 | throw new UnsupportedOperationException(); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/main/java/ru/parsentev/task_020/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Задан одномерный массив. Нужно найти все возможные варианты перестановок этого массива. 3 | * 4 | * @author parsentev 5 | * @since 19.07.2016 6 | */ 7 | package ru.parsentev.task_020; -------------------------------------------------------------------------------- /src/test/java/ru/job4j/array/CrossArrayTest.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.array; 2 | 3 | import org.junit.Test; 4 | 5 | import java.io.ByteArrayOutputStream; 6 | import java.io.PrintStream; 7 | 8 | import static org.hamcrest.CoreMatchers.is; 9 | import static org.junit.Assert.*; 10 | 11 | public class CrossArrayTest { 12 | 13 | @Test 14 | public void whenHasCross() { 15 | ByteArrayOutputStream out = new ByteArrayOutputStream(); 16 | System.setOut(new PrintStream(out)); 17 | CrossArray.printCrossEl( 18 | new int[] {1, 3}, 19 | new int[] {2, 1} 20 | ); 21 | assertThat(out.toString(), is("1" + System.lineSeparator())); 22 | } 23 | 24 | @Test 25 | public void whenNotCross() { 26 | ByteArrayOutputStream out = new ByteArrayOutputStream(); 27 | System.setOut(new PrintStream(out)); 28 | CrossArray.printCrossEl( 29 | new int[] {1, 2}, 30 | new int[] {3, 4} 31 | ); 32 | assertThat(out.toString(), is("")); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/test/java/ru/job4j/array/MergeTest.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.array; 2 | 3 | import org.junit.Test; 4 | 5 | import static org.hamcrest.CoreMatchers.is; 6 | import static org.junit.Assert.*; 7 | 8 | public class MergeTest { 9 | 10 | @Test 11 | public void whenBothEmpty() { 12 | int[] expect = new int[0]; 13 | int[] result = Merge.merge( 14 | new int[0], 15 | new int[0] 16 | ); 17 | assertThat(result, is(expect)); 18 | } 19 | 20 | @Test 21 | public void whenAscOrder() { 22 | int[] expect = {1, 2, 3, 4}; 23 | int[] result = Merge.merge( 24 | new int[] {1, 2}, 25 | new int[] {3, 4} 26 | ); 27 | assertThat(result, is(expect)); 28 | } 29 | 30 | @Test 31 | public void whenLeftLess() { 32 | int[] expect = {1, 2, 3, 3, 4}; 33 | int[] result = Merge.merge( 34 | new int[] {1, 2, 3}, 35 | new int[] {3, 4} 36 | ); 37 | assertThat(result, is(expect)); 38 | } 39 | 40 | @Test 41 | public void whenLeftGreat() { 42 | int[] expect = {1, 2, 3, 4, 4}; 43 | int[] result = Merge.merge( 44 | new int[] {1, 2}, 45 | new int[] {3, 4, 4} 46 | ); 47 | assertThat(result, is(expect)); 48 | } 49 | 50 | @Test 51 | public void whenLeftEmpty() { 52 | int[] expect = {1, 2, 3, 4}; 53 | int[] result = Merge.merge( 54 | new int[] {}, 55 | new int[] {1, 2, 3, 4} 56 | ); 57 | assertThat(result, is(expect)); 58 | } 59 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/array/SortedTest.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.array; 2 | 3 | import org.junit.Test; 4 | 5 | import static org.hamcrest.CoreMatchers.is; 6 | import static org.junit.Assert.*; 7 | 8 | public class SortedTest { 9 | 10 | @Test 11 | public void whenSorted() { 12 | assertThat( 13 | Sorted.isSorted( 14 | new int[] {1, 2, 3} 15 | ), 16 | is(true) 17 | ); 18 | } 19 | 20 | @Test 21 | public void whenNotSorted() { 22 | assertThat( 23 | Sorted.isSorted( 24 | new int[] {1, 3, 2} 25 | ), 26 | is(false) 27 | ); 28 | } 29 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/collection/ArticleTest.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.collection; 2 | 3 | import org.junit.Test; 4 | 5 | import static org.hamcrest.CoreMatchers.is; 6 | import static org.junit.Assert.*; 7 | 8 | public class ArticleTest { 9 | 10 | @Test 11 | public void whenLineGnrTrue() { 12 | assertThat( 13 | Article.generateBy( 14 | "Мама мыла раму и окно", 15 | "мыла окно" 16 | ), 17 | is(true) 18 | ); 19 | } 20 | 21 | @Test 22 | public void whenLineGnrFalse() { 23 | assertThat( 24 | Article.generateBy( 25 | "Мама мыла раму и окно", 26 | "мыла пол" 27 | ), 28 | is(false) 29 | ); 30 | } 31 | 32 | @Test 33 | public void whenLongTextTrue() { 34 | assertThat( 35 | Article.generateBy( 36 | "Мой дядя самых честных правил, " + 37 | "Когда не в шутку занемог, " + 38 | "Он уважать себя заставил " + 39 | "И лучше выдумать не мог. " + 40 | "Его пример другим наука; " + 41 | "Но, боже мой, какая скука " + 42 | "С больным сидеть и день и ночь, " + 43 | "Не отходя ни шагу прочь! " + 44 | "Какое низкое коварство " + 45 | "Полуживого забавлять, " + 46 | "Ему подушки поправлять, " + 47 | "Печально подносить лекарство, " + 48 | "Вздыхать и думать про себя: " + 49 | "Когда же черт возьмет тебя!", 50 | "Мой дядя мог думать про тебя и день и ночь" 51 | ), 52 | is(true) 53 | ); 54 | } 55 | @Test 56 | public void whenLongTextFalse() { 57 | assertThat( 58 | Article.generateBy( 59 | "Мой дядя самых честных правил, " + 60 | "Когда не в шутку занемог, " + 61 | "Он уважать себя заставил " + 62 | "И лучше выдумать не мог. " + 63 | "Его пример другим наука; " + 64 | "Но, боже мой, какая скука " + 65 | "С больным сидеть и день и ночь, " + 66 | "Не отходя ни шагу прочь! " + 67 | "Какое низкое коварство " + 68 | "Полуживого забавлять, " + 69 | "Ему подушки поправлять, " + 70 | "Печально подносить лекарство, " + 71 | "Вздыхать и думать про себя: " + 72 | "Когда же черт возьмет тебя!", 73 | "Мой дядя мог думать про Linux и Java день и ночь" 74 | ), 75 | is(false) 76 | ); 77 | } 78 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/collection/ParenthesesTest.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.collection; 2 | 3 | import org.junit.Test; 4 | 5 | import static org.hamcrest.core.Is.is; 6 | import static org.junit.Assert.*; 7 | 8 | public class ParenthesesTest { 9 | 10 | @Test 11 | public void whenValidInner() { 12 | assertThat( 13 | Parentheses.valid(new char[] {'(', '(', ')', ')'}), 14 | is(true) 15 | ); 16 | } 17 | 18 | @Test 19 | public void whenValidSeq() { 20 | assertThat( 21 | Parentheses.valid(new char[] {'(', ')', '(', ')'}), 22 | is(true) 23 | ); 24 | } 25 | 26 | @Test 27 | public void whenInValidInner() { 28 | assertThat( 29 | Parentheses.valid(new char[] {')', ')', '(', '('}), 30 | is(false) 31 | ); 32 | } 33 | 34 | @Test 35 | public void whenInValidSeq() { 36 | assertThat( 37 | Parentheses.valid(new char[] {'(', ')', '(', '('}), 38 | is(false) 39 | ); 40 | } 41 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/first/Task12Test.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.first; 2 | 3 | import static org.hamcrest.MatcherAssert.assertThat; 4 | import static org.hamcrest.Matchers.is; 5 | import org.junit.Test; 6 | import java.io.ByteArrayOutputStream; 7 | import java.io.PrintStream; 8 | import java.util.StringJoiner; 9 | 10 | public class Task12Test { 11 | @Test 12 | public void checkOutHelloJob4j() { 13 | ByteArrayOutputStream out = new ByteArrayOutputStream(); 14 | System.setOut(new PrintStream(out)); 15 | Task12.main(null); 16 | String expected = new StringJoiner( 17 | System.lineSeparator(), "", System.lineSeparator() 18 | ).add("Ping").add("Pong").toString(); 19 | assertThat(out.toString(), is(expected)); 20 | } 21 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/hash/Task3Test.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.hash; 2 | 3 | import org.junit.Test; 4 | 5 | import java.util.List; 6 | 7 | import static org.hamcrest.CoreMatchers.is; 8 | import static org.junit.Assert.*; 9 | 10 | public class Task3Test { 11 | 12 | @Test 13 | public void whenNoDuplicate() { 14 | var right = List.of(1, 2, 3); 15 | var left = List.of(4, 5, 6); 16 | var expected = List.of(); 17 | var result = Task3.extractDuplicates(left, right); 18 | assertThat(result, is(expected)); 19 | } 20 | 21 | @Test 22 | public void whenFullDuplicate() { 23 | var right = List.of(1, 2, 3); 24 | var left = List.of(1, 2, 3); 25 | var expected = List.of(1, 2, 3); 26 | var result = Task3.extractDuplicates(left, right); 27 | assertThat(result, is(expected)); 28 | } 29 | 30 | @Test 31 | public void whenLeftDuplicate() { 32 | var right = List.of(1, 2, 3); 33 | var left = List.of(1, 2, 3, 4, 5, 6); 34 | var expected = List.of(1, 2, 3); 35 | var result = Task3.extractDuplicates(left, right); 36 | assertThat(result, is(expected)); 37 | } 38 | 39 | @Test 40 | public void whenRightDuplicate() { 41 | var right = List.of(1, 2, 3, 4, 5, 6); 42 | var left = List.of(1, 2, 3); 43 | var expected = List.of(1, 2, 3); 44 | var result = Task3.extractDuplicates(left, right); 45 | assertThat(result, is(expected)); 46 | } 47 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/hash/Task4Test.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.hash; 2 | 3 | import org.junit.Test; 4 | 5 | import java.util.List; 6 | 7 | import static org.hamcrest.CoreMatchers.is; 8 | import static org.junit.Assert.*; 9 | 10 | public class Task4Test { 11 | 12 | @Test 13 | public void whenNoUnique() { 14 | var right = List.of(1, 2, 3); 15 | var left = List.of(1, 2, 3); 16 | var expected = List.of(); 17 | var result = Task4.extractUnique(left, right); 18 | assertThat(result, is(expected)); 19 | } 20 | 21 | @Test 22 | public void whenFullUnique() { 23 | var right = List.of(1, 2, 3); 24 | var left = List.of(4, 5, 6); 25 | var expected = List.of(1, 2, 3, 4, 5, 6); 26 | var result = Task4.extractUnique(left, right); 27 | assertThat(result, is(expected)); 28 | } 29 | 30 | @Test 31 | public void whenLeftDuplicate() { 32 | var right = List.of(1, 2, 3); 33 | var left = List.of(1, 2, 3, 4, 5, 6); 34 | var expected = List.of(4, 5, 6); 35 | var result = Task4.extractUnique(left, right); 36 | assertThat(result, is(expected)); 37 | } 38 | 39 | @Test 40 | public void whenRightDuplicate() { 41 | var right = List.of(1, 2, 3, 4, 5, 6); 42 | var left = List.of(1, 2, 3); 43 | var expected = List.of(4, 5, 6); 44 | var result = Task4.extractUnique(left, right); 45 | assertThat(result, is(expected)); 46 | } 47 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/hash/Task5Test.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.hash; 2 | 3 | import org.junit.Test; 4 | 5 | import java.util.List; 6 | 7 | import static org.hamcrest.CoreMatchers.is; 8 | import static org.junit.Assert.*; 9 | 10 | public class Task5Test { 11 | @Test 12 | public void whenMulti() { 13 | var input = List.of( 14 | new Task5.Task(1, 1), 15 | new Task5.Task(1, 2), 16 | new Task5.Task(1, 1) 17 | ); 18 | var expected = List.of(1); 19 | var result = Task5.multiAssign(input); 20 | assertThat(result, is(expected)); 21 | } 22 | 23 | @Test 24 | public void whenOnlyUnique() { 25 | var input = List.of( 26 | new Task5.Task(1, 1), 27 | new Task5.Task(1, 2), 28 | new Task5.Task(1, 3) 29 | ); 30 | var expected = List.of(); 31 | var result = Task5.multiAssign(input); 32 | assertThat(result, is(expected)); 33 | } 34 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/io/ShellTest.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.io; 2 | 3 | import org.junit.Test; 4 | 5 | import static org.hamcrest.CoreMatchers.is; 6 | import static org.junit.Assert.*; 7 | 8 | public class ShellTest { 9 | 10 | @Test 11 | public void whenCdBack() { 12 | Shell shell = new Shell(); 13 | shell.cd("/user/.."); 14 | assertThat( 15 | shell.pwd(), is("/") 16 | ); 17 | } 18 | 19 | @Test 20 | public void whenCdRoot() { 21 | Shell shell = new Shell(); 22 | shell.cd("/"); 23 | assertThat( 24 | shell.pwd(), is("/") 25 | ); 26 | } 27 | 28 | @Test 29 | public void whenCdUserLocal() { 30 | Shell shell = new Shell(); 31 | shell.cd("user"); 32 | shell.cd("local"); 33 | assertThat( 34 | shell.pwd(), is("/user/local") 35 | ); 36 | } 37 | 38 | @Test 39 | public void whenCdUserBack() { 40 | Shell shell = new Shell(); 41 | shell.cd("user"); 42 | shell.cd(".."); 43 | assertThat( 44 | shell.pwd(), is("/") 45 | ); 46 | } 47 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/map/PutContainsKeyTest.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.map; 2 | 3 | import org.junit.Test; 4 | 5 | import static org.hamcrest.core.Is.is; 6 | import static org.junit.Assert.*; 7 | 8 | import ru.job4j.map.PutContainsKey.User; 9 | 10 | import java.util.List; 11 | import java.util.Map; 12 | 13 | public class PutContainsKeyTest { 14 | @Test 15 | public void addNewElement() { 16 | User one = new User(1, "Name1"); 17 | User two = new User(2, "Name2"); 18 | User three = new User(1, "Name3"); 19 | List list = List.of(one, two, three); 20 | Map map = PutContainsKey.addNewElementWithCheck(list); 21 | Map expected = Map.of(1, one, 2, two); 22 | assertThat(map, is(expected)); 23 | } 24 | 25 | @Test 26 | public void addNewElementWithoutCheck() { 27 | User one = new User(1, "Name1"); 28 | User two = new User(2, "Name2"); 29 | User three = new User(1, "Name3"); 30 | List list = List.of(one, two, three); 31 | Map map = PutContainsKey.addNewElementWithoutCheck(list); 32 | Map expected = Map.of(1, three, 2, two); 33 | assertThat(map, is(expected)); 34 | } 35 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/stream/FlatItTest.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.stream; 2 | 3 | import org.junit.Test; 4 | import java.util.Iterator; 5 | import java.util.List; 6 | import static org.junit.Assert.*; 7 | import static org.hamcrest.core.Is.is; 8 | 9 | public class FlatItTest { 10 | 11 | @Test 12 | public void whenIt() { 13 | Iterator> it = List.of( 14 | List.of(1).iterator(), 15 | List.of(2, 3).iterator() 16 | ).iterator(); 17 | assertThat( 18 | FlatIt.flatten(it), 19 | is(List.of(1, 2, 3)) 20 | ); 21 | } 22 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/type/IntTypeTest.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.type; 2 | 3 | import org.junit.Test; 4 | 5 | import java.io.ByteArrayInputStream; 6 | import java.io.ByteArrayOutputStream; 7 | import java.io.PrintStream; 8 | 9 | import static org.hamcrest.CoreMatchers.is; 10 | import static org.junit.Assert.*; 11 | 12 | public class IntTypeTest { 13 | 14 | @Test 15 | public void whenEnter4() { 16 | ByteArrayInputStream in = new ByteArrayInputStream("4".getBytes()); 17 | ByteArrayOutputStream out = new ByteArrayOutputStream(); 18 | System.setOut(new PrintStream(out)); 19 | System.setIn(in); 20 | IntType.main(null); 21 | assertThat(out.toString(), is("4" + System.lineSeparator())); 22 | } 23 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/type/ShortTypeTest.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.type; 2 | 3 | import org.junit.Test; 4 | 5 | import java.io.ByteArrayInputStream; 6 | import java.io.ByteArrayOutputStream; 7 | import java.io.PrintStream; 8 | 9 | import static org.hamcrest.CoreMatchers.is; 10 | import static org.junit.Assert.assertThat; 11 | 12 | public class ShortTypeTest { 13 | 14 | @Test 15 | public void whenEnter4() { 16 | ByteArrayInputStream in = new ByteArrayInputStream("4".getBytes()); 17 | ByteArrayOutputStream out = new ByteArrayOutputStream(); 18 | System.setOut(new PrintStream(out)); 19 | System.setIn(in); 20 | ShortType.main(null); 21 | assertThat(out.toString(), is("4" + System.lineSeparator())); 22 | } 23 | 24 | @Test 25 | public void whenEnter5() { 26 | ByteArrayInputStream in = new ByteArrayInputStream("5".getBytes()); 27 | ByteArrayOutputStream out = new ByteArrayOutputStream(); 28 | System.setOut(new PrintStream(out)); 29 | System.setIn(in); 30 | ShortType.main(null); 31 | assertThat(out.toString(), is("5" + System.lineSeparator())); 32 | } 33 | } -------------------------------------------------------------------------------- /src/test/java/ru/job4j/type/Task9Test.java: -------------------------------------------------------------------------------- 1 | package ru.job4j.type; 2 | 3 | import org.junit.Test; 4 | 5 | import java.io.ByteArrayInputStream; 6 | import java.io.ByteArrayOutputStream; 7 | import java.io.PrintStream; 8 | import java.util.StringJoiner; 9 | 10 | import static org.hamcrest.MatcherAssert.assertThat; 11 | import static org.hamcrest.Matchers.is; 12 | 13 | public class Task9Test { 14 | 15 | @Test 16 | public void when1And1() { 17 | ByteArrayInputStream in = new ByteArrayInputStream("1 1".getBytes()); 18 | ByteArrayOutputStream out = new ByteArrayOutputStream(); 19 | System.setOut(new PrintStream(out)); 20 | System.setIn(in); 21 | Task9.main(null); 22 | StringJoiner expect = new StringJoiner( 23 | System.lineSeparator(), "", System.lineSeparator()) 24 | .add("2").add("0").add("1").add("1"); 25 | assertThat(out.toString(), is(expect.toString())); 26 | } 27 | 28 | @Test 29 | public void when2And2() { 30 | ByteArrayInputStream in = new ByteArrayInputStream("2 2".getBytes()); 31 | ByteArrayOutputStream out = new ByteArrayOutputStream(); 32 | System.setOut(new PrintStream(out)); 33 | System.setIn(in); 34 | Task9.main(null); 35 | StringJoiner expect = new StringJoiner( 36 | System.lineSeparator(), "", System.lineSeparator()) 37 | .add("4").add("0").add("4").add("1"); 38 | assertThat(out.toString(), is(expect.toString())); 39 | } 40 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_001/CalculatorTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_001; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | 6 | import static org.hamcrest.core.Is.is; 7 | import static org.junit.Assert.*; 8 | 9 | /** 10 | * @author parsentev 11 | * @since 19.07.2016 12 | */ 13 | @Ignore 14 | public class CalculatorTest { 15 | 16 | @Test 17 | public void whenAddOneOnOneThenResultTwo() throws Exception { 18 | Calculator calc = new Calculator(); 19 | calc.add(1d, 1d); 20 | assertThat(calc.getResult(), is(2d)); 21 | } 22 | 23 | @Test 24 | public void whenSubstractOneOnOneThenResultZero() throws Exception { 25 | Calculator calc = new Calculator(); 26 | calc.substract(1d, 1d); 27 | assertThat(calc.getResult(), is(0d)); 28 | } 29 | 30 | @Test 31 | public void whenMultipleOneOnOneThenResultOne() throws Exception { 32 | Calculator calc = new Calculator(); 33 | calc.multiple(1d, 1d); 34 | assertThat(calc.getResult(), is(1d)); 35 | } 36 | 37 | @Test 38 | public void whenDivOneOnOneThenResultOne() throws Exception { 39 | Calculator calc = new Calculator(); 40 | calc.div(1d, 1d); 41 | assertThat(calc.getResult(), is(1d)); 42 | } 43 | 44 | @Test(expected = IllegalStateException.class) 45 | public void whenDivByZeroThenException() throws Exception { 46 | Calculator calc = new Calculator(); 47 | calc.div(1d, 0d); 48 | } 49 | 50 | @Test 51 | public void whenExpandOneOnOneThenResultOne() throws Exception { 52 | Calculator calc = new Calculator(); 53 | calc.expand(1d, 1d); 54 | assertThat(calc.getResult(), is(1d)); 55 | } 56 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_002/PointTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_002; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | 6 | import static org.hamcrest.core.Is.is; 7 | import static org.junit.Assert.*; 8 | 9 | /** 10 | * TODO: comment 11 | * 12 | * @author parsentev 13 | * @since 28.07.2016 14 | */ 15 | @Ignore 16 | public class PointTest { 17 | @Test 18 | public void whenHasTwoPointThenReturnDistance() { 19 | final Point first = new Point(0, 0); 20 | final Point second = new Point(0, 1); 21 | double result = first.distanceTo(second); 22 | assertThat(result, is(1d)); 23 | } 24 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_003/TriangleTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_003; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import ru.parsentev.task_002.Point; 6 | 7 | import static org.hamcrest.core.Is.is; 8 | import static org.junit.Assert.*; 9 | 10 | /** 11 | * TODO: comment 12 | * 13 | * @author parsentev 14 | * @since 28.07.2016 15 | */ 16 | @Ignore 17 | public class TriangleTest { 18 | @Test 19 | public void calculateArea() { 20 | Point first = new Point(0, 0); 21 | Point second = new Point(0, 2); 22 | Point third = new Point(2, 0); 23 | double result = new Triangle(first, second, third).area(); 24 | assertThat(result, is(2d)); 25 | } 26 | 27 | @Test 28 | public void checkExists() { 29 | Point first = new Point(0, 0); 30 | Point second = new Point(0, 2); 31 | Point third = new Point(2, 0); 32 | boolean result = new Triangle(first, second, third).exists(); 33 | assertThat(result, is(true)); 34 | } 35 | 36 | @Test 37 | public void notExist() { 38 | Point first = new Point(0, 0); 39 | Point second = new Point(0, 2); 40 | Point third = new Point(0, 4); 41 | boolean result = new Triangle(first, second, third).exists(); 42 | assertThat(result, is(false)); 43 | } 44 | 45 | @Test(expected = IllegalStateException.class) 46 | public void inLine() { 47 | Point first = new Point(0, 0); 48 | Point second = new Point(0, 2); 49 | Point third = new Point(0, 4); 50 | new Triangle(first, second, third).area(); 51 | } 52 | 53 | @Test(expected = IllegalStateException.class) 54 | public void inPoint() { 55 | Point first = new Point(0, 0); 56 | Point second = new Point(0, 0); 57 | Point third = new Point(0, 0); 58 | new Triangle(first, second, third).area(); 59 | } 60 | 61 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_004/IsoscelesTriangleTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_004; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import ru.parsentev.task_002.Point; 6 | import ru.parsentev.task_003.Triangle; 7 | 8 | import static org.hamcrest.core.Is.is; 9 | import static org.junit.Assert.*; 10 | 11 | /** 12 | * TODO: comment 13 | * 14 | * @author parsentev 15 | * @since 28.07.2016 16 | */ 17 | @Ignore 18 | public class IsoscelesTriangleTest { 19 | 20 | @Test 21 | public void checkExists() { 22 | Point first = new Point(0, 0); 23 | Point second = new Point(0, 2); 24 | Point third = new Point(2, 0); 25 | boolean result = new IsoscelesTriangle(first, second, third).exists(); 26 | assertThat(result, is(true)); 27 | } 28 | 29 | @Test 30 | public void inLine() { 31 | Point first = new Point(0, 0); 32 | Point second = new Point(0, 2); 33 | Point third = new Point(0, 4); 34 | boolean result = new IsoscelesTriangle(first, second, third).exists(); 35 | assertThat(result, is(false)); 36 | } 37 | 38 | @Test 39 | public void notIsosceles() { 40 | Point first = new Point(0, 0); 41 | Point second = new Point(2, 0); 42 | Point third = new Point(0, 5); 43 | boolean result = new IsoscelesTriangle(first, second, third).exists(); 44 | assertThat(result, is(false)); 45 | } 46 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_005/RightTriangleTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_005; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import ru.parsentev.task_002.Point; 6 | import ru.parsentev.task_004.IsoscelesTriangle; 7 | 8 | import static org.hamcrest.core.Is.is; 9 | import static org.junit.Assert.*; 10 | 11 | /** 12 | * TODO: comment 13 | * 14 | * @author parsentev 15 | * @since 28.07.2016 16 | */ 17 | @Ignore 18 | public class RightTriangleTest { 19 | @Test 20 | public void checkExists() { 21 | Point first = new Point(0, 0); 22 | Point second = new Point(0, 2); 23 | Point third = new Point(2, 0); 24 | boolean result = new RightTriangle(first, second, third).exists(); 25 | assertThat(result, is(true)); 26 | } 27 | 28 | @Test 29 | public void inLine() { 30 | Point first = new Point(0, 0); 31 | Point second = new Point(0, 2); 32 | Point third = new Point(0, 4); 33 | boolean result = new RightTriangle(first, second, third).exists(); 34 | assertThat(result, is(false)); 35 | } 36 | 37 | @Test 38 | public void notRight() { 39 | Point first = new Point(0, 0); 40 | Point second = new Point(2, 2); 41 | Point third = new Point(0, 5); 42 | boolean result = new RightTriangle(first, second, third).exists(); 43 | assertThat(result, is(false)); 44 | } 45 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_006/SquareTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_006; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import ru.parsentev.task_002.Point; 6 | import ru.parsentev.task_005.RightTriangle; 7 | 8 | import static org.hamcrest.core.Is.is; 9 | import static org.junit.Assert.*; 10 | 11 | /** 12 | * TODO: comment 13 | * 14 | * @author parsentev 15 | * @since 28.07.2016 16 | */ 17 | @Ignore 18 | public class SquareTest { 19 | @Test 20 | public void checkExists() { 21 | Point first = new Point(0, 0); 22 | Point second = new Point(0, 2); 23 | Point third = new Point(2, 2); 24 | Point fourth = new Point(2, 0); 25 | boolean result = new Square(first, second, third, fourth).exists(); 26 | assertThat(result, is(true)); 27 | } 28 | 29 | @Test 30 | public void inLine() { 31 | Point first = new Point(0, 0); 32 | Point second = new Point(0, 2); 33 | Point third = new Point(0, 4); 34 | Point fourth = new Point(0, 6); 35 | boolean result = new Square(first, second, third, fourth).exists(); 36 | assertThat(result, is(false)); 37 | } 38 | 39 | @Test 40 | public void notSquare() { 41 | Point first = new Point(0, 0); 42 | Point second = new Point(1, 2); 43 | Point third = new Point(1, 4); 44 | Point fourth = new Point(0, 6); 45 | boolean result = new Square(first, second, third, fourth).exists(); 46 | assertThat(result, is(false)); 47 | } 48 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_007/ExpressionTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_007; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | 6 | import static org.hamcrest.core.Is.is; 7 | import static org.junit.Assert.*; 8 | 9 | /** 10 | * TODO: comment 11 | * 12 | * @author parsentev 13 | * @since 28.07.2016 14 | */ 15 | @Ignore 16 | public class ExpressionTest { 17 | @Test 18 | public void calc() { 19 | Expression expr = new Expression("2+2"); 20 | double result = expr.calc(); 21 | assertThat(result, is(4d)); 22 | } 23 | 24 | @Test(expected = IllegalStateException.class) 25 | public void noValid() { 26 | new Expression("2+").calc(); 27 | } 28 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_008/PrimesTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_008; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import ru.parsentev.task_007.Expression; 6 | 7 | import java.util.List; 8 | 9 | import static java.util.Arrays.asList; 10 | import static org.junit.Assert.*; 11 | import static org.hamcrest.core.Is.is; 12 | 13 | /** 14 | * TODO: comment 15 | * 16 | * @author parsentev 17 | * @since 28.07.2016 18 | */ 19 | @Ignore 20 | public class PrimesTest { 21 | @Test 22 | public void calc() { 23 | Primes primes = new Primes(3); 24 | List result = primes.calc(); 25 | assertThat(result, is(asList(2, 3))); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_009/UniqueCharsTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_009; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import static org.hamcrest.core.Is.is; 6 | import static org.junit.Assert.*; 7 | 8 | /** 9 | * TODO: comment 10 | * 11 | * @author parsentev 12 | * @since 28.07.2016 13 | */ 14 | @Ignore 15 | public class UniqueCharsTest { 16 | @Test 17 | public void hasNotUnique() { 18 | UniqueChars unique = new UniqueChars("2+2"); 19 | int result = unique.unique(); 20 | assertThat(result, is(2)); 21 | } 22 | 23 | @Test 24 | public void onlyUnique() { 25 | UniqueChars unique = new UniqueChars("123"); 26 | int result = unique.unique(); 27 | assertThat(result, is(3)); 28 | } 29 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_010/BracketsTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_010; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | 6 | import static org.hamcrest.core.Is.is; 7 | import static org.junit.Assert.*; 8 | 9 | /** 10 | * TODO: comment 11 | * 12 | * @author parsentev 13 | * @since 28.07.2016 14 | */ 15 | @Ignore 16 | public class BracketsTest { 17 | @Test 18 | public void valid() { 19 | Brackets brackets = new Brackets("()()()"); 20 | boolean result = brackets.isCorrect(); 21 | assertThat(result, is(true)); 22 | } 23 | 24 | @Test 25 | public void inValid() { 26 | Brackets brackets = new Brackets("("); 27 | boolean result = brackets.isCorrect(); 28 | assertThat(result, is(false)); 29 | } 30 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_011/ArrayContainsOneTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_011; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import static org.hamcrest.core.Is.is; 6 | import static org.junit.Assert.*; 7 | 8 | /** 9 | * TODO: comment 10 | * 11 | * @author parsentev 12 | * @since 28.07.2016 13 | */ 14 | @Ignore 15 | public class ArrayContainsOneTest { 16 | @Test 17 | public void onlyOne() { 18 | ArrayContainsOne array = new ArrayContainsOne(new int[] {1}); 19 | boolean result = array.containsOnlyOne(); 20 | assertThat(result, is(true)); 21 | } 22 | 23 | @Test 24 | public void notOnlyOne() { 25 | ArrayContainsOne array = new ArrayContainsOne(new int[] {1, 1, 0}); 26 | boolean result = array.containsOnlyOne(); 27 | assertThat(result, is(false)); 28 | } 29 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_012/SequenceArrayTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_012; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import static org.hamcrest.core.Is.is; 6 | import static org.junit.Assert.*; 7 | 8 | /** 9 | * TODO: comment 10 | * 11 | * @author parsentev 12 | * @since 28.07.2016 13 | */ 14 | @Ignore 15 | public class SequenceArrayTest { 16 | @Test 17 | public void contains() { 18 | SequenceArray array = new SequenceArray(new int[] {0, 1, 1, 1, 0}); 19 | boolean result = array.containsOneSequence(); 20 | assertThat(result, is(true)); 21 | } 22 | 23 | @Test 24 | public void notContains() { 25 | SequenceArray array = new SequenceArray(new int[] {0, 1, 0, 1, 0}); 26 | boolean result = array.containsOneSequence(); 27 | assertThat(result, is(false)); 28 | } 29 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_013/MonoArrayTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_013; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import static org.hamcrest.core.Is.is; 6 | import static org.junit.Assert.*; 7 | 8 | /** 9 | * TODO: comment 10 | * 11 | * @author parsentev 12 | * @since 28.07.2016 13 | */ 14 | @Ignore 15 | public class MonoArrayTest { 16 | @Test 17 | public void mono() { 18 | MonoArray array = new MonoArray(new int[] {1, 1, 1}); 19 | boolean result = array.exists(); 20 | assertThat(result, is(true)); 21 | } 22 | 23 | @Test 24 | public void notMono() { 25 | MonoArray array = new MonoArray(new int[] {0, 1, 1, 1, 0}); 26 | boolean result = array.exists(); 27 | assertThat(result, is(false)); 28 | } 29 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_014/ReversePhraseTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_014; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import static org.hamcrest.core.Is.is; 6 | import static org.junit.Assert.*; 7 | 8 | /** 9 | * TODO: comment 10 | * 11 | * @author parsentev 12 | * @since 28.07.2016 13 | */ 14 | @Ignore 15 | public class ReversePhraseTest { 16 | @Test 17 | public void oneWords() { 18 | ReversePhrase phrase = new ReversePhrase("code and earn"); 19 | String result = phrase.reverse(); 20 | assertThat(result, is("earn and code")); 21 | } 22 | 23 | @Test 24 | public void oneWord() { 25 | ReversePhrase phrase = new ReversePhrase("Java"); 26 | String result = phrase.reverse(); 27 | assertThat(result, is("Java")); 28 | } 29 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_015/CycleShiftTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_015; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import ru.parsentev.task_014.ReversePhrase; 6 | 7 | import static org.hamcrest.core.Is.is; 8 | import static org.junit.Assert.*; 9 | 10 | /** 11 | * TODO: comment 12 | * 13 | * @author parsentev 14 | * @since 28.07.2016 15 | */ 16 | @Ignore 17 | public class CycleShiftTest { 18 | 19 | @Test 20 | public void multi() { 21 | CycleShift cycle = new CycleShift(new int[] {1, 2, 3, 4, 5}); 22 | int[] result = cycle.shift(2); 23 | assertThat(result, is(new int[] {4, 5, 1, 2, 3})); 24 | } 25 | 26 | @Test 27 | public void one() { 28 | CycleShift cycle = new CycleShift(new int[] {1}); 29 | int[] result = cycle.shift(2); 30 | assertThat(result, is(new int[] {1})); 31 | } 32 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_016/TicTacToeTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_016; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import static org.hamcrest.core.Is.is; 6 | import static org.junit.Assert.*; 7 | 8 | /** 9 | * TODO: comment 10 | * 11 | * @author parsentev 12 | * @since 28.07.2016 13 | */ 14 | @Ignore 15 | public class TicTacToeTest { 16 | @Test 17 | public void hasWinner() { 18 | TicTacToe game = new TicTacToe( 19 | new int[][] { 20 | {1, 0, 0}, 21 | {1, 1, 0}, 22 | {0, 0, 1} 23 | } 24 | ); 25 | boolean result = game.hasWinner(); 26 | assertThat(result, is(true)); 27 | } 28 | 29 | @Test 30 | public void hasNotWinner() { 31 | TicTacToe game = new TicTacToe( 32 | new int[][] { 33 | {1, 0, 1}, 34 | {1, 0, 0}, 35 | {0, 1, 1} 36 | } 37 | ); 38 | boolean result = game.hasWinner(); 39 | assertThat(result, is(false)); 40 | } 41 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_017/CashMachineTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_017; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | 6 | import java.util.Arrays; 7 | import java.util.Collections; 8 | import java.util.List; 9 | 10 | import static java.util.Arrays.asList; 11 | import static java.util.Collections.singletonList; 12 | import static org.hamcrest.core.Is.is; 13 | import static org.junit.Assert.*; 14 | 15 | /** 16 | * TODO: comment 17 | * 18 | * @author parsentev 19 | * @since 28.07.2016 20 | */ 21 | @Ignore 22 | public class CashMachineTest { 23 | @Test 24 | public void unchange() { 25 | CashMachine machine = new CashMachine(new int[] {1, 5, 10}); 26 | List> result = machine.exchange(1); 27 | assertThat(result, is(singletonList(singletonList(1)))); 28 | } 29 | 30 | @Test 31 | public void change() { 32 | CashMachine machine = new CashMachine(new int[] {1, 5, 10}); 33 | List> result = machine.exchange(10); 34 | assertThat( 35 | result, is( 36 | asList( 37 | singletonList(10), 38 | asList(5, 5), 39 | asList(5, 1, 1, 1, 1, 1), 40 | asList(1, 1, 1, 1, 1, 1, 1, 1, 1, 1) 41 | ) 42 | ) 43 | ); 44 | } 45 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_018/PoolTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_018; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import ru.parsentev.task_015.CycleShift; 6 | 7 | import static org.hamcrest.core.Is.is; 8 | import static org.junit.Assert.*; 9 | 10 | /** 11 | * TODO: comment 12 | * 13 | * @author parsentev 14 | * @since 28.07.2016 15 | */ 16 | @Ignore 17 | public class PoolTest { 18 | @Test 19 | public void multi() { 20 | Pool pool = new Pool( 21 | new int[][] { 22 | {1, 0, 0}, 23 | {1, 1, 0}, 24 | {0, 0, 1} 25 | } 26 | ); 27 | int result = pool.maxUnion(); 28 | assertThat(result, is(3)); 29 | } 30 | 31 | @Test 32 | public void one() { 33 | Pool pool = new Pool( 34 | new int[][] { 35 | {1, 1, 1}, 36 | {1, 1, 1}, 37 | {1, 1, 1} 38 | } 39 | ); 40 | int result = pool.maxUnion(); 41 | assertThat(result, is(9)); 42 | } 43 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_019/MazeTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_019; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import ru.parsentev.task_002.Point; 6 | import ru.parsentev.task_015.CycleShift; 7 | import ru.parsentev.task_018.Pool; 8 | 9 | import java.util.List; 10 | 11 | import static java.util.Arrays.asList; 12 | import static org.hamcrest.core.Is.is; 13 | import static org.junit.Assert.*; 14 | 15 | /** 16 | * TODO: comment 17 | * 18 | * @author parsentev 19 | * @since 28.07.2016 20 | */ 21 | @Ignore 22 | public class MazeTest { 23 | @Test 24 | public void singleSolution() { 25 | Maze maze = new Maze( 26 | new int[][] { 27 | {1, 0, 0}, 28 | {1, 1, 1}, 29 | {0, 0, 1} 30 | } 31 | ); 32 | List result = maze.solution(new Point(0, 0), new Point(2, 2)); 33 | assertThat( 34 | result, is( 35 | asList( 36 | new Point(0, 0), 37 | new Point(1, 0), 38 | new Point(1, 1), 39 | new Point(2, 1), 40 | new Point(2, 2) 41 | ) 42 | ) 43 | ); 44 | } 45 | 46 | @Test 47 | public void multiSolutions() { 48 | Maze maze = new Maze( 49 | new int[][] { 50 | {1, 1, 1, 0, 1, 1, 1}, 51 | {1, 0, 1, 0, 1, 0, 1}, 52 | {1, 0, 1, 0, 1, 0, 1}, 53 | {1, 0, 1, 1, 1, 0, 1}, 54 | {1, 0, 0, 0, 0, 0, 1}, 55 | {1, 1, 1, 1, 1, 1, 1} 56 | } 57 | ); 58 | List result = maze.solution(new Point(0, 0), new Point(6, 5)); 59 | assertThat( 60 | result, is( 61 | asList( 62 | new Point(0, 0), 63 | new Point(0, 1), 64 | new Point(0, 2), 65 | new Point(0, 3), 66 | new Point(0, 4), 67 | new Point(0, 5), 68 | new Point(1, 5), 69 | new Point(2, 5), 70 | new Point(3, 5), 71 | new Point(4, 5), 72 | new Point(5, 5), 73 | new Point(6, 5) 74 | ) 75 | ) 76 | ); 77 | } 78 | } -------------------------------------------------------------------------------- /src/test/java/ru/parsentev/task_020/CombineTest.java: -------------------------------------------------------------------------------- 1 | package ru.parsentev.task_020; 2 | 3 | import org.junit.Ignore; 4 | import org.junit.Test; 5 | import ru.parsentev.task_015.CycleShift; 6 | 7 | import java.util.List; 8 | 9 | import static java.util.Arrays.asList; 10 | import static org.hamcrest.core.Is.is; 11 | import static org.junit.Assert.*; 12 | 13 | /** 14 | * TODO: comment 15 | * 16 | * @author parsentev 17 | * @since 28.07.2016 18 | */ 19 | @Ignore 20 | public class CombineTest { 21 | @Test 22 | public void simple() { 23 | Combine combine = new Combine(new int[] {1, 2}); 24 | List> result = combine.generate(); 25 | assertThat(result, is( 26 | asList( 27 | asList(1, 2), 28 | asList(2, 1) 29 | ) 30 | ) 31 | ); 32 | } 33 | 34 | @Test 35 | public void three() { 36 | Combine combine = new Combine(new int[] {1, 2, 3}); 37 | List> result = combine.generate(); 38 | assertThat(result, is( 39 | asList( 40 | asList(1, 2, 3), 41 | asList(1, 3, 2), 42 | asList(2, 1, 3), 43 | asList(3, 2, 1) 44 | ) 45 | ) 46 | ); 47 | } 48 | } --------------------------------------------------------------------------------