diff --git a/out/production/algorithms-project-2022/.github/actions/gradle-build/action.yaml b/out/production/algorithms-project-2022/.github/actions/gradle-build/action.yaml new file mode 100644 index 0000000..c05ca06 --- /dev/null +++ b/out/production/algorithms-project-2022/.github/actions/gradle-build/action.yaml @@ -0,0 +1,17 @@ +name: 'Gradle build' +description: 'Run gradle test' +runs: + using: "composite" + steps: + - name: Run the Gradle test task + uses: gradle/gradle-build-action@v2 + with: + arguments: test + - name: Check test report exists # if project has no tests then report is not generated + shell: bash + run: | + if [[ -z $(find . -path "*build/test-results/test/TEST-*.xml") ]] + then + echo "No tests found" + exit 1 + fi \ No newline at end of file diff --git a/out/production/algorithms-project-2022/.github/actions/maven-build/action.yaml b/out/production/algorithms-project-2022/.github/actions/maven-build/action.yaml new file mode 100644 index 0000000..a21b2e6 --- /dev/null +++ b/out/production/algorithms-project-2022/.github/actions/maven-build/action.yaml @@ -0,0 +1,16 @@ +name: 'Maven build' +description: 'Run maven package' +runs: + using: "composite" + steps: + - name: Run the Maven package task + shell: bash + run: mvn package --file pom.xml | tee mvn_out + - name: Check tests exists + shell: bash + run: | + if [[ -z $(cat mvn_out | grep -E "Tests run: [1-9]") ]] + then + echo "No tests found" + exit 1 + fi \ No newline at end of file diff --git a/out/production/algorithms-project-2022/.github/workflows/integration.yml b/out/production/algorithms-project-2022/.github/workflows/integration.yml new file mode 100644 index 0000000..3bed121 --- /dev/null +++ b/out/production/algorithms-project-2022/.github/workflows/integration.yml @@ -0,0 +1,29 @@ +name: Java CI + +on: + push: + pull_request: + types: [ opened, synchronize, reopened, edited, assigned ] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v1 + - name: Set up JDK 17 + uses: actions/setup-java@v1 + with: + java-version: 17 + - name: Check maven build + if: hashFiles('pom.xml') != '' + uses: ./.github/actions/maven-build + - name: Check gradle build + if: hashFiles('gradlew') != '' + uses: ./.github/actions/gradle-build + - name: Fail if build system is not detected + if: hashFiles('pom.xml') == '' && hashFiles('gradlew') == '' + run: | + echo "No build system found" + exit 1 diff --git a/out/production/algorithms-project-2022/.gitignore b/out/production/algorithms-project-2022/.gitignore new file mode 100644 index 0000000..3798a3f --- /dev/null +++ b/out/production/algorithms-project-2022/.gitignore @@ -0,0 +1,18 @@ +.gradle +.idea +/build/ +/target/ + +# Ignore Gradle GUI config +gradle-app.setting + +# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored) +!gradle-wrapper.jar + +# Cache of project +.gradletasknamecache + +# # Work around https://youtrack.jetbrains.com/issue/IDEA-116898 +# gradle/wrapper/gradle-wrapper.properties + +*.iml \ No newline at end of file diff --git a/out/production/algorithms-project-2022/README.md b/out/production/algorithms-project-2022/README.md new file mode 100644 index 0000000..1ab10ed --- /dev/null +++ b/out/production/algorithms-project-2022/README.md @@ -0,0 +1,54 @@ +# Базовый репозиторий для курсового проекта по курсу "Алгоритмы и структуры данных" + +## Инструкция +1. Сделайте [fork](https://docs.github.com/en/get-started/quickstart/fork-a-repo) репозитория + * после того как вы сделали fork, перейдите во вкладку Actions в вашем репозитории и включите их (будет большая зеленая кнопка) +3. Настройте систему сборки [maven](https://maven.apache.org/) или [gradle](https://gradle.org/) + * [Работа с maven в IDEA](https://www.jetbrains.com/help/idea/maven-support.html) + * [Работа с gradle в IDEA](https://www.jetbrains.com/help/idea/gradle.html) +4. Используйте этот репозиторий в процессе работы над своей задачей. Весь код и необходимые артефакты +должны быть в репозитории на момент сдачи. **Обязательное условие**: ваше решение должно содержать тесты, +которые должны **успешно проходить**. Дополнительная информация по конфигурации сборки: + * Если вы используете Maven, то вам необходимо явно указать необходимую версию JDK (не ниже 1.8). Пример конфигурации + для Java и JDK 11: + ```xml + + 11 + ${jvm.version} + ${jvm.version} + + ``` + Если все сконфигурировано правильно, то при запуске команды `mvn package` в консоль будет выводиться информация + о сборке и запущенных тестах. Пример необходимого вывода: + ```shell + ... + [INFO] ------------------------------------------------------- + [INFO] T E S T S + [INFO] ------------------------------------------------------- + [INFO] + [INFO] Results: + [INFO] + [INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0 + [INFO] + [INFO] ------------------------------------------------------------------------ + [INFO] BUILD SUCCESS + [INFO] ------------------------------------------------------------------------ + [INFO] Total time: 20.524 s + [INFO] Finished at: 2022-02-01T22:28:30+03:00 + [INFO] ------------------------------------------------------------------------ + ``` + * Если вы используете Gradle, то ничего дополнительного делать не нужно. Перед сдачей своего решения убедитесь, что + при запуске команды `./gradlew build` (или `./gradlew test`) в папке `build/test-results/test` генерируется xml файл + с отчетом о выполненных тестах. Пример успешного выполнения команды `./gradlew build`: + ```shell + BUILD SUCCESSFUL in 7s + 7 actionable tasks: 7 executed + ``` + В той же директории, в которой у вас находится файл `build.gradle` (или `build.gradle.kts`), должна появиться директория `build`. + В результате выполнения команды `./gradlew build` должен сгенерироваться файл с именем `build/test-results/test/TEST-myapp.test.Test.xml`, + где `myapp.test.Test` — имя вашего тестового класса. Если тестовых классов несколько, то для каждого из них генерируется отдельный отчет. +4. Чтобы сдать задание откройте [pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork) + * В качестве `base repository` выберите этот (базовый) репозиторий. В качестве ветки `base` выберите ветку `main` + * В качестве `head repository` выберите ваш репозиторий (fork). В качестве ветки `compare` выберите ветку 'main' + * В заголовке PR укажите ваше имя, название задания, и номер группы + * например, "Иванов И.И., 'Шашки рэндзю', гр. 3530901/00006" diff --git a/out/production/algorithms-project-2022/src/main/Deramida$DeramidaIterator.class b/out/production/algorithms-project-2022/src/main/Deramida$DeramidaIterator.class new file mode 100644 index 0000000..adb1d24 Binary files /dev/null and b/out/production/algorithms-project-2022/src/main/Deramida$DeramidaIterator.class differ diff --git a/out/production/algorithms-project-2022/src/main/Deramida$Node.class b/out/production/algorithms-project-2022/src/main/Deramida$Node.class new file mode 100644 index 0000000..81e47ae Binary files /dev/null and b/out/production/algorithms-project-2022/src/main/Deramida$Node.class differ diff --git a/out/production/algorithms-project-2022/src/main/Deramida$NodePair.class b/out/production/algorithms-project-2022/src/main/Deramida$NodePair.class new file mode 100644 index 0000000..1d9bc17 Binary files /dev/null and b/out/production/algorithms-project-2022/src/main/Deramida$NodePair.class differ diff --git a/out/production/algorithms-project-2022/src/main/Deramida$SubTree$SubTreeIterator.class b/out/production/algorithms-project-2022/src/main/Deramida$SubTree$SubTreeIterator.class new file mode 100644 index 0000000..e7afc53 Binary files /dev/null and b/out/production/algorithms-project-2022/src/main/Deramida$SubTree$SubTreeIterator.class differ diff --git a/out/production/algorithms-project-2022/src/main/Deramida$SubTree.class b/out/production/algorithms-project-2022/src/main/Deramida$SubTree.class new file mode 100644 index 0000000..1b99deb Binary files /dev/null and b/out/production/algorithms-project-2022/src/main/Deramida$SubTree.class differ diff --git a/out/production/algorithms-project-2022/src/main/Deramida.class b/out/production/algorithms-project-2022/src/main/Deramida.class new file mode 100644 index 0000000..560f9ff Binary files /dev/null and b/out/production/algorithms-project-2022/src/main/Deramida.class differ diff --git a/out/production/algorithms-project-2022/src/main/Main.class b/out/production/algorithms-project-2022/src/main/Main.class new file mode 100644 index 0000000..7d39116 Binary files /dev/null and b/out/production/algorithms-project-2022/src/main/Main.class differ diff --git a/out/production/algorithms-project-2022/src/test/DeramidaTest.class b/out/production/algorithms-project-2022/src/test/DeramidaTest.class new file mode 100644 index 0000000..bbffb64 Binary files /dev/null and b/out/production/algorithms-project-2022/src/test/DeramidaTest.class differ diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..3545063 --- /dev/null +++ b/pom.xml @@ -0,0 +1,16 @@ + + + 4.0.0 + + groupId + algorithms-project-2022 + 1.0-SNAPSHOT + + + 17 + 17 + + + \ No newline at end of file diff --git a/src/main/Deramida.java b/src/main/Deramida.java new file mode 100644 index 0000000..3e09b43 --- /dev/null +++ b/src/main/Deramida.java @@ -0,0 +1,428 @@ +package src.main; +import java.util.*; + +public class Deramida> implements SortedSet { + + private Node root = null; + private int size = 0; + private static final Random random = new Random(); + + private class Node { + T key; + int priority; + + Node leftChild; + Node rightChild; + Node parent = null; + + Node(T key) { + this.key = key; + priority = random.nextInt(30); + } + } + + private class NodePair { + private final K treeA; + private final V treeB; + + NodePair(K treeA, V treeB) { + this.treeA = treeA; + this.treeB = treeB; + } + + public K getTreeA() { + return treeA; + } + + public V getTreeB() { + return treeB; + } + } + + @Override + public Comparator comparator() { + return (Comparator) Comparable::compareTo; + } + + private Node merge(Node treeA, Node treeB) { + if (treeA == null) + return treeB; + if (treeB == null) + return treeA; + + if (treeA.priority > treeB.priority) { + treeA.rightChild = merge(treeA.rightChild, treeB); + treeA.rightChild.parent = treeA; + return treeA; + } else { + treeB.leftChild = merge(treeA, treeB.leftChild); + treeB.leftChild.parent = treeB; + return treeB; + } + } + + private NodePair, Node> split(Node start, T key) { + if (start == null) + return new NodePair<>(null, null); + + if (key.compareTo(start.key) > 0) { + NodePair, Node> result = split(start.rightChild, key); + start.rightChild = result.getTreeA(); + + if (start.rightChild != null) start.rightChild.parent = start; + if (result.getTreeB() != null) result.getTreeB().parent = null; + return new NodePair<>(start, result.getTreeB()); + } else { + NodePair, Node> result = split(start.leftChild, key); + start.leftChild = result.getTreeB(); + + if (start.leftChild != null) start.leftChild.parent = start; + if (result.getTreeA() != null) result.getTreeA().parent = null; + return new NodePair<>(result.getTreeA(), start); + } + } + + @Override + public int size() { + return size; + } + + @Override + public boolean isEmpty() { + return size == 0; + } + + private Node find(T key) { + if (root == null) return null; + return find(root, key); + } + + private Node find(Node start, T key) { + if (key.compareTo(start.key) == 0) { + return start; + } else if (key.compareTo(start.key) < 0) { + if (start.leftChild == null) return start; + return find(start.leftChild, key); + } else { + if (start.rightChild == null) return start; + return find(start.rightChild, key); + } + } + + @Override + public boolean contains(Object o) { + T t = (T) o; + Node node = find(t); + return node != null && t.compareTo(node.key) == 0; + } + + @Override + public boolean add(Object key) { + T addKey = (T) key; + + Node node = find(addKey); + + if (node != null && node.key.equals(addKey)) return false; + + NodePair, Node> treaps = split(root, addKey); + Node temp = merge(treaps.getTreeA(), new Node<>(addKey)); + root = merge(temp, treaps.getTreeB()); + + root.parent = null; + size++; + return true; + } + + @Override + public boolean remove(Object o) { + T deleteKey = (T) o; + Node node = find(deleteKey); + + if (node != null && node.key.compareTo(deleteKey) == 0) return removeNode(node); + + return false; + } + + public boolean removeNode(Node node) { + + Node parent = node.parent; + + if (parent != null) { + if (parent.leftChild != null && parent.leftChild.key.equals(node.key)) { + + parent.leftChild = merge(node.leftChild, node.rightChild); + if (parent.leftChild != null) parent.leftChild.parent = parent; + + } else { + + parent.rightChild = merge(node.leftChild, node.rightChild); + if (parent.rightChild != null) parent.rightChild.parent = parent; + } + } else { + root = merge(node.leftChild, node.rightChild); + if (root != null) + root.parent = null; + } + size--; + return true; + } + + @Override + public T first() { + if (root == null) throw new NoSuchElementException(); + + Node node = root; + while (node.leftChild != null) node = node.leftChild; + + return node.key; + } + + @Override + public T last() { + if (root == null) throw new NoSuchElementException(); + + Node node = root; + while (node.rightChild != null) node = node.rightChild; + + return node.key; + } + + @Override + public Iterator iterator() { + return new DeramidaIterator(); + } + + public class DeramidaIterator implements Iterator { + + private Stack> stack = new Stack<>(); + Node current = null; + + private DeramidaIterator() { + pushIter(root); + } + + private void pushIter(Node node) { + if (node != null) { + stack.push(node); + pushIter(node.leftChild); + } + } + + @Override + public boolean hasNext() { + return !stack.isEmpty(); + } + + @Override + public T next() { + if(!hasNext()) throw new NoSuchElementException(); + + Node node = stack.pop(); + current = node; + pushIter(node.rightChild); + + return node.key; + } + + @Override + public void remove() { + if (current == null) throw new IllegalStateException(); + removeNode(current); + current = null; + } + } + + @Override + public boolean addAll(Collection c) { + for (Object o : c) + if (!this.add(o)) return false; + return true; + } + + @Override + public void clear() { + this.root = null; + this.size = 0; + } + + @Override + public boolean containsAll(Collection c) { + for (Object o : c) + if (!contains(o)) return false; + return true; + } + + @Override + public boolean removeAll(Collection c) { + if (this.containsAll(c)) { + for (Object o : c) + remove(o); + return true; + } else return false; + } + + @Override + public boolean retainAll(Collection c) { + if (this.containsAll(c)) { + for (Object o : this) + if (!c.contains(o)) remove(o); + return true; + } else return false; + } + + @Override + public Object[] toArray() { + Object[] array = new Object[this.size]; + Iterator iterator = this.iterator(); + for (int i = 0; i < this.size; i++) + array[i] = iterator.next(); + return array; + } + + @Override + public Object[] toArray(Object[] a) { + Object[] array = this.toArray(); + if (this.size >= 0) System.arraycopy(array, 0, a, 0, this.size); + return a; + } + + private class SubTree extends Deramida { + T bottom; + T up; + Deramida deramida; + + SubTree(T bottom, T up, Deramida deramida) { + this.bottom = bottom; + this.up = up; + this.deramida = deramida; + } + + private boolean isIncluded(T key) { + + return (bottom != null && up != null && key.compareTo(bottom) >= 0 && key.compareTo(up) < 0) + || (bottom == null && key.compareTo(up) < 0) + || (up == null && key.compareTo(bottom) >= 0 ); + } + + public int size() { + if (deramida == null) return 0; + int size = 0; + for (Object key : deramida) + if (isIncluded((T) key)) size++; + return size; + } + + public boolean contains(Object o) { + return isIncluded((T) o) && deramida.contains(o); + } + + public boolean add(Object key) { + if (!isIncluded((T) key)) + throw new IllegalArgumentException(); + return deramida.add(key); + } + + public boolean remove(Object o) { + if (!isIncluded((T) o)) + throw new IllegalArgumentException(); + return deramida.remove(o); + } + + @Override + public Iterator iterator() { + return new SubTreeIterator(); + } + + public class SubTreeIterator implements Iterator { + + private final Stack> stack = new Stack<>(); + Node current = null; + + private SubTreeIterator() { + if (root != null) { + pushIter(root); + current = stack.peek(); + } + } + + private void pushIter(Node node) { + if (node.leftChild != null) pushIter(node.leftChild); + + if (isIncluded(node.key)) stack.push(node); + + if (node.rightChild != null) pushIter(node.rightChild); + } + + @Override + public boolean hasNext() { + return !stack.isEmpty(); + } + + @Override + public T next() { + if (!hasNext()) throw new NoSuchElementException(); + + Node node = stack.pop(); + current = node; + + return node.key; + } + + @Override + public void remove() { + if (current == null) throw new IllegalStateException(); + deramida.remove(current.key); + } + } + } + + @Override + public SortedSet subSet(Object fromElement, Object toElement) { + T from = (T) fromElement; + T to = (T) toElement; + + if (to == null && from == null) throw new IllegalArgumentException(); + if (to != null && from.compareTo(to) >= 0) throw new IllegalArgumentException(); + + return new SubTree(from, to, this); + } + + @Override + public SortedSet headSet(Object toElement) { + T to = (T) toElement; + + if (to == null) throw new IllegalArgumentException(); + + return new SubTree(null, to, this); + } + + @Override + public SortedSet tailSet(Object fromElement) { + T from = (T) fromElement; + + if (from == null) throw new IllegalArgumentException(); + + return new SubTree(from, null, this); + } + + public void print() { + print(root, 0); + } + + public void print(Node node, int level){ + if (node == null ) { + return; + } + + print(node.rightChild, level + 1); + if (level != 0) { + for(int i = 0; i < level - 1; i++) + System.out.print("| \t"); + System.out.println("├-----------" + "[" + node.key + "; " + node.priority + "]"); + } + else { + System.out.println("[" + node.key + "; " + node.priority + "]"); + } + print(node.leftChild, level + 1); + } +} \ No newline at end of file diff --git a/src/main/Main.java b/src/main/Main.java new file mode 100644 index 0000000..177b158 --- /dev/null +++ b/src/main/Main.java @@ -0,0 +1,55 @@ +package src.main; + +import java.io.*; +import java.util.Scanner; + +public class Main { + public static void main(String[] args) throws IOException { + System.out.println("Дерамида"); + Deramida deramida = new Deramida(); + char ch; + int key; + Scanner scanner = new Scanner(System.in); + + do { + System.out.println("Нажмите \"1\", чтобы добавить новый элемент"); + System.out.println("Нажмите \"2\", чтобы удалить элемент"); + System.out.println("Нажмите \"3\", чтобы добавить сразу 5 элементов"); + + int choice = scanner.nextInt(); + switch (choice) { + case 1: + System.out.println("Введите значение ключа"); + key = scanner.nextInt(); + deramida.add(key); + break; + case 2: + System.out.println("Введите значение ключа"); + key = scanner.nextInt(); + deramida.remove(key); + break; + case 3: + System.out.println("Введите пять значений ключей"); + key = scanner.nextInt(); + deramida.add(key); + key = scanner.nextInt(); + deramida.add(key); + key = scanner.nextInt(); + deramida.add(key); + key = scanner.nextInt(); + deramida.add(key); + key = scanner.nextInt(); + deramida.add(key); + break; + default: + System.out.println("Вы нажали что-то не то...\n"); + break; + } + + System.out.println("Новая дерамида:"); + deramida.print(); + System.out.println("\nПродолжить? y/n \n"); + ch = scanner.next().charAt(0); + } while (ch == 'y'); +} +} diff --git a/src/test/DeramidaTest.java b/src/test/DeramidaTest.java new file mode 100644 index 0000000..cafef8d --- /dev/null +++ b/src/test/DeramidaTest.java @@ -0,0 +1,372 @@ +package src.test; + +import src.main.Deramida; +import org.junit.Test; + +import java.util.*; + +import static org.junit.Assert.*; + +public class DeramidaTest { + @Test + public void testAdd() { + + Deramida deramida = new Deramida<>(); + + assertTrue(deramida.isEmpty()); + + assertTrue(deramida.add(1)); + assertTrue(deramida.add(8)); + assertTrue(deramida.add(9)); + + assertEquals(3, deramida.size()); + + assertTrue(deramida.add(15)); + assertTrue(deramida.add(7)); + assertTrue(deramida.add(21)); + assertTrue(deramida.add(11)); + + assertEquals(7, deramida.size()); + } + @Test + public void testRemove() { + Deramida deramida = new Deramida<>(); + + deramida.add(3); + deramida.add(7); + deramida.add(18); + deramida.add(76); + deramida.add(20); + + assertEquals(5, deramida.size()); + + assertTrue(deramida.remove(3)); + assertTrue(deramida.remove(20)); + assertTrue(deramida.remove(76)); + assertFalse(deramida.remove(55)); + + assertEquals(2, deramida.size()); + + assertTrue(deramida.remove(7)); + assertTrue(deramida.remove(18)); + + assertTrue(deramida.isEmpty()); + } + + @Test + public void testContains() { + Deramida deramida = new Deramida<>(); + + deramida.add(31); + deramida.add(27); + deramida.add(138); + + assertTrue(deramida.contains(31)); + assertTrue(deramida.contains(27)); + assertTrue(deramida.contains(138)); + assertFalse(deramida.contains(0)); + assertFalse(deramida.contains(13)); + + deramida.remove(31); + assertFalse(deramida.contains(31)); + } + + @Test + public void testFirst() { + Deramida deramida = new Deramida<>(); + + deramida.add(3); + + assertEquals(3, deramida.first()); + + deramida.add(1); + deramida.add(10); + + assertEquals(1, deramida.first()); + + deramida.remove(1); + deramida.remove(3); + + assertEquals(10, deramida.first()); + } + + @Test + public void testLast() { + Deramida deramida = new Deramida<>(); + deramida.add(11); + + assertEquals(11, deramida.last()); + + deramida.add(1); + deramida.add(23); + + assertEquals(23, deramida.last()); + + deramida.remove(11); + deramida.remove(23); + + assertEquals(1, deramida.last()); + } + + @Test + public void testAddAll() { + Deramida deramida = new Deramida<>(); + List list = new ArrayList<>(); + List list1 = new ArrayList<>(); + List list2 = new ArrayList<>(); + + assertTrue(deramida.isEmpty()); + + list.add(1); + list.add(10); + list.add(16); + list.add(4); + list.add(45); + + list2.add(1); + list2.add(45); + + deramida.addAll(list); + + assertTrue(deramida.contains(1)); + assertTrue(deramida.contains(10)); + assertTrue(deramida.contains(16)); + assertTrue(deramida.contains(4)); + assertTrue(deramida.contains(45)); + assertEquals(5, deramida.size()); + + deramida.addAll(list1); + assertEquals(5, deramida.size()); + + deramida.addAll(list2); + assertEquals(5, deramida.size()); + } + + @Test + public void testContainsAll() { + Deramida deramida = new Deramida<>(); + List list = new ArrayList<>(); + + deramida.add(106); + deramida.add(687); + deramida.add(224); + deramida.add(1566); + + list.add(106); + list.add(687); + list.add(224); + + assertTrue(deramida.containsAll(list)); + + list.add(1566); + + assertTrue(deramida.containsAll(list)); + + list.remove(3); + assertTrue(deramida.containsAll(list)); + + list.add(136); + assertFalse(deramida.containsAll(list)); + } + + @Test + public void testRemoveAll() { + Deramida deramida = new Deramida<>(); + List list = new ArrayList<>(); + List list1 = new ArrayList<>(); + + deramida.add(125); + deramida.add(246); + deramida.add(688); + deramida.add(2536); + + list.add(125); + list.add(246); + + list1.add(688); + list1.add(2536); + + deramida.removeAll(list); + + assertTrue(deramida.contains(688)); + assertTrue(deramida.contains(2536)); + assertEquals(2, deramida.size()); + + deramida.removeAll(list1); + assertTrue(deramida.isEmpty()); + } + + @Test + public void testRetainAll() { + Deramida deramida = new Deramida<>(); + List list = new ArrayList<>(); + List list1 = new ArrayList<>(); + + deramida.add(4); + deramida.add(978); + deramida.add(468); + deramida.add(24); + deramida.add(987); + deramida.add(534); + + list.add(534); + list.add(978); + + deramida.retainAll(list); + assertEquals(list.size(), deramida.size()); + assertTrue(deramida.contains(534)); + assertTrue(deramida.contains(978)); + + deramida.retainAll(list1); + assertTrue(deramida.isEmpty()); + } + + @Test + public void testClear() { + Deramida deramida = new Deramida<>(); + + deramida.add(4); + deramida.add(978); + deramida.add(468); + deramida.add(24); + + deramida.clear(); + assertTrue(deramida.isEmpty()); + + deramida.add(1); + deramida.clear(); + assertTrue(deramida.isEmpty()); + } + + @Test + public void testIterator() { + Deramida deramida = new Deramida<>(); + Set expectedSet = new HashSet<>(); + + deramida.add(4); + deramida.add(14); + deramida.add(1); + deramida.add(35); + deramida.add(7); + deramida.add(13); + deramida.add(789); + deramida.add(90); + deramida.add(55); + + expectedSet.add(4); + expectedSet.add(14); + expectedSet.add(1); + expectedSet.add(35); + expectedSet.add(7); + expectedSet.add(13); + expectedSet.add(789); + expectedSet.add(90); + expectedSet.add(55); + + + Iterator iterator1 = deramida.iterator(); + Iterator iterator2 = deramida.iterator(); + Iterator iterator3 = deramida.iterator(); + + while (iterator1.hasNext()) { + assertEquals(iterator2.next(), iterator1.next()); + } + + while (iterator3.hasNext()) { + assertTrue(expectedSet.contains(iterator3.next())); + iterator3.remove(); + } + + assertTrue(deramida.isEmpty()); + } + + @Test + public void testSubSet() { + Deramida deramida = new Deramida<>(); + + deramida.add(7); + deramida.add(2); + deramida.add(0); + deramida.add(5); + deramida.add(10); + deramida.add(14); + + SortedSet subTree = deramida.subSet(5, 11); + + assertFalse(subTree.contains(0)); + assertFalse(subTree.contains(2)); + assertFalse(subTree.contains(14)); + assertTrue(subTree.contains(5)); + assertTrue(subTree.contains(7)); + assertTrue(subTree.contains(10)); + + SortedSet subTree2 = deramida.subSet(3, 10); + + assertFalse(subTree2.contains(0)); + assertFalse(subTree2.contains(2)); + assertFalse(subTree2.contains(10)); + assertFalse(subTree2.contains(14)); + assertTrue(subTree2.contains(5)); + assertTrue(subTree2.contains(7)); + } + + @Test + public void testTailSet() { + Deramida deramida = new Deramida<>(); + + deramida.add(6); + deramida.add(1); + deramida.add(0); + deramida.add(15); + deramida.add(18); + deramida.add(34); + + SortedSet subTree = deramida.tailSet(15); + + assertFalse(subTree.contains(0)); + assertFalse(subTree.contains(1)); + assertFalse(subTree.contains(6)); + assertTrue(subTree.contains(15)); + assertTrue(subTree.contains(18)); + assertTrue(subTree.contains(34)); + + SortedSet subTree2 = deramida.tailSet(3); + + assertFalse(subTree2.contains(0)); + assertFalse(subTree2.contains(1)); + assertTrue(subTree2.contains(6)); + assertTrue(subTree2.contains(15)); + assertTrue(subTree2.contains(18)); + assertTrue(subTree2.contains(34)); + } + + @Test + public void testHeadSet() { + Deramida deramida = new Deramida<>(); + + deramida.add(6); + deramida.add(1); + deramida.add(0); + deramida.add(15); + deramida.add(18); + deramida.add(34); + + SortedSet subTree = deramida.headSet(15); + + assertTrue(subTree.contains(0)); + assertTrue(subTree.contains(1)); + assertTrue(subTree.contains(6)); + assertTrue(!subTree.contains(15)); + assertFalse(subTree.contains(18)); + assertFalse(subTree.contains(34)); + + SortedSet subTree2 = deramida.headSet(3); + + assertTrue(subTree2.contains(0)); + assertTrue(subTree2.contains(1)); + assertFalse(subTree2.contains(6)); + assertFalse(subTree2.contains(15)); + assertFalse(subTree2.contains(18)); + assertFalse(subTree2.contains(34)); + } +}