From b0da3ee8d43f7a32aaf0fade9f36dede0965e786 Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Wed, 10 Jul 2019 14:44:39 +0300 Subject: [PATCH 01/18] initial for HW04 --- .gitignore | 4 +- src/ArrayStorage.java | 85 ------------------- src/Resume.java | 21 ----- .../javawebinar/basejava}/MainArray.java | 22 +++-- .../javawebinar/basejava/MainReflection.java | 19 +++++ src/ru/javawebinar/basejava/MainString.java | 18 ++++ .../basejava}/MainTestArrayStorage.java | 37 +++----- .../exception/ExistStorageException.java | 7 ++ .../exception/NotExistStorageException.java | 7 ++ .../basejava/exception/StorageException.java | 14 +++ src/ru/javawebinar/basejava/model/Resume.java | 49 +++++++++++ .../storage/AbstractArrayStorage.java | 80 +++++++++++++++++ .../javawebinar/basejava/storage/Storage.java | 20 +++++ .../basejava/storage/impl/ArrayStorage.java | 30 +++++++ .../storage/impl/SortedArrayStorage.java | 31 +++++++ .../storage/AbstractArrayStorageTest.java | 63 ++++++++++++++ .../storage/impl/ArrayStorageTest.java | 7 ++ 17 files changed, 369 insertions(+), 145 deletions(-) delete mode 100644 src/ArrayStorage.java delete mode 100644 src/Resume.java rename src/{ => ru/javawebinar/basejava}/MainArray.java (80%) create mode 100644 src/ru/javawebinar/basejava/MainReflection.java create mode 100644 src/ru/javawebinar/basejava/MainString.java rename src/{ => ru/javawebinar/basejava}/MainTestArrayStorage.java (50%) create mode 100644 src/ru/javawebinar/basejava/exception/ExistStorageException.java create mode 100644 src/ru/javawebinar/basejava/exception/NotExistStorageException.java create mode 100644 src/ru/javawebinar/basejava/exception/StorageException.java create mode 100644 src/ru/javawebinar/basejava/model/Resume.java create mode 100644 src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java create mode 100644 src/ru/javawebinar/basejava/storage/Storage.java create mode 100644 src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java create mode 100644 src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java create mode 100644 test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java diff --git a/.gitignore b/.gitignore index 188fae8..ba9ea56 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,4 @@ out *.iml log - - - +lib diff --git a/src/ArrayStorage.java b/src/ArrayStorage.java deleted file mode 100644 index cefa261..0000000 --- a/src/ArrayStorage.java +++ /dev/null @@ -1,85 +0,0 @@ -import java.util.Arrays; -import java.util.Objects; - -/** - * Array based storage for Resumes - */ -public class ArrayStorage { - private Resume[] storage = new Resume[10_000]; - - private int size; - - public void clear() { - Arrays.fill(storage, 0, size, null); - size = 0; - } - - public void update(Resume resume) { - int index = getIndex(resume.getUuid()); - - if (index >= 0) { - storage[index] = resume; - } else { - System.out.println("ERROR in method 'update' :" + resume.getUuid()); - } - } - - public void save(Resume resume) { - int index = getIndex(resume.getUuid()); - - if (index >= 0) { - System.out.println("ERROR in method 'save' :" + resume.getUuid()); - } else { - if (size < storage.length) { - storage[size] = resume; - size++; - } else { - System.out.println("ERROR in method 'save' :" + resume.getUuid() + " (storage backing array boundary has been reached)"); - } - } - } - - public Resume get(String uuid) { - int index = getIndex(uuid); - - if (index >= 0) { - return storage[index]; - } else { - System.out.println("Invalid uuid in method 'get': " + uuid); - return null; - } - } - - - public void delete(String uuid) { - int index = getIndex(uuid); - - if (index >= 0) { - storage[index] = storage[size - 1]; - storage[size - 1] = null; - size--; - } else { - System.out.println("Invalid uuid in method 'delete': " + uuid); - } - } - - /** - * @return array, contains only Resumes in storage (without null) - */ - public Resume[] getAll() { - return Arrays.copyOf(storage, size); - } - - public int size() { - return size; - } - - private int getIndex(String uuid) { - for (int i = 0; i < size; i++) { - if (Objects.equals(storage[i].getUuid(), uuid)) { - return i; - } - } - return -1; - } -} diff --git a/src/Resume.java b/src/Resume.java deleted file mode 100644 index ef673e6..0000000 --- a/src/Resume.java +++ /dev/null @@ -1,21 +0,0 @@ -/** - * Initial resume class - */ -public class Resume { - - // Unique identifier - private String uuid; - - public String getUuid() { - return uuid; - } - - public void setUuid(String uuid) { - this.uuid = uuid; - } - - @Override - public String toString() { - return uuid; - } -} diff --git a/src/MainArray.java b/src/ru/javawebinar/basejava/MainArray.java similarity index 80% rename from src/MainArray.java rename to src/ru/javawebinar/basejava/MainArray.java index cc060cf..2f812b8 100644 --- a/src/MainArray.java +++ b/src/ru/javawebinar/basejava/MainArray.java @@ -1,19 +1,24 @@ +package ru.javawebinar.basejava; + +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.impl.ArrayStorage; +import ru.javawebinar.basejava.storage.Storage; + import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; /** - * Interactive test for ArrayStorage implementation - * (just run, no need to understand) + * Test for ru.javawebinar.basejava.storage.impl.ArrayStorage */ public class MainArray { - private final static ArrayStorage ARRAY_STORAGE = new ArrayStorage(); + private final static Storage ARRAY_STORAGE = new ArrayStorage(); public static void main(String[] args) throws IOException { BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); Resume r; while (true) { - System.out.print("Введите одну из команд - (list | save uuid | update uuid | delete uuid | get uuid | clear | exit): "); + System.out.print("Введите одну из команд - (list | save uuid | delete uuid | get uuid | update uuid | clear | exit): "); String[] params = reader.readLine().trim().toLowerCase().split(" "); if (params.length < 1 || params.length > 2) { System.out.println("Неверная команда."); @@ -31,15 +36,14 @@ public static void main(String[] args) throws IOException { System.out.println(ARRAY_STORAGE.size()); break; case "save": - r = new Resume(); - r.setUuid(uuid); + r = new Resume(uuid); ARRAY_STORAGE.save(r); printAll(); break; case "update": - Resume rNew = new Resume(); - rNew.setUuid(uuid); - ARRAY_STORAGE.update(rNew); + r = new Resume(uuid); + ARRAY_STORAGE.update(r); + printAll(); break; case "delete": ARRAY_STORAGE.delete(uuid); diff --git a/src/ru/javawebinar/basejava/MainReflection.java b/src/ru/javawebinar/basejava/MainReflection.java new file mode 100644 index 0000000..d37690a --- /dev/null +++ b/src/ru/javawebinar/basejava/MainReflection.java @@ -0,0 +1,19 @@ +package ru.javawebinar.basejava; + +import ru.javawebinar.basejava.model.Resume; + +import java.lang.reflect.Field; + +public class MainReflection { + + public static void main(String[] args) throws IllegalAccessException { + Resume r = new Resume(); + Field field = r.getClass().getDeclaredFields()[0]; + field.setAccessible(true); + System.out.println(field.getName()); + System.out.println(field.get(r)); + field.set(r, "new_uuid"); + // TODO : invoke r.toString via reflection + System.out.println(r); + } +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/MainString.java b/src/ru/javawebinar/basejava/MainString.java new file mode 100644 index 0000000..681b189 --- /dev/null +++ b/src/ru/javawebinar/basejava/MainString.java @@ -0,0 +1,18 @@ +package ru.javawebinar.basejava; + +public class MainString { + public static void main(String[] args) { + String[] strArray = new String[]{"1", "2", "3", "4", "5"}; +// String result = ""; + StringBuilder sb = new StringBuilder(); + for (String str : strArray) { + sb.append(str).append(", "); + } + System.out.println(sb.toString()); + + String str1 = "abc"; + String str3 = "c"; + String str2 = ("ab" + str3).intern(); + System.out.println(str1 == str2); + } +} \ No newline at end of file diff --git a/src/MainTestArrayStorage.java b/src/ru/javawebinar/basejava/MainTestArrayStorage.java similarity index 50% rename from src/MainTestArrayStorage.java rename to src/ru/javawebinar/basejava/MainTestArrayStorage.java index 7683807..dad5b1b 100644 --- a/src/MainTestArrayStorage.java +++ b/src/ru/javawebinar/basejava/MainTestArrayStorage.java @@ -1,19 +1,18 @@ +package ru.javawebinar.basejava; + +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.impl.ArrayStorage; + /** - * Test for your ArrayStorage implementation + * Test ru.javawebinar.basejava.storage.impl.ArrayStorage */ public class MainTestArrayStorage { static final ArrayStorage ARRAY_STORAGE = new ArrayStorage(); - static int ARRAY_STORAGE_LIMIT = 10_000; public static void main(String[] args) { - Resume r1 = new Resume(); - r1.setUuid("uuid1"); - Resume r2 = new Resume(); - r2.setUuid("uuid2"); - Resume r3 = new Resume(); - r3.setUuid("uuid3"); - Resume r2new = new Resume(); - r2new.setUuid("uuid2"); + Resume r1 = new Resume("uuid1"); + Resume r2 = new Resume("uuid2"); + Resume r3 = new Resume("uuid3"); ARRAY_STORAGE.save(r1); ARRAY_STORAGE.save(r2); @@ -24,14 +23,6 @@ public static void main(String[] args) { System.out.println("Get dummy: " + ARRAY_STORAGE.get("dummy")); - ARRAY_STORAGE.save(r2new); - - ARRAY_STORAGE.update(r2new); - System.out.println("Get r2new: " + ARRAY_STORAGE.get(r2new.getUuid())); - - ARRAY_STORAGE.get("uuid111"); - ARRAY_STORAGE.delete("uuid111"); - printAll(); ARRAY_STORAGE.delete(r1.getUuid()); printAll(); @@ -39,14 +30,6 @@ public static void main(String[] args) { printAll(); System.out.println("Size: " + ARRAY_STORAGE.size()); - - for (int i = 0; i <= ARRAY_STORAGE_LIMIT; i++) { - Resume r = new Resume(); - r.setUuid("uuid" + i); - ARRAY_STORAGE.save(r); - } - - System.out.println("Size: " + ARRAY_STORAGE.size()); } static void printAll() { @@ -55,4 +38,4 @@ static void printAll() { System.out.println(r); } } -} +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/exception/ExistStorageException.java b/src/ru/javawebinar/basejava/exception/ExistStorageException.java new file mode 100644 index 0000000..33d98be --- /dev/null +++ b/src/ru/javawebinar/basejava/exception/ExistStorageException.java @@ -0,0 +1,7 @@ +package ru.javawebinar.basejava.exception; + +public class ExistStorageException extends StorageException { + public ExistStorageException(String uuid) { + super("Resume " + uuid + " already exist", uuid); + } +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/exception/NotExistStorageException.java b/src/ru/javawebinar/basejava/exception/NotExistStorageException.java new file mode 100644 index 0000000..9a9b867 --- /dev/null +++ b/src/ru/javawebinar/basejava/exception/NotExistStorageException.java @@ -0,0 +1,7 @@ +package ru.javawebinar.basejava.exception; + +public class NotExistStorageException extends StorageException { + public NotExistStorageException(String uuid) { + super("Resume " + uuid + " not exist", uuid); + } +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/exception/StorageException.java b/src/ru/javawebinar/basejava/exception/StorageException.java new file mode 100644 index 0000000..dbd1be0 --- /dev/null +++ b/src/ru/javawebinar/basejava/exception/StorageException.java @@ -0,0 +1,14 @@ +package ru.javawebinar.basejava.exception; + +public class StorageException extends RuntimeException { + private final String uuid; + + public StorageException(String message, String uuid) { + super(message); + this.uuid = uuid; + } + + public String getUuid() { + return uuid; + } +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/model/Resume.java b/src/ru/javawebinar/basejava/model/Resume.java new file mode 100644 index 0000000..508cc20 --- /dev/null +++ b/src/ru/javawebinar/basejava/model/Resume.java @@ -0,0 +1,49 @@ +package ru.javawebinar.basejava.model; + +import java.util.UUID; + +/** + * ru.javawebinar.basejava.model.Resume class + */ +public class Resume implements Comparable { + + // Unique identifier + private final String uuid; + + public Resume() { + this(UUID.randomUUID().toString()); + } + + public Resume(String uuid) { + this.uuid = uuid; + } + + public String getUuid() { + return uuid; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Resume resume = (Resume) o; + + return uuid.equals(resume.uuid); + } + + @Override + public int hashCode() { + return uuid.hashCode(); + } + + @Override + public String toString() { + return uuid; + } + + @Override + public int compareTo(Resume o) { + return uuid.compareTo(o.uuid); + } +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java new file mode 100644 index 0000000..098f9f1 --- /dev/null +++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java @@ -0,0 +1,80 @@ +package ru.javawebinar.basejava.storage; + +import ru.javawebinar.basejava.exception.ExistStorageException; +import ru.javawebinar.basejava.exception.NotExistStorageException; +import ru.javawebinar.basejava.exception.StorageException; +import ru.javawebinar.basejava.model.Resume; + +import java.util.Arrays; + +/** + * Array based storage for Resumes + */ +public abstract class AbstractArrayStorage implements Storage { + protected static final int STORAGE_LIMIT = 10000; + + protected Resume[] storage = new Resume[STORAGE_LIMIT]; + protected int size = 0; + + public int size() { + return size; + } + + public void clear() { + Arrays.fill(storage, 0, size, null); + size = 0; + } + + public void update(Resume r) { + int index = getIndex(r.getUuid()); + if (index < 0) { + throw new NotExistStorageException(r.getUuid()); + } else { + storage[index] = r; + } + } + + /** + * @return array, contains only Resumes in storage (without null) + */ + public Resume[] getAll() { + return Arrays.copyOfRange(storage, 0, size); + } + + public void save(Resume r) { + int index = getIndex(r.getUuid()); + if (index >= 0) { + throw new ExistStorageException(r.getUuid()); + } else if (size == STORAGE_LIMIT) { + throw new StorageException("Storage overflow", r.getUuid()); + } else { + insertElement(r, index); + size++; + } + } + + public void delete(String uuid) { + int index = getIndex(uuid); + if (index < 0) { + throw new NotExistStorageException(uuid); + } else { + fillDeletedElement(index); + storage[size - 1] = null; + size--; + } + } + + public Resume get(String uuid) { + int index = getIndex(uuid); + if (index < 0) { + throw new NotExistStorageException(uuid); + } + return storage[index]; + } + + protected abstract void fillDeletedElement(int index); + + protected abstract void insertElement(Resume r, int index); + + protected abstract int getIndex(String uuid); +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/Storage.java b/src/ru/javawebinar/basejava/storage/Storage.java new file mode 100644 index 0000000..2f7a1d9 --- /dev/null +++ b/src/ru/javawebinar/basejava/storage/Storage.java @@ -0,0 +1,20 @@ +package ru.javawebinar.basejava.storage; + +import ru.javawebinar.basejava.model.Resume; + +public interface Storage { + + void clear(); + + void update(Resume r); + + void save(Resume r); + + Resume get(String uuid); + + void delete(String uuid); + + Resume[] getAll(); + + int size(); +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java new file mode 100644 index 0000000..37663ba --- /dev/null +++ b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java @@ -0,0 +1,30 @@ +package ru.javawebinar.basejava.storage.impl; + +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.AbstractArrayStorage; + +/** + * Array based storage for Resumes + */ +public class ArrayStorage extends AbstractArrayStorage { + + @Override + protected void fillDeletedElement(int index) { + storage[index] = storage[size - 1]; + } + + @Override + protected void insertElement(Resume r, int index) { + storage[size] = r; + } + + @Override + protected int getIndex(String uuid) { + for (int i = 0; i < size; i++) { + if (uuid.equals(storage[i].getUuid())) { + return i; + } + } + return -1; + } +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java new file mode 100644 index 0000000..befd2f6 --- /dev/null +++ b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java @@ -0,0 +1,31 @@ +package ru.javawebinar.basejava.storage.impl; + +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.AbstractArrayStorage; + +import java.util.Arrays; + +public class SortedArrayStorage extends AbstractArrayStorage { + + @Override + protected void fillDeletedElement(int index) { + int numMoved = size - index - 1; + if (numMoved > 0) { + System.arraycopy(storage, index + 1, storage, index, numMoved); + } + } + + @Override + protected void insertElement(Resume r, int index) { +// http://codereview.stackexchange.com/questions/36221/binary-search-for-inserting-in-array#answer-36239 + int insertIdx = -index - 1; + System.arraycopy(storage, insertIdx, storage, insertIdx + 1, size - insertIdx); + storage[insertIdx] = r; + } + + @Override + protected int getIndex(String uuid) { + Resume searchKey = new Resume(uuid); + return Arrays.binarySearch(storage, 0, size, searchKey); + } +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java new file mode 100644 index 0000000..dce9722 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java @@ -0,0 +1,63 @@ +package ru.javawebinar.basejava.storage; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import ru.javawebinar.basejava.exception.NotExistStorageException; +import ru.javawebinar.basejava.model.Resume; + +public abstract class AbstractArrayStorageTest { + private Storage storage; + + private static final String UUID_1 = "uuid1"; + private static final String UUID_2 = "uuid2"; + private static final String UUID_3 = "uuid3"; + + @Before + public void setUp() throws Exception { + storage.clear(); + storage.save(new Resume(UUID_1)); + storage.save(new Resume(UUID_2)); + storage.save(new Resume(UUID_3)); + } + + @Test + public void size() throws Exception { + Assert.assertEquals(3, storage.size()); + } + + @Test + public void clear() throws Exception { + + } + + @Test + public void update() throws Exception { + + } + + @Test + public void getAll() throws Exception { + + } + + @Test + public void save() throws Exception { + + } + + @Test + public void delete() throws Exception { + + } + + @Test + public void get() throws Exception { + + } + + @Test(expected = NotExistStorageException.class) + public void getNotExist() throws Exception { + storage.get("dummy"); + } +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java new file mode 100644 index 0000000..ef07e36 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java @@ -0,0 +1,7 @@ +package ru.javawebinar.basejava.storage.impl; + +import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; + +public class ArrayStorageTest extends AbstractArrayStorageTest { + +} \ No newline at end of file From d288d7113119f3a7919c93b7083da69875c0a122 Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Wed, 10 Jul 2019 15:07:32 +0300 Subject: [PATCH 02/18] invoke via reflection --- .../javawebinar/basejava/MainReflection.java | 21 +++++++++++++++++++ .../storage/impl/SortedArrayStorageTest.java | 20 ++++++++++++++++++ 2 files changed, 41 insertions(+) create mode 100644 test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java diff --git a/src/ru/javawebinar/basejava/MainReflection.java b/src/ru/javawebinar/basejava/MainReflection.java index d37690a..7652fd8 100644 --- a/src/ru/javawebinar/basejava/MainReflection.java +++ b/src/ru/javawebinar/basejava/MainReflection.java @@ -3,6 +3,8 @@ import ru.javawebinar.basejava.model.Resume; import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; public class MainReflection { @@ -15,5 +17,24 @@ public static void main(String[] args) throws IllegalAccessException { field.set(r, "new_uuid"); // TODO : invoke r.toString via reflection System.out.println(r); + + System.out.println(field.get(r)); + + try { + Method toString = r.getClass().getMethod("toString"); + + try { + Object invoke = toString.invoke(r); + System.out.println(invoke); + + } catch (IllegalArgumentException e) { } + catch (IllegalAccessException e) { } + catch (InvocationTargetException e) { } + + } catch (SecurityException e) { } + catch (NoSuchMethodException e) { } + + + } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java new file mode 100644 index 0000000..90c4b09 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java @@ -0,0 +1,20 @@ +package ru.javawebinar.basejava.storage.impl; + +import org.junit.Test; + +import static org.junit.Assert.*; + +public class SortedArrayStorageTest { + + @Test + public void fillDeletedElement() { + } + + @Test + public void insertElement() { + } + + @Test + public void getIndex() { + } +} \ No newline at end of file From 86217926ef25c6a90ae1335e9bd264b74e93ad8b Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Sat, 3 Aug 2019 23:13:31 +0300 Subject: [PATCH 03/18] ready to review --- .../storage/AbstractArrayStorage.java | 8 +- .../basejava/storage/impl/ArrayStorage.java | 4 +- .../storage/impl/SortedArrayStorage.java | 11 +- .../storage/AbstractArrayStorageTest.java | 127 +++++++++++++++--- .../storage/impl/ArrayStorageTest.java | 3 + .../storage/impl/SortedArrayStorageTest.java | 18 +-- 6 files changed, 129 insertions(+), 42 deletions(-) diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java index 098f9f1..3971b8d 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java @@ -48,7 +48,7 @@ public void save(Resume r) { } else if (size == STORAGE_LIMIT) { throw new StorageException("Storage overflow", r.getUuid()); } else { - insertElement(r, index); + doSave(r, index); size++; } } @@ -58,7 +58,7 @@ public void delete(String uuid) { if (index < 0) { throw new NotExistStorageException(uuid); } else { - fillDeletedElement(index); + doDelete(index); storage[size - 1] = null; size--; } @@ -72,9 +72,9 @@ public Resume get(String uuid) { return storage[index]; } - protected abstract void fillDeletedElement(int index); + protected abstract void doDelete(int index); - protected abstract void insertElement(Resume r, int index); + protected abstract void doSave(Resume r, int index); protected abstract int getIndex(String uuid); } \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java index 37663ba..981e3bd 100644 --- a/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java @@ -9,12 +9,12 @@ public class ArrayStorage extends AbstractArrayStorage { @Override - protected void fillDeletedElement(int index) { + protected void doDelete(int index) { storage[index] = storage[size - 1]; } @Override - protected void insertElement(Resume r, int index) { + protected void doSave(Resume r, int index) { storage[size] = r; } diff --git a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java index befd2f6..aef2646 100644 --- a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java @@ -8,7 +8,7 @@ public class SortedArrayStorage extends AbstractArrayStorage { @Override - protected void fillDeletedElement(int index) { + protected void doDelete(int index) { int numMoved = size - index - 1; if (numMoved > 0) { System.arraycopy(storage, index + 1, storage, index, numMoved); @@ -16,11 +16,10 @@ protected void fillDeletedElement(int index) { } @Override - protected void insertElement(Resume r, int index) { -// http://codereview.stackexchange.com/questions/36221/binary-search-for-inserting-in-array#answer-36239 - int insertIdx = -index - 1; - System.arraycopy(storage, insertIdx, storage, insertIdx + 1, size - insertIdx); - storage[insertIdx] = r; + protected void doSave(Resume r, int index) { + int insert = -index - 1; + System.arraycopy(storage, insert, storage, insert + 1, size - insert); + storage[insert] = r; } @Override diff --git a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java index dce9722..a8f2536 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java @@ -1,63 +1,158 @@ package ru.javawebinar.basejava.storage; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.*; +import org.junit.jupiter.api.function.Executable; +import ru.javawebinar.basejava.exception.ExistStorageException; import ru.javawebinar.basejava.exception.NotExistStorageException; +import ru.javawebinar.basejava.exception.StorageException; import ru.javawebinar.basejava.model.Resume; +import java.util.Optional; +import java.util.stream.IntStream; +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.*; + + +@DisplayName("JUnit 5 Example") public abstract class AbstractArrayStorageTest { - private Storage storage; + protected Storage storage; - private static final String UUID_1 = "uuid1"; - private static final String UUID_2 = "uuid2"; - private static final String UUID_3 = "uuid3"; + protected static final String UUID_1 = "uuid1"; + protected static final String UUID_2 = "uuid2"; + protected static final String UUID_3 = "uuid3"; - @Before - public void setUp() throws Exception { - storage.clear(); + public AbstractArrayStorageTest(Storage storage) { + this.storage = storage; + } + + @BeforeEach + void beforeEach() { storage.save(new Resume(UUID_1)); storage.save(new Resume(UUID_2)); storage.save(new Resume(UUID_3)); } + @AfterEach + void afterEach() { + storage.clear(); + } + + @Nested + @DisplayName("When overflow") + class WhenOverflow { + + @BeforeEach + void setUp() { + storage.clear(); + + IntStream.iterate(0, n -> n + 1). + limit(AbstractArrayStorage.STORAGE_LIMIT). + mapToObj(i -> new Resume("Name" + i)). + forEach(storage::save); + } + + + @Test + @DisplayName("Should not throw within size limit") + void shouldNotThrow() { + String uuid = "New item"; + if (storage.size() < AbstractArrayStorage.STORAGE_LIMIT) { + storage.save(new Resume(uuid)); + assertDoesNotThrow(() -> { + }); + } + } + + @Test + @DisplayName("Should throw correct exception if overflown") + void shouldThrowCorrectException() { + + // arrange + String uuid = "New item"; + Executable throwingExecutable = () -> { + storage.save(new Resume(uuid)); + }; + + // act and assert + RuntimeException thrown = assertThrows( + StorageException.class, throwingExecutable::execute, "Should throw non specialized StorageException" + ); + + assertEquals("Storage overflow", thrown.getMessage()); + } + } + @Test public void size() throws Exception { - Assert.assertEquals(3, storage.size()); + assertEquals(3, storage.size()); } @Test public void clear() throws Exception { - + storage.clear(); + assertEquals(0, storage.size()); } @Test public void update() throws Exception { + Resume r2new = new Resume(UUID_2); + storage.update(r2new); + assertEquals(UUID_2, storage.get(UUID_2).getUuid()); } @Test public void getAll() throws Exception { + Resume[] all = storage.getAll(); + + assertEquals(UUID_1, all[0].getUuid()); + assertEquals(UUID_2, all[1].getUuid()); + assertEquals(UUID_3, all[2].getUuid()); } @Test public void save() throws Exception { + String newUuid = "uuid4"; + Resume r4 = new Resume(newUuid); + storage.save(r4); + assertEquals(newUuid, storage.get(newUuid).getUuid()); + } + + @Test + public void saveExisting() throws Exception { + assertThrows(ExistStorageException.class, + () -> storage.save(new Resume(UUID_1))); } @Test public void delete() throws Exception { + storage.delete(UUID_2); + Resume[] all = storage.getAll(); + Optional first = Stream.of(all) + .filter(r -> r.getUuid() == UUID_2) + .findFirst(); + assertEquals(Optional.empty(), first); } @Test public void get() throws Exception { - + assertEquals(UUID_1, storage.get("uuid1").getUuid()); } - @Test(expected = NotExistStorageException.class) - public void getNotExist() throws Exception { - storage.get("dummy"); + @Test + public void getNonExisting() { + String dummy = "dummy"; + + final StorageException thrown = assertThrows( + NotExistStorageException.class, + () -> { + storage.get(dummy); + } + ); + assertEquals(dummy, thrown.getUuid()); } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java index ef07e36..51d79df 100644 --- a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java @@ -4,4 +4,7 @@ public class ArrayStorageTest extends AbstractArrayStorageTest { + public ArrayStorageTest() { + super(new ArrayStorage()); + } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java index 90c4b09..8f53414 100644 --- a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java @@ -1,20 +1,10 @@ package ru.javawebinar.basejava.storage.impl; -import org.junit.Test; +import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; -import static org.junit.Assert.*; +public class SortedArrayStorageTest extends AbstractArrayStorageTest { -public class SortedArrayStorageTest { - - @Test - public void fillDeletedElement() { - } - - @Test - public void insertElement() { - } - - @Test - public void getIndex() { + public SortedArrayStorageTest() { + super(new SortedArrayStorage()); } } \ No newline at end of file From 2ae77cf8ee629a9f7cca2462c514de0ddce81f72 Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Mon, 5 Aug 2019 15:27:19 +0300 Subject: [PATCH 04/18] rev2 --- .../storage/AbstractArrayStorageTest.java | 80 +++++++++++-------- .../ru/javawebinar/basejava/storage/Util.java | 24 ++++++ .../storage/impl/ArrayStorageTest.java | 2 + .../storage/impl/SortedArrayStorageTest.java | 2 + 4 files changed, 74 insertions(+), 34 deletions(-) create mode 100644 test/ru/javawebinar/basejava/storage/Util.java diff --git a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java index a8f2536..27824c7 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java @@ -7,30 +7,29 @@ import ru.javawebinar.basejava.exception.StorageException; import ru.javawebinar.basejava.model.Resume; -import java.util.Optional; import java.util.stream.IntStream; -import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.*; +import static ru.javawebinar.basejava.storage.Util.*; -@DisplayName("JUnit 5 Example") public abstract class AbstractArrayStorageTest { - protected Storage storage; - protected static final String UUID_1 = "uuid1"; - protected static final String UUID_2 = "uuid2"; - protected static final String UUID_3 = "uuid3"; + private Storage storage; - public AbstractArrayStorageTest(Storage storage) { + protected AbstractArrayStorageTest(Storage storage) { this.storage = storage; } + @BeforeAll + static void beforeAll() { + } + @BeforeEach void beforeEach() { - storage.save(new Resume(UUID_1)); - storage.save(new Resume(UUID_2)); - storage.save(new Resume(UUID_3)); + storage.save(r1); + storage.save(r2); + storage.save(r3); } @AfterEach @@ -39,8 +38,7 @@ void afterEach() { } @Nested - @DisplayName("When overflow") - class WhenOverflow { + class SaveOverflow { @BeforeEach void setUp() { @@ -96,26 +94,33 @@ public void clear() throws Exception { @Test public void update() throws Exception { - Resume r2new = new Resume(UUID_2); - + Resume r2new = makeResume(UUID_2); storage.update(r2new); - assertEquals(UUID_2, storage.get(UUID_2).getUuid()); + + assertSame(storage.get(UUID_2), r2new); } @Test - public void getAll() throws Exception { + public void updateNonExisting() { + assertThrows( + NotExistStorageException.class, + () -> { + storage.update(makeResume("dummy")); + } + ); + } - Resume[] all = storage.getAll(); - assertEquals(UUID_1, all[0].getUuid()); - assertEquals(UUID_2, all[1].getUuid()); - assertEquals(UUID_3, all[2].getUuid()); + @Test + public void getAll() throws Exception { + Resume[] test = new Resume[]{r1, r2, r3}; + assertArrayEquals(test, storage.getAll()); } @Test public void save() throws Exception { - String newUuid = "uuid4"; - Resume r4 = new Resume(newUuid); + String newUuid = UUID_4; + Resume r4 = makeResume(newUuid); storage.save(r4); assertEquals(newUuid, storage.get(newUuid).getUuid()); @@ -130,29 +135,36 @@ public void saveExisting() throws Exception { @Test public void delete() throws Exception { storage.delete(UUID_2); - Resume[] all = storage.getAll(); - Optional first = Stream.of(all) - .filter(r -> r.getUuid() == UUID_2) - .findFirst(); - assertEquals(Optional.empty(), first); + assertAll("storage size is decreased, and access to deleted item correctly throws", + () -> assertEquals(2, storage.size()), + () -> assertThrows(NotExistStorageException.class, + () -> storage.get(UUID_2)) + ); + } + + @Test + public void deleteNonExisting() { + assertThrows( + NotExistStorageException.class, + () -> { + storage.delete("dummy"); + } + ); } @Test public void get() throws Exception { - assertEquals(UUID_1, storage.get("uuid1").getUuid()); + assertSame(r1, storage.get(UUID_1)); } @Test public void getNonExisting() { - String dummy = "dummy"; - - final StorageException thrown = assertThrows( + assertThrows( NotExistStorageException.class, () -> { - storage.get(dummy); + storage.get("dummy"); } ); - assertEquals(dummy, thrown.getUuid()); } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/Util.java b/test/ru/javawebinar/basejava/storage/Util.java new file mode 100644 index 0000000..8e5c658 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/Util.java @@ -0,0 +1,24 @@ +package ru.javawebinar.basejava.storage; + +import ru.javawebinar.basejava.model.Resume; + +class Util { + static final String UUID_1 = "uuid1"; + static final String UUID_2 = "uuid2"; + static final String UUID_3 = "uuid3"; + static final String UUID_4 = "uuid4"; + + static final Resume r1; + static final Resume r2; + static final Resume r3; + + static Resume makeResume(String uuid){ + return new Resume(uuid); + } + + static { + r1 = makeResume(UUID_1); + r2 = makeResume(UUID_2); + r3 = makeResume(UUID_3); + } +} diff --git a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java index 51d79df..4d9bcdb 100644 --- a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java @@ -1,7 +1,9 @@ package ru.javawebinar.basejava.storage.impl; +import org.junit.jupiter.api.DisplayName; import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; +@DisplayName("ArrayStorage implementstion") public class ArrayStorageTest extends AbstractArrayStorageTest { public ArrayStorageTest() { diff --git a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java index 8f53414..384a34b 100644 --- a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java @@ -1,7 +1,9 @@ package ru.javawebinar.basejava.storage.impl; +import org.junit.jupiter.api.DisplayName; import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; +@DisplayName("SortedArrayStorage implementstion") public class SortedArrayStorageTest extends AbstractArrayStorageTest { public SortedArrayStorageTest() { From eb1d904005dbd0eec43a7b8a7c2ca245877a8e4a Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Mon, 5 Aug 2019 15:41:29 +0300 Subject: [PATCH 05/18] rev2 --- .../storage/AbstractArrayStorageTest.java | 28 ++++++------------- 1 file changed, 9 insertions(+), 19 deletions(-) diff --git a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java index 27824c7..175a797 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java @@ -43,29 +43,12 @@ class SaveOverflow { @BeforeEach void setUp() { storage.clear(); - - IntStream.iterate(0, n -> n + 1). - limit(AbstractArrayStorage.STORAGE_LIMIT). - mapToObj(i -> new Resume("Name" + i)). - forEach(storage::save); } @Test - @DisplayName("Should not throw within size limit") - void shouldNotThrow() { - String uuid = "New item"; - if (storage.size() < AbstractArrayStorage.STORAGE_LIMIT) { - storage.save(new Resume(uuid)); - assertDoesNotThrow(() -> { - }); - } - } - - @Test - @DisplayName("Should throw correct exception if overflown") - void shouldThrowCorrectException() { - + @DisplayName("Should not throw within size limit, then throws when overflow") + void fill() { // arrange String uuid = "New item"; Executable throwingExecutable = () -> { @@ -73,6 +56,13 @@ void shouldThrowCorrectException() { }; // act and assert + assertDoesNotThrow(() -> { + IntStream.iterate(0, n -> n + 1). + limit(AbstractArrayStorage.STORAGE_LIMIT). + mapToObj(i -> new Resume("Name" + i)). + forEach(storage::save); + }); + RuntimeException thrown = assertThrows( StorageException.class, throwingExecutable::execute, "Should throw non specialized StorageException" ); From 0a31ed879257eacfebfc289fa308bbd2d1fbb6ed Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Mon, 5 Aug 2019 22:46:22 +0300 Subject: [PATCH 06/18] rev3 --- .../storage/AbstractArrayStorageTest.java | 70 ++++++++----------- .../ru/javawebinar/basejava/storage/Util.java | 16 ++--- .../storage/impl/ArrayStorageTest.java | 2 +- .../storage/impl/SortedArrayStorageTest.java | 2 +- 4 files changed, 38 insertions(+), 52 deletions(-) diff --git a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java index 175a797..6d5ab9e 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java @@ -21,15 +21,11 @@ protected AbstractArrayStorageTest(Storage storage) { this.storage = storage; } - @BeforeAll - static void beforeAll() { - } - @BeforeEach void beforeEach() { - storage.save(r1); - storage.save(r2); - storage.save(r3); + storage.save(R1); + storage.save(R2); + storage.save(R3); } @AfterEach @@ -45,7 +41,6 @@ void setUp() { storage.clear(); } - @Test @DisplayName("Should not throw within size limit, then throws when overflow") void fill() { @@ -64,7 +59,7 @@ void fill() { }); RuntimeException thrown = assertThrows( - StorageException.class, throwingExecutable::execute, "Should throw non specialized StorageException" + StorageException.class, throwingExecutable::execute, "Should throw generic StorageException" ); assertEquals("Storage overflow", thrown.getMessage()); @@ -72,60 +67,59 @@ void fill() { } @Test - public void size() throws Exception { + void size() throws Exception { assertEquals(3, storage.size()); } @Test - public void clear() throws Exception { + void clear() throws Exception { storage.clear(); assertEquals(0, storage.size()); } @Test - public void update() throws Exception { - Resume r2new = makeResume(UUID_2); - storage.update(r2new); + void update() throws Exception { + Resume r2New = new Resume(UUID_2); + storage.update(r2New); - assertSame(storage.get(UUID_2), r2new); + assertSame(r2New, storage.get(UUID_2)); } @Test - public void updateNonExisting() { + void updateNonExisting() { assertThrows( NotExistStorageException.class, - () -> { - storage.update(makeResume("dummy")); - } + () -> storage.update(new Resume("dummy")) ); } @Test - public void getAll() throws Exception { - Resume[] test = new Resume[]{r1, r2, r3}; + void getAll() throws Exception { + Resume[] test = new Resume[]{R1, R2, R3}; + assertEquals(3, storage.getAll().length); assertArrayEquals(test, storage.getAll()); } @Test - public void save() throws Exception { - String newUuid = UUID_4; - Resume r4 = makeResume(newUuid); - + void save() throws Exception { + Resume r4 = new Resume(UUID_4); storage.save(r4); - assertEquals(newUuid, storage.get(newUuid).getUuid()); + + assertEquals(4, storage.getAll().length); + assertSame(r4, storage.get(UUID_4)); } @Test - public void saveExisting() throws Exception { + void saveExisting() throws Exception { assertThrows(ExistStorageException.class, - () -> storage.save(new Resume(UUID_1))); + () -> storage.save(R1)); } + @Test - public void delete() throws Exception { + void delete() throws Exception { storage.delete(UUID_2); - assertAll("storage size is decreased, and access to deleted item correctly throws", () -> assertEquals(2, storage.size()), () -> assertThrows(NotExistStorageException.class, @@ -134,27 +128,23 @@ public void delete() throws Exception { } @Test - public void deleteNonExisting() { + void deleteNonExisting() { assertThrows( NotExistStorageException.class, - () -> { - storage.delete("dummy"); - } + () -> storage.delete("dummy") ); } @Test - public void get() throws Exception { - assertSame(r1, storage.get(UUID_1)); + void get() throws Exception { + assertSame(R1, storage.get(UUID_1)); } @Test - public void getNonExisting() { + void getNonExisting() { assertThrows( NotExistStorageException.class, - () -> { - storage.get("dummy"); - } + () -> storage.get("dummy") ); } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/Util.java b/test/ru/javawebinar/basejava/storage/Util.java index 8e5c658..e4587c3 100644 --- a/test/ru/javawebinar/basejava/storage/Util.java +++ b/test/ru/javawebinar/basejava/storage/Util.java @@ -8,17 +8,13 @@ class Util { static final String UUID_3 = "uuid3"; static final String UUID_4 = "uuid4"; - static final Resume r1; - static final Resume r2; - static final Resume r3; - - static Resume makeResume(String uuid){ - return new Resume(uuid); - } + static final Resume R1; + static final Resume R2; + static final Resume R3; static { - r1 = makeResume(UUID_1); - r2 = makeResume(UUID_2); - r3 = makeResume(UUID_3); + R1 = new Resume(UUID_1); + R2 = new Resume(UUID_2); + R3 = new Resume(UUID_3); } } diff --git a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java index 4d9bcdb..2430475 100644 --- a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java @@ -3,7 +3,7 @@ import org.junit.jupiter.api.DisplayName; import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; -@DisplayName("ArrayStorage implementstion") +@DisplayName("Test ArrayStorage implementation") public class ArrayStorageTest extends AbstractArrayStorageTest { public ArrayStorageTest() { diff --git a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java index 384a34b..269dd2d 100644 --- a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java @@ -3,7 +3,7 @@ import org.junit.jupiter.api.DisplayName; import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; -@DisplayName("SortedArrayStorage implementstion") +@DisplayName("Test SortedArrayStorage implementation") public class SortedArrayStorageTest extends AbstractArrayStorageTest { public SortedArrayStorageTest() { From 4dca19f9969be7fc86b4e8daf6de87d115607c6b Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Thu, 15 Aug 2019 17:44:40 +0300 Subject: [PATCH 07/18] ListStorage with tests --- src/ru/javawebinar/basejava/MainArray.java | 5 +- .../javawebinar/basejava/MainCollections.java | 58 ++++++++ .../storage/AbstractArrayStorage.java | 67 ++++----- .../basejava/storage/AbstractStorage.java | 67 +++++++++ .../javawebinar/basejava/storage/Storage.java | 6 +- .../basejava/storage/impl/ArrayStorage.java | 6 +- .../basejava/storage/impl/ListStorage.java | 58 ++++++++ .../storage/impl/SortedArrayStorage.java | 4 +- .../storage/AbstractArrayStorageTest.java | 107 +-------------- .../basejava/storage/AbstractStorageTest.java | 128 ++++++++++++++++++ .../storage/impl/ArrayStorageTest.java | 2 +- .../storage/impl/ListStorageTest.java | 17 +++ .../storage/impl/SortedArrayStorageTest.java | 2 +- 13 files changed, 375 insertions(+), 152 deletions(-) create mode 100644 src/ru/javawebinar/basejava/MainCollections.java create mode 100644 src/ru/javawebinar/basejava/storage/AbstractStorage.java create mode 100644 src/ru/javawebinar/basejava/storage/impl/ListStorage.java create mode 100644 test/ru/javawebinar/basejava/storage/AbstractStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java diff --git a/src/ru/javawebinar/basejava/MainArray.java b/src/ru/javawebinar/basejava/MainArray.java index 2f812b8..9b5d114 100644 --- a/src/ru/javawebinar/basejava/MainArray.java +++ b/src/ru/javawebinar/basejava/MainArray.java @@ -7,6 +7,7 @@ import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; +import java.util.List; /** * Test for ru.javawebinar.basejava.storage.impl.ArrayStorage @@ -66,9 +67,9 @@ public static void main(String[] args) throws IOException { } static void printAll() { - Resume[] all = ARRAY_STORAGE.getAll(); + List all = ARRAY_STORAGE.getAll(); System.out.println("----------------------------"); - if (all.length == 0) { + if (all.size() == 0) { System.out.println("Empty"); } else { for (Resume r : all) { diff --git a/src/ru/javawebinar/basejava/MainCollections.java b/src/ru/javawebinar/basejava/MainCollections.java new file mode 100644 index 0000000..5b7077f --- /dev/null +++ b/src/ru/javawebinar/basejava/MainCollections.java @@ -0,0 +1,58 @@ +package ru.javawebinar.basejava; + +import ru.javawebinar.basejava.model.Resume; + +import java.util.*; + +public class MainCollections { + private static final String UUID_1 = "uuid1"; + private static final Resume RESUME_1 = new Resume(UUID_1); + + private static final String UUID_2 = "uuid2"; + private static final Resume RESUME_2 = new Resume(UUID_2); + + private static final String UUID_3 = "uuid3"; + private static final Resume RESUME_3 = new Resume(UUID_3); + + private static final String UUID_4 = "uuid4"; + private static final Resume RESUME_4 = new Resume(UUID_4); + + public static void main(String[] args) { + Collection collection = new ArrayList<>(); + collection.add(RESUME_1); + collection.add(RESUME_2); + collection.add(RESUME_3); + + for (Resume r : collection) { + System.out.println(r); + if (Objects.equals(r.getUuid(), UUID_1)) { +// collection.remove(r); + } + } + + Iterator iterator = collection.iterator(); + while (iterator.hasNext()) { + Resume r = iterator.next(); + System.out.println(r); + if (Objects.equals(r.getUuid(), UUID_1)) { + iterator.remove(); + } + } + System.out.println(collection.toString()); + + + Map map = new HashMap<>(); + map.put(UUID_1, RESUME_1); + map.put(UUID_2, RESUME_2); + map.put(UUID_3, RESUME_3); + + // Bad! + for (String uuid : map.keySet()) { + System.out.println(map.get(uuid)); + } + + for (Map.Entry entry : map.entrySet()) { + System.out.println(entry.getValue()); + } + } +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java index 3971b8d..c82b61a 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java @@ -1,21 +1,26 @@ package ru.javawebinar.basejava.storage; -import ru.javawebinar.basejava.exception.ExistStorageException; -import ru.javawebinar.basejava.exception.NotExistStorageException; import ru.javawebinar.basejava.exception.StorageException; import ru.javawebinar.basejava.model.Resume; import java.util.Arrays; +import java.util.List; /** * Array based storage for Resumes */ -public abstract class AbstractArrayStorage implements Storage { +public abstract class AbstractArrayStorage extends AbstractStorage { protected static final int STORAGE_LIMIT = 10000; protected Resume[] storage = new Resume[STORAGE_LIMIT]; protected int size = 0; + protected abstract void implDelete(int index); + + protected abstract void implSave(int index, Resume r); + + protected abstract int getIndex(String uuid); + public int size() { return size; } @@ -25,56 +30,34 @@ public void clear() { size = 0; } - public void update(Resume r) { - int index = getIndex(r.getUuid()); - if (index < 0) { - throw new NotExistStorageException(r.getUuid()); - } else { - storage[index] = r; - } + public void doUpdate(int index, Resume r) { + storage[index] = r; + } + + public Resume doGet(int index) { + return storage[index]; + } + + public void doDelete(int index) { + implDelete(index); + storage[size - 1] = null; + size--; } /** * @return array, contains only Resumes in storage (without null) */ - public Resume[] getAll() { - return Arrays.copyOfRange(storage, 0, size); + public List toList() { + return Arrays.asList(Arrays.copyOfRange(storage, 0, size)); } - public void save(Resume r) { - int index = getIndex(r.getUuid()); - if (index >= 0) { - throw new ExistStorageException(r.getUuid()); - } else if (size == STORAGE_LIMIT) { + public void doSave(int index, Resume r) { + if (size == STORAGE_LIMIT) { throw new StorageException("Storage overflow", r.getUuid()); } else { - doSave(r, index); + implSave(index, r); size++; } } - public void delete(String uuid) { - int index = getIndex(uuid); - if (index < 0) { - throw new NotExistStorageException(uuid); - } else { - doDelete(index); - storage[size - 1] = null; - size--; - } - } - - public Resume get(String uuid) { - int index = getIndex(uuid); - if (index < 0) { - throw new NotExistStorageException(uuid); - } - return storage[index]; - } - - protected abstract void doDelete(int index); - - protected abstract void doSave(Resume r, int index); - - protected abstract int getIndex(String uuid); } \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/AbstractStorage.java b/src/ru/javawebinar/basejava/storage/AbstractStorage.java new file mode 100644 index 0000000..2e3e602 --- /dev/null +++ b/src/ru/javawebinar/basejava/storage/AbstractStorage.java @@ -0,0 +1,67 @@ +package ru.javawebinar.basejava.storage; + +import ru.javawebinar.basejava.exception.ExistStorageException; +import ru.javawebinar.basejava.exception.NotExistStorageException; +import ru.javawebinar.basejava.model.Resume; + +import java.util.List; + +public abstract class AbstractStorage implements Storage { + + protected abstract void doSave(int index, Resume r); + + protected abstract void doUpdate(int index, Resume r); + + protected abstract Resume doGet(int index); + + protected abstract void doDelete(int index); + + protected abstract int getIndex(String uuid); + + protected abstract List toList(); + + @Override + public void save(Resume r) { + int index = getNotExistingKey(r.getUuid()); + doSave(index, r); + } + + @Override + public void update(Resume r) { + int index = getExistingKey(r.getUuid()); + doUpdate(index, r); + } + + @Override + public void delete(String uuid) { + int index = getExistingKey(uuid); + doDelete(index); + } + + @Override + public Resume get(String uuid) { + int index = getExistingKey(uuid); + return doGet(index); + } + + @Override + public List getAll(){ + return toList(); + } + + protected int getExistingKey(String uuid) { + int index = getIndex(uuid); + if (index < 0) { + throw new NotExistStorageException(uuid); + } + return index; + } + + protected int getNotExistingKey(String uuid) { + int index = getIndex(uuid); + if (index >= 0) { + throw new ExistStorageException(uuid); + } + return index; + } +} diff --git a/src/ru/javawebinar/basejava/storage/Storage.java b/src/ru/javawebinar/basejava/storage/Storage.java index 2f7a1d9..fe2cdf2 100644 --- a/src/ru/javawebinar/basejava/storage/Storage.java +++ b/src/ru/javawebinar/basejava/storage/Storage.java @@ -2,6 +2,8 @@ import ru.javawebinar.basejava.model.Resume; +import java.util.List; + public interface Storage { void clear(); @@ -14,7 +16,9 @@ public interface Storage { void delete(String uuid); - Resume[] getAll(); +// Resume[] getAll(); + + List getAll(); int size(); } \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java index 981e3bd..b413dd0 100644 --- a/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java @@ -3,18 +3,20 @@ import ru.javawebinar.basejava.model.Resume; import ru.javawebinar.basejava.storage.AbstractArrayStorage; +import java.util.Arrays; + /** * Array based storage for Resumes */ public class ArrayStorage extends AbstractArrayStorage { @Override - protected void doDelete(int index) { + protected void implDelete(int index) { storage[index] = storage[size - 1]; } @Override - protected void doSave(Resume r, int index) { + protected void implSave(int index, Resume r) { storage[size] = r; } diff --git a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java new file mode 100644 index 0000000..66b1191 --- /dev/null +++ b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java @@ -0,0 +1,58 @@ +package ru.javawebinar.basejava.storage.impl; + +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.AbstractStorage; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +public class ListStorage extends AbstractStorage { + + private List list = new ArrayList<>(); + + @Override + protected void doSave(int index, Resume r) { + list.add(r); + } + + @Override + protected void doUpdate(int index, Resume r) { + list.set(index, r); + } + + @Override + protected Resume doGet(int index) { + return list.get(index); + } + + @Override + protected void doDelete(int index) { + list.remove(index); + } + + @Override + protected int getIndex(String uuid) { + for (int i = 0; i < list.size(); i++) { + if (uuid.equals(list.get(i).getUuid())) { + return i; + } + } + return -1; + } + + @Override + protected List toList() { + return list; + } + + @Override + public void clear() { + list.clear(); + } + + @Override + public int size() { + return list.size(); + } +} diff --git a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java index aef2646..6e2c2f6 100644 --- a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java @@ -8,7 +8,7 @@ public class SortedArrayStorage extends AbstractArrayStorage { @Override - protected void doDelete(int index) { + protected void implDelete(int index) { int numMoved = size - index - 1; if (numMoved > 0) { System.arraycopy(storage, index + 1, storage, index, numMoved); @@ -16,7 +16,7 @@ protected void doDelete(int index) { } @Override - protected void doSave(Resume r, int index) { + protected void implSave(int index, Resume r) { int insert = -index - 1; System.arraycopy(storage, insert, storage, insert + 1, size - insert); storage[insert] = r; diff --git a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java index 6d5ab9e..690bd9f 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java @@ -1,37 +1,24 @@ package ru.javawebinar.basejava.storage; -import org.junit.jupiter.api.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; import org.junit.jupiter.api.function.Executable; -import ru.javawebinar.basejava.exception.ExistStorageException; -import ru.javawebinar.basejava.exception.NotExistStorageException; import ru.javawebinar.basejava.exception.StorageException; import ru.javawebinar.basejava.model.Resume; import java.util.stream.IntStream; import static org.junit.jupiter.api.Assertions.*; -import static ru.javawebinar.basejava.storage.Util.*; -public abstract class AbstractArrayStorageTest { - - private Storage storage; +public abstract class AbstractArrayStorageTest extends AbstractStorageTest { protected AbstractArrayStorageTest(Storage storage) { - this.storage = storage; - } - - @BeforeEach - void beforeEach() { - storage.save(R1); - storage.save(R2); - storage.save(R3); + super(storage); } - @AfterEach - void afterEach() { - storage.clear(); - } @Nested class SaveOverflow { @@ -65,86 +52,4 @@ void fill() { assertEquals("Storage overflow", thrown.getMessage()); } } - - @Test - void size() throws Exception { - assertEquals(3, storage.size()); - } - - @Test - void clear() throws Exception { - storage.clear(); - assertEquals(0, storage.size()); - } - - @Test - void update() throws Exception { - Resume r2New = new Resume(UUID_2); - storage.update(r2New); - - assertSame(r2New, storage.get(UUID_2)); - } - - @Test - void updateNonExisting() { - assertThrows( - NotExistStorageException.class, - () -> storage.update(new Resume("dummy")) - ); - } - - - @Test - void getAll() throws Exception { - Resume[] test = new Resume[]{R1, R2, R3}; - assertEquals(3, storage.getAll().length); - assertArrayEquals(test, storage.getAll()); - } - - @Test - void save() throws Exception { - Resume r4 = new Resume(UUID_4); - storage.save(r4); - - assertEquals(4, storage.getAll().length); - assertSame(r4, storage.get(UUID_4)); - } - - @Test - void saveExisting() throws Exception { - assertThrows(ExistStorageException.class, - () -> storage.save(R1)); - } - - - @Test - void delete() throws Exception { - storage.delete(UUID_2); - assertAll("storage size is decreased, and access to deleted item correctly throws", - () -> assertEquals(2, storage.size()), - () -> assertThrows(NotExistStorageException.class, - () -> storage.get(UUID_2)) - ); - } - - @Test - void deleteNonExisting() { - assertThrows( - NotExistStorageException.class, - () -> storage.delete("dummy") - ); - } - - @Test - void get() throws Exception { - assertSame(R1, storage.get(UUID_1)); - } - - @Test - void getNonExisting() { - assertThrows( - NotExistStorageException.class, - () -> storage.get("dummy") - ); - } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java new file mode 100644 index 0000000..0dd8403 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java @@ -0,0 +1,128 @@ +package ru.javawebinar.basejava.storage; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import ru.javawebinar.basejava.exception.ExistStorageException; +import ru.javawebinar.basejava.exception.NotExistStorageException; +import ru.javawebinar.basejava.model.Resume; + +import java.util.Arrays; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static ru.javawebinar.basejava.storage.Util.*; + +public class AbstractStorageTest { + protected Storage storage; + + protected AbstractStorageTest(Storage storage) { + this.storage = storage; + } + + @BeforeEach + void beforeEach() { + storage.save(R1); + storage.save(R2); + storage.save(R3); + } + + @AfterEach + void afterEach() { + storage.clear(); + } + + @Test + void size() throws Exception { + assertSize(3); + } + + @Test + void clear() throws Exception { + storage.clear(); + assertSize(0); + } + + + @Test + void update() throws Exception { + Resume r2New = new Resume(UUID_2); + storage.update(r2New); + + assertSame(r2New, storage.get(UUID_2)); + } + + + @Test + void updateNonExisting() { + assertThrows( + NotExistStorageException.class, + () -> storage.update(new Resume("dummy")) + ); + } + + @Test + void save() throws Exception { + Resume r4 = new Resume(UUID_4); + storage.save(r4); + + assertEquals(4, storage.getAll().size()); + assertSame(r4, storage.get(UUID_4)); + } + + + @Test + void saveExisting() throws Exception { + assertThrows(ExistStorageException.class, + () -> storage.save(R1)); + } + + + @Test + void delete() throws Exception { + storage.delete(UUID_2); + assertAll("storage size is decreased, and access to deleted item correctly throws", + () -> assertEquals(2, storage.size()), + () -> assertThrows(NotExistStorageException.class, + () -> storage.get(UUID_2)) + ); + } + + @Test + void deleteNonExisting() { + assertThrows( + NotExistStorageException.class, + () -> storage.delete("dummy") + ); + } + + + + @Test + void getAll() throws Exception { + List test = Arrays.asList(R1, R2, R3); + assertEquals(3, storage.getAll().size()); + assertEquals(test, storage.getAll()); + } + + @Test + void get() throws Exception { + assertGet(R1); + } + + @Test + void getNonExisting() { + assertThrows( + NotExistStorageException.class, + () -> storage.get("dummy") + ); + } + + private void assertGet(Resume r) { + assertEquals(r, storage.get(r.getUuid())); + } + + private void assertSize(int size) { + assertEquals(size, storage.size()); + } +} diff --git a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java index 2430475..c4a303b 100644 --- a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java @@ -3,7 +3,7 @@ import org.junit.jupiter.api.DisplayName; import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; -@DisplayName("Test ArrayStorage implementation") +@DisplayName("ArrayStorage implementation") public class ArrayStorageTest extends AbstractArrayStorageTest { public ArrayStorageTest() { diff --git a/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java new file mode 100644 index 0000000..6bfe846 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java @@ -0,0 +1,17 @@ +package ru.javawebinar.basejava.storage.impl; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import ru.javawebinar.basejava.storage.AbstractStorageTest; + +import static org.junit.jupiter.api.Assertions.*; + +@DisplayName("ListStorage implementation") +class ListStorageTest extends AbstractStorageTest{ + + public ListStorageTest() + { + super(new ListStorage()); + } +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java index 269dd2d..6b8c2aa 100644 --- a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java @@ -3,7 +3,7 @@ import org.junit.jupiter.api.DisplayName; import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; -@DisplayName("Test SortedArrayStorage implementation") +@DisplayName("SortedArrayStorage implementation") public class SortedArrayStorageTest extends AbstractArrayStorageTest { public SortedArrayStorageTest() { From 3ea2de6890484220b3011e6e2078d81b2c29ce04 Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Sat, 17 Aug 2019 13:53:43 +0300 Subject: [PATCH 08/18] reverted getAll() signature --- src/ru/javawebinar/basejava/MainArray.java | 4 ++-- .../storage/AbstractArrayStorage.java | 7 ++---- .../basejava/storage/AbstractStorage.java | 7 ------ .../javawebinar/basejava/storage/Storage.java | 4 ++-- .../basejava/storage/impl/ListStorage.java | 8 +++---- .../storage/AbstractArrayStorageTest.java | 4 ++++ .../basejava/storage/AbstractStorageTest.java | 24 +++++++++++-------- .../storage/impl/ListStorageTest.java | 4 ++++ .../basejava/storage/impl/MapStorageTest.java | 18 ++++++++++++++ 9 files changed, 50 insertions(+), 30 deletions(-) create mode 100644 test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java diff --git a/src/ru/javawebinar/basejava/MainArray.java b/src/ru/javawebinar/basejava/MainArray.java index 9b5d114..248a0aa 100644 --- a/src/ru/javawebinar/basejava/MainArray.java +++ b/src/ru/javawebinar/basejava/MainArray.java @@ -67,9 +67,9 @@ public static void main(String[] args) throws IOException { } static void printAll() { - List all = ARRAY_STORAGE.getAll(); + Resume [] all = ARRAY_STORAGE.getAll(); System.out.println("----------------------------"); - if (all.size() == 0) { + if (all.length == 0) { System.out.println("Empty"); } else { for (Resume r : all) { diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java index c82b61a..e408c3e 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java @@ -44,11 +44,8 @@ public void doDelete(int index) { size--; } - /** - * @return array, contains only Resumes in storage (without null) - */ - public List toList() { - return Arrays.asList(Arrays.copyOfRange(storage, 0, size)); + public Resume[] getAll() { + return Arrays.copyOfRange(storage, 0, size); } public void doSave(int index, Resume r) { diff --git a/src/ru/javawebinar/basejava/storage/AbstractStorage.java b/src/ru/javawebinar/basejava/storage/AbstractStorage.java index 2e3e602..7a5f54b 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractStorage.java @@ -18,8 +18,6 @@ public abstract class AbstractStorage implements Storage { protected abstract int getIndex(String uuid); - protected abstract List toList(); - @Override public void save(Resume r) { int index = getNotExistingKey(r.getUuid()); @@ -44,11 +42,6 @@ public Resume get(String uuid) { return doGet(index); } - @Override - public List getAll(){ - return toList(); - } - protected int getExistingKey(String uuid) { int index = getIndex(uuid); if (index < 0) { diff --git a/src/ru/javawebinar/basejava/storage/Storage.java b/src/ru/javawebinar/basejava/storage/Storage.java index fe2cdf2..2ae2aae 100644 --- a/src/ru/javawebinar/basejava/storage/Storage.java +++ b/src/ru/javawebinar/basejava/storage/Storage.java @@ -16,9 +16,9 @@ public interface Storage { void delete(String uuid); -// Resume[] getAll(); + Resume[] getAll(); - List getAll(); +// List getAll(); int size(); } \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java index 66b1191..08ebca5 100644 --- a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java @@ -42,13 +42,13 @@ protected int getIndex(String uuid) { } @Override - protected List toList() { - return list; + public void clear() { + list.clear(); } @Override - public void clear() { - list.clear(); + public Resume[] getAll() { + return list.toArray(Resume[]::new); } @Override diff --git a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java index 690bd9f..dfa8e78 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java @@ -52,4 +52,8 @@ void fill() { assertEquals("Storage overflow", thrown.getMessage()); } } + + + + } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java index 0dd8403..470c074 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java @@ -13,13 +13,16 @@ import static org.junit.jupiter.api.Assertions.*; import static ru.javawebinar.basejava.storage.Util.*; -public class AbstractStorageTest { +public abstract class AbstractStorageTest { protected Storage storage; protected AbstractStorageTest(Storage storage) { this.storage = storage; } +// protected abstract void assertSize(int size); + + @BeforeEach void beforeEach() { storage.save(R1); @@ -66,7 +69,7 @@ void save() throws Exception { Resume r4 = new Resume(UUID_4); storage.save(r4); - assertEquals(4, storage.getAll().size()); + assertSize(4); assertSame(r4, storage.get(UUID_4)); } @@ -97,14 +100,14 @@ void deleteNonExisting() { } - @Test void getAll() throws Exception { - List test = Arrays.asList(R1, R2, R3); - assertEquals(3, storage.getAll().size()); - assertEquals(test, storage.getAll()); + Resume[] test = new Resume[]{R1, R2, R3}; + assertEquals(3, storage.getAll().length); + assertArrayEquals(test, storage.getAll()); } + @Test void get() throws Exception { assertGet(R1); @@ -118,11 +121,12 @@ void getNonExisting() { ); } - private void assertGet(Resume r) { - assertEquals(r, storage.get(r.getUuid())); - } - private void assertSize(int size) { + protected void assertSize(int size) { assertEquals(size, storage.size()); } + + private void assertGet(Resume r) { + assertEquals(r, storage.get(r.getUuid())); + } } diff --git a/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java index 6bfe846..e752fcf 100644 --- a/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java @@ -14,4 +14,8 @@ public ListStorageTest() { super(new ListStorage()); } +// +// protected void assertSize(int size) { +// assertEquals(size, storage.size()); +// } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java new file mode 100644 index 0000000..d081c1c --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java @@ -0,0 +1,18 @@ +package ru.javawebinar.basejava.storage.impl; + +import org.junit.jupiter.api.DisplayName; +import ru.javawebinar.basejava.storage.AbstractStorageTest; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +@DisplayName("MapStorage implementation") +public class MapStorageTest extends AbstractStorageTest { + public MapStorageTest() + { + super(new MapStorage()); + } + +// protected void assertSize(int size) { +// assertEquals(size, storage.size()); +// } +} From b7520658d0f6b5ec411e6913b02ff6a61fef383b Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Sat, 17 Aug 2019 16:14:55 +0300 Subject: [PATCH 09/18] implemented MapStorage --- src/ru/javawebinar/basejava/MainArray.java | 3 +- .../storage/AbstractArrayStorage.java | 30 ++++++---- .../basejava/storage/AbstractStorage.java | 34 +++++------ .../javawebinar/basejava/storage/Storage.java | 2 - .../basejava/storage/impl/ArrayStorage.java | 4 +- .../basejava/storage/impl/ListStorage.java | 24 ++++---- .../basejava/storage/impl/MapStorage.java | 60 +++++++++++++++++++ .../storage/impl/SortedArrayStorage.java | 2 +- .../storage/AbstractArrayStorageTest.java | 12 ++-- .../basejava/storage/AbstractStorageTest.java | 6 -- .../storage/impl/ListStorageTest.java | 14 +---- .../basejava/storage/impl/MapStorageTest.java | 9 +-- 12 files changed, 122 insertions(+), 78 deletions(-) create mode 100644 src/ru/javawebinar/basejava/storage/impl/MapStorage.java diff --git a/src/ru/javawebinar/basejava/MainArray.java b/src/ru/javawebinar/basejava/MainArray.java index 248a0aa..da69a13 100644 --- a/src/ru/javawebinar/basejava/MainArray.java +++ b/src/ru/javawebinar/basejava/MainArray.java @@ -1,13 +1,12 @@ package ru.javawebinar.basejava; import ru.javawebinar.basejava.model.Resume; -import ru.javawebinar.basejava.storage.impl.ArrayStorage; import ru.javawebinar.basejava.storage.Storage; +import ru.javawebinar.basejava.storage.impl.ArrayStorage; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; -import java.util.List; /** * Test for ru.javawebinar.basejava.storage.impl.ArrayStorage diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java index e408c3e..4656f95 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java @@ -4,7 +4,6 @@ import ru.javawebinar.basejava.model.Resume; import java.util.Arrays; -import java.util.List; /** * Array based storage for Resumes @@ -19,42 +18,53 @@ public abstract class AbstractArrayStorage extends AbstractStorage { protected abstract void implSave(int index, Resume r); - protected abstract int getIndex(String uuid); + protected abstract Object getIndex(String uuid); + @Override public int size() { return size; } + @Override public void clear() { Arrays.fill(storage, 0, size, null); size = 0; } - public void doUpdate(int index, Resume r) { - storage[index] = r; + @Override + public void doUpdate(Object index, Resume r) { + storage[(Integer)index] = r; } - public Resume doGet(int index) { - return storage[index]; + @Override + public Resume doGet(Object index) { + return storage[(Integer)index]; } - public void doDelete(int index) { - implDelete(index); + @Override + public void doDelete(Object index) { + implDelete((Integer)index); storage[size - 1] = null; size--; } + @Override public Resume[] getAll() { return Arrays.copyOfRange(storage, 0, size); } - public void doSave(int index, Resume r) { + @Override + public void doSave(Object index, Resume r) { if (size == STORAGE_LIMIT) { throw new StorageException("Storage overflow", r.getUuid()); } else { - implSave(index, r); + implSave((Integer)index, r); size++; } } + @Override + public boolean isPresent(Object index) { + return (Integer) index >= 0; + } } \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/AbstractStorage.java b/src/ru/javawebinar/basejava/storage/AbstractStorage.java index 7a5f54b..e53a5af 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractStorage.java @@ -4,55 +4,55 @@ import ru.javawebinar.basejava.exception.NotExistStorageException; import ru.javawebinar.basejava.model.Resume; -import java.util.List; - public abstract class AbstractStorage implements Storage { - protected abstract void doSave(int index, Resume r); + protected abstract void doSave(Object index, Resume r); + + protected abstract void doUpdate(Object index, Resume r); - protected abstract void doUpdate(int index, Resume r); + protected abstract Resume doGet(Object index); - protected abstract Resume doGet(int index); + protected abstract void doDelete(Object index); - protected abstract void doDelete(int index); + protected abstract Object getIndex(String uuid); - protected abstract int getIndex(String uuid); + protected abstract boolean isPresent(Object index); @Override public void save(Resume r) { - int index = getNotExistingKey(r.getUuid()); + Object index = getNotExistingKey(r.getUuid()); doSave(index, r); } @Override public void update(Resume r) { - int index = getExistingKey(r.getUuid()); + Object index = getExistingKey(r.getUuid()); doUpdate(index, r); } @Override public void delete(String uuid) { - int index = getExistingKey(uuid); + Object index = getExistingKey(uuid); doDelete(index); } @Override public Resume get(String uuid) { - int index = getExistingKey(uuid); + Object index = getExistingKey(uuid); return doGet(index); } - protected int getExistingKey(String uuid) { - int index = getIndex(uuid); - if (index < 0) { + protected Object getExistingKey(String uuid) { + Object index = getIndex(uuid); + if (!isPresent(index)) { throw new NotExistStorageException(uuid); } return index; } - protected int getNotExistingKey(String uuid) { - int index = getIndex(uuid); - if (index >= 0) { + protected Object getNotExistingKey(String uuid) { + Object index = getIndex(uuid); + if (isPresent(index)) { throw new ExistStorageException(uuid); } return index; diff --git a/src/ru/javawebinar/basejava/storage/Storage.java b/src/ru/javawebinar/basejava/storage/Storage.java index 2ae2aae..992a445 100644 --- a/src/ru/javawebinar/basejava/storage/Storage.java +++ b/src/ru/javawebinar/basejava/storage/Storage.java @@ -2,8 +2,6 @@ import ru.javawebinar.basejava.model.Resume; -import java.util.List; - public interface Storage { void clear(); diff --git a/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java index b413dd0..f9e28d7 100644 --- a/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java @@ -3,8 +3,6 @@ import ru.javawebinar.basejava.model.Resume; import ru.javawebinar.basejava.storage.AbstractArrayStorage; -import java.util.Arrays; - /** * Array based storage for Resumes */ @@ -21,7 +19,7 @@ protected void implSave(int index, Resume r) { } @Override - protected int getIndex(String uuid) { + protected Object getIndex(String uuid) { for (int i = 0; i < size; i++) { if (uuid.equals(storage[i].getUuid())) { return i; diff --git a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java index 08ebca5..d512a93 100644 --- a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java @@ -5,40 +5,44 @@ import java.util.ArrayList; import java.util.List; -import java.util.Optional; public class ListStorage extends AbstractStorage { private List list = new ArrayList<>(); @Override - protected void doSave(int index, Resume r) { + protected void doSave(Object index, Resume r) { list.add(r); } @Override - protected void doUpdate(int index, Resume r) { - list.set(index, r); + protected void doUpdate(Object index, Resume r) { + list.set((int) index, r); } @Override - protected Resume doGet(int index) { - return list.get(index); + protected Resume doGet(Object index) { + return list.get((int) index); } @Override - protected void doDelete(int index) { - list.remove(index); + protected void doDelete(Object index) { + list.remove(((int) index)); } @Override - protected int getIndex(String uuid) { + protected Object getIndex(String uuid) { for (int i = 0; i < list.size(); i++) { if (uuid.equals(list.get(i).getUuid())) { return i; } } - return -1; + return null; + } + + @Override + protected boolean isPresent(Object index) { + return index != null; } @Override diff --git a/src/ru/javawebinar/basejava/storage/impl/MapStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapStorage.java new file mode 100644 index 0000000..ef777e1 --- /dev/null +++ b/src/ru/javawebinar/basejava/storage/impl/MapStorage.java @@ -0,0 +1,60 @@ +package ru.javawebinar.basejava.storage.impl; + +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.AbstractStorage; + +import java.util.HashMap; +import java.util.Map; + +public class MapStorage extends AbstractStorage { + + private Map map = new HashMap<>(); + + + @Override + protected void doSave(Object index, Resume r) { + map.put((String)index,r); + } + + @Override + protected void doUpdate(Object index, Resume r) { + map.put((String)index,r); + } + + @Override + protected Resume doGet(Object index) { + return map.get(index); + } + + @Override + protected void doDelete(Object index) { + map.remove(index); + } + + @Override + protected Object getIndex(String uuid) { + return uuid; + } + + @Override + protected boolean isPresent(Object index) { + return map.containsKey(index); + } + + @Override + public void clear() { + map.clear(); + } + + @Override + public Resume[] getAll() { + return map.values().stream() + .sorted(Resume::compareTo) + .toArray(Resume[]::new); + } + + @Override + public int size() { + return map.size(); + } +} diff --git a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java index 6e2c2f6..0958689 100644 --- a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java @@ -23,7 +23,7 @@ protected void implSave(int index, Resume r) { } @Override - protected int getIndex(String uuid) { + protected Object getIndex(String uuid) { Resume searchKey = new Resume(uuid); return Arrays.binarySearch(storage, 0, size, searchKey); } diff --git a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java index dfa8e78..73f1d88 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java @@ -38,15 +38,13 @@ void fill() { }; // act and assert - assertDoesNotThrow(() -> { - IntStream.iterate(0, n -> n + 1). - limit(AbstractArrayStorage.STORAGE_LIMIT). - mapToObj(i -> new Resume("Name" + i)). - forEach(storage::save); - }); + assertDoesNotThrow(() -> IntStream.iterate(0, n -> n + 1). + limit(AbstractArrayStorage.STORAGE_LIMIT). + mapToObj(i -> new Resume("Name" + i)). + forEach(storage::save)); RuntimeException thrown = assertThrows( - StorageException.class, throwingExecutable::execute, "Should throw generic StorageException" + StorageException.class, throwingExecutable, "Should throw generic StorageException" ); assertEquals("Storage overflow", thrown.getMessage()); diff --git a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java index 470c074..06f6a27 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java @@ -7,9 +7,6 @@ import ru.javawebinar.basejava.exception.NotExistStorageException; import ru.javawebinar.basejava.model.Resume; -import java.util.Arrays; -import java.util.List; - import static org.junit.jupiter.api.Assertions.*; import static ru.javawebinar.basejava.storage.Util.*; @@ -20,9 +17,6 @@ protected AbstractStorageTest(Storage storage) { this.storage = storage; } -// protected abstract void assertSize(int size); - - @BeforeEach void beforeEach() { storage.save(R1); diff --git a/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java index e752fcf..ac30618 100644 --- a/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java @@ -1,21 +1,11 @@ package ru.javawebinar.basejava.storage.impl; -import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; import ru.javawebinar.basejava.storage.AbstractStorageTest; -import static org.junit.jupiter.api.Assertions.*; - @DisplayName("ListStorage implementation") -class ListStorageTest extends AbstractStorageTest{ - - public ListStorageTest() - { +class ListStorageTest extends AbstractStorageTest { + public ListStorageTest() { super(new ListStorage()); } -// -// protected void assertSize(int size) { -// assertEquals(size, storage.size()); -// } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java index d081c1c..3625069 100644 --- a/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java @@ -3,16 +3,9 @@ import org.junit.jupiter.api.DisplayName; import ru.javawebinar.basejava.storage.AbstractStorageTest; -import static org.junit.jupiter.api.Assertions.assertEquals; - @DisplayName("MapStorage implementation") public class MapStorageTest extends AbstractStorageTest { - public MapStorageTest() - { + public MapStorageTest() { super(new MapStorage()); } - -// protected void assertSize(int size) { -// assertEquals(size, storage.size()); -// } } From b4eda72f621d788b440c1fd8450df6b9a81c3ac0 Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Mon, 19 Aug 2019 02:09:54 +0300 Subject: [PATCH 10/18] implemented MapStorage --- .../javawebinar/basejava/storage/AbstractArrayStorageTest.java | 3 --- test/ru/javawebinar/basejava/storage/AbstractStorageTest.java | 1 + 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java index 73f1d88..1639fe4 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java @@ -51,7 +51,4 @@ void fill() { } } - - - } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java index 06f6a27..6b4f9a8 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java @@ -19,6 +19,7 @@ protected AbstractStorageTest(Storage storage) { @BeforeEach void beforeEach() { + storage.clear(); storage.save(R1); storage.save(R2); storage.save(R3); From 9c1b77e0729dfbabc8808c0ed691662da80d82f2 Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Fri, 23 Aug 2019 13:28:14 +0300 Subject: [PATCH 11/18] aligned with master --- src/ru/javawebinar/basejava/MainArray.java | 2 +- .../basejava/MainTestArrayStorage.java | 2 +- .../storage/AbstractArrayStorage.java | 51 ++++++++------- .../basejava/storage/AbstractStorage.java | 54 ++++++++-------- .../basejava/storage/impl/ArrayStorage.java | 10 ++- .../basejava/storage/impl/ListStorage.java | 39 ++++++------ .../basejava/storage/impl/MapStorage.java | 60 ------------------ .../basejava/storage/impl/MapUuidStorage.java | 62 +++++++++++++++++++ .../storage/impl/SortedArrayStorage.java | 31 +++++++--- .../basejava/storage/MapUuidStorageTest.java | 29 +++++++++ .../storage/impl/ArrayStorageTest.java | 1 + .../basejava/storage/impl/MapStorageTest.java | 11 ---- 12 files changed, 191 insertions(+), 161 deletions(-) delete mode 100644 src/ru/javawebinar/basejava/storage/impl/MapStorage.java create mode 100644 src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java create mode 100644 test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java delete mode 100644 test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java diff --git a/src/ru/javawebinar/basejava/MainArray.java b/src/ru/javawebinar/basejava/MainArray.java index da69a13..5688707 100644 --- a/src/ru/javawebinar/basejava/MainArray.java +++ b/src/ru/javawebinar/basejava/MainArray.java @@ -1,8 +1,8 @@ package ru.javawebinar.basejava; import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.ArrayStorage; import ru.javawebinar.basejava.storage.Storage; -import ru.javawebinar.basejava.storage.impl.ArrayStorage; import java.io.BufferedReader; import java.io.IOException; diff --git a/src/ru/javawebinar/basejava/MainTestArrayStorage.java b/src/ru/javawebinar/basejava/MainTestArrayStorage.java index dad5b1b..1c795fe 100644 --- a/src/ru/javawebinar/basejava/MainTestArrayStorage.java +++ b/src/ru/javawebinar/basejava/MainTestArrayStorage.java @@ -1,7 +1,7 @@ package ru.javawebinar.basejava; import ru.javawebinar.basejava.model.Resume; -import ru.javawebinar.basejava.storage.impl.ArrayStorage; +import ru.javawebinar.basejava.storage.ArrayStorage; /** * Test ru.javawebinar.basejava.storage.impl.ArrayStorage diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java index 4656f95..2736117 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java @@ -14,57 +14,56 @@ public abstract class AbstractArrayStorage extends AbstractStorage { protected Resume[] storage = new Resume[STORAGE_LIMIT]; protected int size = 0; - protected abstract void implDelete(int index); - - protected abstract void implSave(int index, Resume r); - - protected abstract Object getIndex(String uuid); - - @Override public int size() { return size; } - @Override public void clear() { Arrays.fill(storage, 0, size, null); size = 0; } @Override - public void doUpdate(Object index, Resume r) { - storage[(Integer)index] = r; - } - - @Override - public Resume doGet(Object index) { - return storage[(Integer)index]; - } - - @Override - public void doDelete(Object index) { - implDelete((Integer)index); - storage[size - 1] = null; - size--; + protected void doUpdate(Resume r, Object index) { + storage[(Integer) index] = r; } - @Override + /** + * @return array, contains only Resumes in storage (without null) + */ public Resume[] getAll() { return Arrays.copyOfRange(storage, 0, size); } @Override - public void doSave(Object index, Resume r) { + protected void doSave(Resume r, Object index) { if (size == STORAGE_LIMIT) { throw new StorageException("Storage overflow", r.getUuid()); } else { - implSave((Integer)index, r); + insertElement(r, (Integer) index); size++; } } @Override - public boolean isPresent(Object index) { + public void doDelete(Object index) { + fillDeletedElement((Integer) index); + storage[size - 1] = null; + size--; + } + + public Resume doGet(Object index) { + return storage[(Integer) index]; + } + + @Override + protected boolean isExist(Object index) { return (Integer) index >= 0; } + + protected abstract void fillDeletedElement(int index); + + protected abstract void insertElement(Resume r, int index); + + protected abstract Integer getSearchKey(String uuid); } \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/AbstractStorage.java b/src/ru/javawebinar/basejava/storage/AbstractStorage.java index e53a5af..ce813a8 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractStorage.java @@ -6,55 +6,51 @@ public abstract class AbstractStorage implements Storage { - protected abstract void doSave(Object index, Resume r); + protected abstract Object getSearchKey(String uuid); - protected abstract void doUpdate(Object index, Resume r); + protected abstract void doUpdate(Resume r, Object searchKey); - protected abstract Resume doGet(Object index); + protected abstract boolean isExist(Object searchKey); - protected abstract void doDelete(Object index); + protected abstract void doSave(Resume r, Object searchKey); - protected abstract Object getIndex(String uuid); + protected abstract Resume doGet(Object searchKey); - protected abstract boolean isPresent(Object index); + protected abstract void doDelete(Object searchKey); - @Override - public void save(Resume r) { - Object index = getNotExistingKey(r.getUuid()); - doSave(index, r); + public void update(Resume r) { + Object searchKey = getExistedSearchKey(r.getUuid()); + doUpdate(r, searchKey); } - @Override - public void update(Resume r) { - Object index = getExistingKey(r.getUuid()); - doUpdate(index, r); + public void save(Resume r) { + Object searchKey = getNotExistedSearchKey(r.getUuid()); + doSave(r, searchKey); } - @Override public void delete(String uuid) { - Object index = getExistingKey(uuid); - doDelete(index); + Object searchKey = getExistedSearchKey(uuid); + doDelete(searchKey); } - @Override public Resume get(String uuid) { - Object index = getExistingKey(uuid); - return doGet(index); + Object searchKey = getExistedSearchKey(uuid); + return doGet(searchKey); } - protected Object getExistingKey(String uuid) { - Object index = getIndex(uuid); - if (!isPresent(index)) { + private Object getExistedSearchKey(String uuid) { + Object searchKey = getSearchKey(uuid); + if (!isExist(searchKey)) { throw new NotExistStorageException(uuid); } - return index; + return searchKey; } - protected Object getNotExistingKey(String uuid) { - Object index = getIndex(uuid); - if (isPresent(index)) { + private Object getNotExistedSearchKey(String uuid) { + Object searchKey = getSearchKey(uuid); + if (isExist(searchKey)) { throw new ExistStorageException(uuid); } - return index; + return searchKey; } -} +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java index f9e28d7..b9722d8 100644 --- a/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java @@ -1,7 +1,6 @@ -package ru.javawebinar.basejava.storage.impl; +package ru.javawebinar.basejava.storage; import ru.javawebinar.basejava.model.Resume; -import ru.javawebinar.basejava.storage.AbstractArrayStorage; /** * Array based storage for Resumes @@ -9,17 +8,16 @@ public class ArrayStorage extends AbstractArrayStorage { @Override - protected void implDelete(int index) { + protected void fillDeletedElement(int index) { storage[index] = storage[size - 1]; } @Override - protected void implSave(int index, Resume r) { + protected void insertElement(Resume r, int index) { storage[size] = r; } - @Override - protected Object getIndex(String uuid) { + protected Integer getSearchKey(String uuid) { for (int i = 0; i < size; i++) { if (uuid.equals(storage[i].getUuid())) { return i; diff --git a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java index d512a93..ddb57d6 100644 --- a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java @@ -7,42 +7,41 @@ import java.util.List; public class ListStorage extends AbstractStorage { - private List list = new ArrayList<>(); @Override - protected void doSave(Object index, Resume r) { - list.add(r); + protected Integer getSearchKey(String uuid) { + for (int i = 0; i < list.size(); i++) { + if (list.get(i).getUuid().equals(uuid)) { + return i; + } + } + return null; } @Override - protected void doUpdate(Object index, Resume r) { - list.set((int) index, r); + protected boolean isExist(Object searchKey) { + return searchKey != null; } @Override - protected Resume doGet(Object index) { - return list.get((int) index); + protected void doUpdate(Resume r, Object searchKey) { + list.set((Integer) searchKey, r); } @Override - protected void doDelete(Object index) { - list.remove(((int) index)); + protected void doSave(Resume r, Object searchKey) { + list.add(r); } @Override - protected Object getIndex(String uuid) { - for (int i = 0; i < list.size(); i++) { - if (uuid.equals(list.get(i).getUuid())) { - return i; - } - } - return null; + protected Resume doGet(Object searchKey) { + return list.get((Integer) searchKey); } @Override - protected boolean isPresent(Object index) { - return index != null; + protected void doDelete(Object searchKey) { + list.remove(((Integer) searchKey).intValue()); } @Override @@ -52,11 +51,11 @@ public void clear() { @Override public Resume[] getAll() { - return list.toArray(Resume[]::new); + return list.toArray(new Resume[list.size()]); } @Override public int size() { return list.size(); } -} +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/impl/MapStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapStorage.java deleted file mode 100644 index ef777e1..0000000 --- a/src/ru/javawebinar/basejava/storage/impl/MapStorage.java +++ /dev/null @@ -1,60 +0,0 @@ -package ru.javawebinar.basejava.storage.impl; - -import ru.javawebinar.basejava.model.Resume; -import ru.javawebinar.basejava.storage.AbstractStorage; - -import java.util.HashMap; -import java.util.Map; - -public class MapStorage extends AbstractStorage { - - private Map map = new HashMap<>(); - - - @Override - protected void doSave(Object index, Resume r) { - map.put((String)index,r); - } - - @Override - protected void doUpdate(Object index, Resume r) { - map.put((String)index,r); - } - - @Override - protected Resume doGet(Object index) { - return map.get(index); - } - - @Override - protected void doDelete(Object index) { - map.remove(index); - } - - @Override - protected Object getIndex(String uuid) { - return uuid; - } - - @Override - protected boolean isPresent(Object index) { - return map.containsKey(index); - } - - @Override - public void clear() { - map.clear(); - } - - @Override - public Resume[] getAll() { - return map.values().stream() - .sorted(Resume::compareTo) - .toArray(Resume[]::new); - } - - @Override - public int size() { - return map.size(); - } -} diff --git a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java new file mode 100644 index 0000000..8cd8aa8 --- /dev/null +++ b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java @@ -0,0 +1,62 @@ +package ru.javawebinar.basejava.storage.impl; + +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.AbstractStorage; + +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; + +// TODO implement +// TODO create new MapStorage with search key not uuid +public class MapUuidStorage extends AbstractStorage { + private Map map = new HashMap<>(); + + @Override + protected String getSearchKey(String uuid) { + return uuid; + } + + @Override + protected void doUpdate(Resume r, Object searchKey) { + map.put((String) searchKey, r); + } + + @Override + protected boolean isExist(Object searchKey) { + return map.containsKey(searchKey); + } + + @Override + protected void doSave(Resume r, Object searchKey) { + map.put((String) searchKey, r); + } + + @Override + protected Resume doGet(Object searchKey) { + return map.get(searchKey); + } + + @Override + protected void doDelete(Object searchKey) { + map.remove(searchKey); + } + + @Override + public void clear() { + map.clear(); + } + + @Override + public Resume[] getAll() { + Collection values = map.values(); + return values.toArray(new Resume[map.size()]); +// Resume[] objects = values.toArray(new Resume[0]); +// return objects; + } + + @Override + public int size() { + return map.size(); + } +} \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java index 0958689..7482598 100644 --- a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java @@ -4,11 +4,27 @@ import ru.javawebinar.basejava.storage.AbstractArrayStorage; import java.util.Arrays; +import java.util.Comparator; public class SortedArrayStorage extends AbstractArrayStorage { +/* + private static class ResumeComparator implements Comparator { + @Override + public int compare(Resume o1, Resume o2) { + return o1.getUuid().compareTo(o2.getUuid()); + } + } +*/ + + private static final Comparator RESUME_COMPARATOR = new Comparator() { + @Override + public int compare(Resume o1, Resume o2) { + return o1.getUuid().compareTo(o2.getUuid()); + } + }; @Override - protected void implDelete(int index) { + protected void fillDeletedElement(int index) { int numMoved = size - index - 1; if (numMoved > 0) { System.arraycopy(storage, index + 1, storage, index, numMoved); @@ -16,15 +32,16 @@ protected void implDelete(int index) { } @Override - protected void implSave(int index, Resume r) { - int insert = -index - 1; - System.arraycopy(storage, insert, storage, insert + 1, size - insert); - storage[insert] = r; + protected void insertElement(Resume r, int index) { +// http://codereview.stackexchange.com/questions/36221/binary-search-for-inserting-in-array#answer-36239 + int insertIdx = -index - 1; + System.arraycopy(storage, insertIdx, storage, insertIdx + 1, size - insertIdx); + storage[insertIdx] = r; } @Override - protected Object getIndex(String uuid) { + protected Integer getSearchKey(String uuid) { Resume searchKey = new Resume(uuid); - return Arrays.binarySearch(storage, 0, size, searchKey); + return Arrays.binarySearch(storage, 0, size, searchKey, RESUME_COMPARATOR); } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java b/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java new file mode 100644 index 0000000..8594094 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java @@ -0,0 +1,29 @@ +package ru.javawebinar.basejava.storage; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.AbstractStorageTest; +import ru.javawebinar.basejava.storage.impl.MapUuidStorage; + +import java.util.Arrays; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static ru.javawebinar.basejava.storage.Util.*; + +@DisplayName("MapStorage implementation") +public class MapUuidStorageTest extends AbstractStorageTest { + public MapUuidStorageTest() { + super(new MapUuidStorage()); + } + + @Test + void getAll() throws Exception { + Resume[] test = new Resume[]{R1, R2, R3}; + Resume[] all = storage.getAll(); + Arrays.sort(all); + assertEquals(3, all.length); + assertArrayEquals(test, all); + } +} diff --git a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java index c4a303b..6ce9f87 100644 --- a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java @@ -2,6 +2,7 @@ import org.junit.jupiter.api.DisplayName; import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; +import ru.javawebinar.basejava.storage.ArrayStorage; @DisplayName("ArrayStorage implementation") public class ArrayStorageTest extends AbstractArrayStorageTest { diff --git a/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java b/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java deleted file mode 100644 index 3625069..0000000 --- a/test/ru/javawebinar/basejava/storage/impl/MapStorageTest.java +++ /dev/null @@ -1,11 +0,0 @@ -package ru.javawebinar.basejava.storage.impl; - -import org.junit.jupiter.api.DisplayName; -import ru.javawebinar.basejava.storage.AbstractStorageTest; - -@DisplayName("MapStorage implementation") -public class MapStorageTest extends AbstractStorageTest { - public MapStorageTest() { - super(new MapStorage()); - } -} From 8fce302f489bb16feefb545b97061d5db5970053 Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Fri, 23 Aug 2019 17:06:05 +0300 Subject: [PATCH 12/18] implemented getAllSorted --- src/ru/javawebinar/basejava/MainArray.java | 5 +++-- .../javawebinar/basejava/MainReflection.java | 2 +- .../basejava/MainTestArrayStorage.java | 2 +- .../storage/AbstractArrayStorage.java | 14 ++++++++++++-- .../javawebinar/basejava/storage/Storage.java | 6 +++++- .../basejava/storage/impl/ListStorage.java | 9 ++++++--- .../basejava/storage/impl/MapUuidStorage.java | 18 +++++++++++++----- .../basejava/storage/AbstractStorageTest.java | 19 ++++++++++++++----- .../basejava/storage/MapUuidStorageTest.java | 16 ++++++++-------- .../ru/javawebinar/basejava/storage/Util.java | 7 +++++++ 10 files changed, 70 insertions(+), 28 deletions(-) diff --git a/src/ru/javawebinar/basejava/MainArray.java b/src/ru/javawebinar/basejava/MainArray.java index 5688707..5290e5d 100644 --- a/src/ru/javawebinar/basejava/MainArray.java +++ b/src/ru/javawebinar/basejava/MainArray.java @@ -7,6 +7,7 @@ import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; +import java.util.List; /** * Test for ru.javawebinar.basejava.storage.impl.ArrayStorage @@ -66,9 +67,9 @@ public static void main(String[] args) throws IOException { } static void printAll() { - Resume [] all = ARRAY_STORAGE.getAll(); + List all = ARRAY_STORAGE.getAllSorted(); System.out.println("----------------------------"); - if (all.length == 0) { + if (all.size() == 0) { System.out.println("Empty"); } else { for (Resume r : all) { diff --git a/src/ru/javawebinar/basejava/MainReflection.java b/src/ru/javawebinar/basejava/MainReflection.java index 7652fd8..c9df96a 100644 --- a/src/ru/javawebinar/basejava/MainReflection.java +++ b/src/ru/javawebinar/basejava/MainReflection.java @@ -9,7 +9,7 @@ public class MainReflection { public static void main(String[] args) throws IllegalAccessException { - Resume r = new Resume(); + Resume r = new Resume("New Person"); Field field = r.getClass().getDeclaredFields()[0]; field.setAccessible(true); System.out.println(field.getName()); diff --git a/src/ru/javawebinar/basejava/MainTestArrayStorage.java b/src/ru/javawebinar/basejava/MainTestArrayStorage.java index 1c795fe..32659d9 100644 --- a/src/ru/javawebinar/basejava/MainTestArrayStorage.java +++ b/src/ru/javawebinar/basejava/MainTestArrayStorage.java @@ -34,7 +34,7 @@ public static void main(String[] args) { static void printAll() { System.out.println("\nGet All"); - for (Resume r : ARRAY_STORAGE.getAll()) { + for (Resume r : ARRAY_STORAGE.getAllSorted()) { System.out.println(r); } } diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java index 2736117..1af93fb 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java @@ -4,6 +4,8 @@ import ru.javawebinar.basejava.model.Resume; import java.util.Arrays; +import java.util.Collections; +import java.util.List; /** * Array based storage for Resumes @@ -31,10 +33,18 @@ protected void doUpdate(Resume r, Object index) { /** * @return array, contains only Resumes in storage (without null) */ - public Resume[] getAll() { - return Arrays.copyOfRange(storage, 0, size); +// public Resume[] getAll() { +// return Arrays.copyOfRange(storage, 0, size); +// } + + @Override + public List getAllSorted() { + List resumes = Arrays.asList(Arrays.copyOfRange(storage, 0, size)); + Collections.sort(resumes); + return resumes; } + @Override protected void doSave(Resume r, Object index) { if (size == STORAGE_LIMIT) { diff --git a/src/ru/javawebinar/basejava/storage/Storage.java b/src/ru/javawebinar/basejava/storage/Storage.java index 992a445..6832046 100644 --- a/src/ru/javawebinar/basejava/storage/Storage.java +++ b/src/ru/javawebinar/basejava/storage/Storage.java @@ -2,6 +2,8 @@ import ru.javawebinar.basejava.model.Resume; +import java.util.List; + public interface Storage { void clear(); @@ -14,9 +16,11 @@ public interface Storage { void delete(String uuid); - Resume[] getAll(); +// Resume[] getAll(); // List getAll(); int size(); + + List getAllSorted(); } \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java index ddb57d6..9c217c3 100644 --- a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java @@ -49,10 +49,13 @@ public void clear() { list.clear(); } +// @Override +// public Resume[] getAll() { +// return list.toArray(new Resume[list.size()]); +// } + @Override - public Resume[] getAll() { - return list.toArray(new Resume[list.size()]); - } + public List getAllSorted() {return new ArrayList<>(list);} @Override public int size() { diff --git a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java index 8cd8aa8..a17d213 100644 --- a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java @@ -5,7 +5,9 @@ import java.util.Collection; import java.util.HashMap; +import java.util.List; import java.util.Map; +import java.util.stream.Collectors; // TODO implement // TODO create new MapStorage with search key not uuid @@ -47,12 +49,18 @@ public void clear() { map.clear(); } +// @Override +// public Resume[] getAll() { +// Collection values = map.values(); +// return values.toArray(new Resume[map.size()]); +// } + + @Override - public Resume[] getAll() { - Collection values = map.values(); - return values.toArray(new Resume[map.size()]); -// Resume[] objects = values.toArray(new Resume[0]); -// return objects; + public List getAllSorted() { + return map.values().stream() + .sorted() + .collect(Collectors.toList()); } @Override diff --git a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java index 6b4f9a8..82b4851 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java @@ -7,6 +7,8 @@ import ru.javawebinar.basejava.exception.NotExistStorageException; import ru.javawebinar.basejava.model.Resume; +import java.util.Arrays; + import static org.junit.jupiter.api.Assertions.*; import static ru.javawebinar.basejava.storage.Util.*; @@ -47,7 +49,8 @@ void update() throws Exception { Resume r2New = new Resume(UUID_2); storage.update(r2New); - assertSame(r2New, storage.get(UUID_2)); + assertEquals(r2New, storage.get(UUID_2)); +// assertSame(r2New, storage.get(UUID_2)); } @@ -96,12 +99,18 @@ void deleteNonExisting() { @Test - void getAll() throws Exception { - Resume[] test = new Resume[]{R1, R2, R3}; - assertEquals(3, storage.getAll().length); - assertArrayEquals(test, storage.getAll()); + void getAllSorted() throws Exception { + assertEquals(Arrays.asList(R1,R2,R3), storage.getAllSorted()); + assertSize(3); } +// @Test +// void getAll() throws Exception { +// Resume[] test = new Resume[]{R1, R2, R3}; +// assertEquals(3, storage.getAll().length); +// assertArrayEquals(test, storage.getAll()); +// } + @Test void get() throws Exception { diff --git a/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java b/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java index 8594094..3abee46 100644 --- a/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java @@ -18,12 +18,12 @@ public MapUuidStorageTest() { super(new MapUuidStorage()); } - @Test - void getAll() throws Exception { - Resume[] test = new Resume[]{R1, R2, R3}; - Resume[] all = storage.getAll(); - Arrays.sort(all); - assertEquals(3, all.length); - assertArrayEquals(test, all); - } +// @Test +// void getAll() throws Exception { +// Resume[] test = new Resume[]{R1, R2, R3}; +// Resume[] all = storage.getAll(); +// Arrays.sort(all); +// assertEquals(3, all.length); +// assertArrayEquals(test, all); +// } } diff --git a/test/ru/javawebinar/basejava/storage/Util.java b/test/ru/javawebinar/basejava/storage/Util.java index e4587c3..47a4e6c 100644 --- a/test/ru/javawebinar/basejava/storage/Util.java +++ b/test/ru/javawebinar/basejava/storage/Util.java @@ -11,10 +11,17 @@ class Util { static final Resume R1; static final Resume R2; static final Resume R3; + static final Resume R4; static { R1 = new Resume(UUID_1); R2 = new Resume(UUID_2); R3 = new Resume(UUID_3); + R4 = new Resume(UUID_3); + +// R1 = new Resume(UUID_1, "Name1"); +// R2 = new Resume(UUID_2, "Name2"); +// R3 = new Resume(UUID_3, "Name3"); +// R4 = new Resume(UUID_3, "Name4"); } } From 8fc7f1551bcef2c40247a1fd3692939c93e47da4 Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Sat, 24 Aug 2019 02:28:28 +0300 Subject: [PATCH 13/18] ready to review --- src/ru/javawebinar/basejava/MainArray.java | 4 +- .../javawebinar/basejava/MainCollections.java | 8 +- .../basejava/MainTestArrayStorage.java | 6 +- .../storage/AbstractArrayStorage.java | 7 -- .../javawebinar/basejava/storage/Storage.java | 4 - .../basejava/storage/impl/ListStorage.java | 5 - .../storage/impl/MapResumeStorage.java | 65 ++++++++++++ .../basejava/storage/impl/MapUuidStorage.java | 6 -- .../storage/impl/SortedArrayStorage.java | 2 +- .../basejava/storage/MapUuidStorageTest.java | 29 ------ .../ru/javawebinar/basejava/storage/Util.java | 49 ++++++---- .../storage/junit4/AbstractStorageTest.java | 98 +++++++++++++++++++ .../storage/junit4/ListStorageTest.java | 9 ++ .../AbstractArrayStorageTest.java | 10 +- .../{ => junit5}/AbstractStorageTest.java | 28 +++--- .../{impl => junit5}/ArrayStorageTest.java | 3 +- .../{impl => junit5}/ListStorageTest.java | 4 +- .../storage/junit5/MapResumeStorageTest.java | 11 +++ .../storage/junit5/MapUuidStorageTest.java | 11 +++ .../SortedArrayStorageTest.java | 4 +- 20 files changed, 257 insertions(+), 106 deletions(-) create mode 100644 src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java delete mode 100644 test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java rename test/ru/javawebinar/basejava/storage/{ => junit5}/AbstractArrayStorageTest.java (79%) rename test/ru/javawebinar/basejava/storage/{ => junit5}/AbstractStorageTest.java (80%) rename test/ru/javawebinar/basejava/storage/{impl => junit5}/ArrayStorageTest.java (71%) rename test/ru/javawebinar/basejava/storage/{impl => junit5}/ListStorageTest.java (66%) create mode 100644 test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java rename test/ru/javawebinar/basejava/storage/{impl => junit5}/SortedArrayStorageTest.java (69%) diff --git a/src/ru/javawebinar/basejava/MainArray.java b/src/ru/javawebinar/basejava/MainArray.java index 5290e5d..e2fb2a7 100644 --- a/src/ru/javawebinar/basejava/MainArray.java +++ b/src/ru/javawebinar/basejava/MainArray.java @@ -37,12 +37,12 @@ public static void main(String[] args) throws IOException { System.out.println(ARRAY_STORAGE.size()); break; case "save": - r = new Resume(uuid); + r = new Resume(uuid, "Name"+uuid); ARRAY_STORAGE.save(r); printAll(); break; case "update": - r = new Resume(uuid); + r = new Resume(uuid, "Name"+uuid); ARRAY_STORAGE.update(r); printAll(); break; diff --git a/src/ru/javawebinar/basejava/MainCollections.java b/src/ru/javawebinar/basejava/MainCollections.java index 5b7077f..bff3f7c 100644 --- a/src/ru/javawebinar/basejava/MainCollections.java +++ b/src/ru/javawebinar/basejava/MainCollections.java @@ -6,16 +6,16 @@ public class MainCollections { private static final String UUID_1 = "uuid1"; - private static final Resume RESUME_1 = new Resume(UUID_1); + private static final Resume RESUME_1 = new Resume(UUID_1, "Name1"); private static final String UUID_2 = "uuid2"; - private static final Resume RESUME_2 = new Resume(UUID_2); + private static final Resume RESUME_2 = new Resume(UUID_2, "Name2"); private static final String UUID_3 = "uuid3"; - private static final Resume RESUME_3 = new Resume(UUID_3); + private static final Resume RESUME_3 = new Resume(UUID_3, "Name3"); private static final String UUID_4 = "uuid4"; - private static final Resume RESUME_4 = new Resume(UUID_4); + private static final Resume RESUME_4 = new Resume(UUID_4, "Name4"); public static void main(String[] args) { Collection collection = new ArrayList<>(); diff --git a/src/ru/javawebinar/basejava/MainTestArrayStorage.java b/src/ru/javawebinar/basejava/MainTestArrayStorage.java index 32659d9..9b84ecc 100644 --- a/src/ru/javawebinar/basejava/MainTestArrayStorage.java +++ b/src/ru/javawebinar/basejava/MainTestArrayStorage.java @@ -10,9 +10,9 @@ public class MainTestArrayStorage { static final ArrayStorage ARRAY_STORAGE = new ArrayStorage(); public static void main(String[] args) { - Resume r1 = new Resume("uuid1"); - Resume r2 = new Resume("uuid2"); - Resume r3 = new Resume("uuid3"); + Resume r1 = new Resume("uuid1", "Name1"); + Resume r2 = new Resume("uuid2", "Name2"); + Resume r3 = new Resume("uuid3", "Name3"); ARRAY_STORAGE.save(r1); ARRAY_STORAGE.save(r2); diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java index 1af93fb..55fe890 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java @@ -30,13 +30,6 @@ protected void doUpdate(Resume r, Object index) { storage[(Integer) index] = r; } - /** - * @return array, contains only Resumes in storage (without null) - */ -// public Resume[] getAll() { -// return Arrays.copyOfRange(storage, 0, size); -// } - @Override public List getAllSorted() { List resumes = Arrays.asList(Arrays.copyOfRange(storage, 0, size)); diff --git a/src/ru/javawebinar/basejava/storage/Storage.java b/src/ru/javawebinar/basejava/storage/Storage.java index 6832046..baf1c97 100644 --- a/src/ru/javawebinar/basejava/storage/Storage.java +++ b/src/ru/javawebinar/basejava/storage/Storage.java @@ -16,10 +16,6 @@ public interface Storage { void delete(String uuid); -// Resume[] getAll(); - -// List getAll(); - int size(); List getAllSorted(); diff --git a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java index 9c217c3..8e9c42c 100644 --- a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java @@ -49,11 +49,6 @@ public void clear() { list.clear(); } -// @Override -// public Resume[] getAll() { -// return list.toArray(new Resume[list.size()]); -// } - @Override public List getAllSorted() {return new ArrayList<>(list);} diff --git a/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java new file mode 100644 index 0000000..e02dd62 --- /dev/null +++ b/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java @@ -0,0 +1,65 @@ +package ru.javawebinar.basejava.storage.impl; + +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.AbstractStorage; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +public class MapResumeStorage extends AbstractStorage { + private Map map = new HashMap<>(); + + @Override + protected Object getSearchKey(String uuid) { + return map.get(uuid); + } + + @Override + protected void doUpdate(Resume r, Object searchKey) { + map.put(r.getUuid(), r); + } + + @Override + protected boolean isExist(Object searchKey) { + return searchKey != null; + } + + @Override + protected void doSave(Resume r, Object searchKey) { + map.put(r.getUuid(), r); + } + + @Override + protected Resume doGet(Object searchKey) { + return map.get(getUuid(searchKey)); + } + + @Override + protected void doDelete(Object searchKey) { + map.remove(getUuid(searchKey)); + } + + @Override + public void clear() { + map.clear(); + } + + @Override + public int size() { + return map.size(); + } + + @Override + public List getAllSorted() { + return new ArrayList<>(map.values().stream() + .sorted() + .collect(Collectors.toList())); + } + + private String getUuid(Object searchKey) { + return ((Resume) searchKey).getUuid(); + } +} diff --git a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java index a17d213..d97c8a1 100644 --- a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java @@ -49,12 +49,6 @@ public void clear() { map.clear(); } -// @Override -// public Resume[] getAll() { -// Collection values = map.values(); -// return values.toArray(new Resume[map.size()]); -// } - @Override public List getAllSorted() { diff --git a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java index 7482598..40ee653 100644 --- a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java @@ -41,7 +41,7 @@ protected void insertElement(Resume r, int index) { @Override protected Integer getSearchKey(String uuid) { - Resume searchKey = new Resume(uuid); + Resume searchKey = new Resume(uuid, "DummyName"); return Arrays.binarySearch(storage, 0, size, searchKey, RESUME_COMPARATOR); } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java b/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java deleted file mode 100644 index 3abee46..0000000 --- a/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java +++ /dev/null @@ -1,29 +0,0 @@ -package ru.javawebinar.basejava.storage; - -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; -import ru.javawebinar.basejava.model.Resume; -import ru.javawebinar.basejava.storage.AbstractStorageTest; -import ru.javawebinar.basejava.storage.impl.MapUuidStorage; - -import java.util.Arrays; - -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static ru.javawebinar.basejava.storage.Util.*; - -@DisplayName("MapStorage implementation") -public class MapUuidStorageTest extends AbstractStorageTest { - public MapUuidStorageTest() { - super(new MapUuidStorage()); - } - -// @Test -// void getAll() throws Exception { -// Resume[] test = new Resume[]{R1, R2, R3}; -// Resume[] all = storage.getAll(); -// Arrays.sort(all); -// assertEquals(3, all.length); -// assertArrayEquals(test, all); -// } -} diff --git a/test/ru/javawebinar/basejava/storage/Util.java b/test/ru/javawebinar/basejava/storage/Util.java index 47a4e6c..76b7ab2 100644 --- a/test/ru/javawebinar/basejava/storage/Util.java +++ b/test/ru/javawebinar/basejava/storage/Util.java @@ -2,26 +2,39 @@ import ru.javawebinar.basejava.model.Resume; -class Util { - static final String UUID_1 = "uuid1"; - static final String UUID_2 = "uuid2"; - static final String UUID_3 = "uuid3"; - static final String UUID_4 = "uuid4"; +public class Util { + public static final String UUID_1 = "uuid1"; + public static final String UUID_2 = "uuid2"; + public static final String UUID_3 = "uuid3"; + public static final String UUID_4 = "uuid4"; + public static final String UUID_FAKE = "dummy"; - static final Resume R1; - static final Resume R2; - static final Resume R3; - static final Resume R4; + public static final Resume R1; + public static final Resume R2; + public static final Resume R3; + public static final Resume R4; + public static final Resume FAKE; static { - R1 = new Resume(UUID_1); - R2 = new Resume(UUID_2); - R3 = new Resume(UUID_3); - R4 = new Resume(UUID_3); - -// R1 = new Resume(UUID_1, "Name1"); -// R2 = new Resume(UUID_2, "Name2"); -// R3 = new Resume(UUID_3, "Name3"); -// R4 = new Resume(UUID_3, "Name4"); +// R1 = new Resume(UUID_1); +// R2 = new Resume(UUID_2); +// R3 = new Resume(UUID_3); +// R4 = new Resume(UUID_3); +// FAKE = new Resume(UUID_FAKE); + + R1 = new Resume(UUID_1, "Name1"); + R2 = new Resume(UUID_2, "Name2"); + R3 = new Resume(UUID_3, "Name3"); + R4 = new Resume(UUID_4, "Name4"); + FAKE = new Resume(UUID_FAKE, "DUMMY"); + + +// R1 = new Resume(UUID_1, 1); +// R2 = new Resume(UUID_2, 2); +// R3 = new Resume(UUID_3, 3); +// R4 = new Resume(UUID_3, 4); +// FAKE = new Resume(UUID_FAKE, 111111); + } + public static final int STORAGE_LIMIT = 10000; } diff --git a/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java new file mode 100644 index 0000000..613b3d1 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java @@ -0,0 +1,98 @@ +package ru.javawebinar.basejava.storage.junit4; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import ru.javawebinar.basejava.exception.ExistStorageException; +import ru.javawebinar.basejava.exception.NotExistStorageException; +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.Storage; + +import java.util.Arrays; + +import static org.junit.Assert.*; +import static ru.javawebinar.basejava.storage.Util.*; + +public class AbstractStorageTest { + protected Storage storage; + +// public AbstractStorageTest(){} + + public AbstractStorageTest(Storage storage) { + this.storage = storage; + } + + @Before + public void setUp() throws Exception { + storage.clear(); + storage.save(R1); + storage.save(R2); + storage.save(R3); + } + + @Test + public void clear() { + storage.clear(); + assertEquals(0, storage.size()); + } + + @Test + public void update() { + storage.update(new Resume(UUID_2, "New Name")); + assertEquals(R2, storage.get(R2.getUuid())); + } + + @Test(expected = NotExistStorageException.class) + public void updateNonExisting() throws Exception { + storage.update(FAKE); + } + + @Test + public void getAllSorted() throws Exception { + assertEquals(Arrays.asList(R1, R2, R3), storage.getAllSorted()); + assertEquals(3, storage.size()); + } + + @Test + public void save() throws Exception { + storage.save(R4); + Assert.assertTrue(storage.getAllSorted().contains(R4)); + assertSize(4); + } + + @Test(expected = ExistStorageException.class) + public void saveExisting() throws Exception { + storage.save(R1); + } + + @Test + public void delete() throws Exception { + storage.delete(R2.getUuid()); + Assert.assertFalse(storage.getAllSorted().contains(R2)); + assertSize(2); + } + + @Test(expected = NotExistStorageException.class) + public void deleteNotExisting() throws Exception { + storage.delete(FAKE.getUuid()); + } + + @Test + public void get() throws Exception { + assertGet(R1); + } + + @Test(expected = NotExistStorageException.class) + public void getNonExisting() throws Exception { + storage.get(FAKE.getUuid()); + } + + private void assertSize(int size) { + assertEquals(size, storage.size()); + } + + private void assertGet(Resume r) { + assertEquals(r, storage.get(r.getUuid())); + } + +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java new file mode 100644 index 0000000..e27d48d --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java @@ -0,0 +1,9 @@ +package ru.javawebinar.basejava.storage.junit4; + +import ru.javawebinar.basejava.storage.impl.ListStorage; + +class ListStorageTest extends ru.javawebinar.basejava.storage.junit4.AbstractStorageTest { + public ListStorageTest() { + super(new ListStorage()); + } +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java similarity index 79% rename from test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java index 1639fe4..a22f59a 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java @@ -1,4 +1,4 @@ -package ru.javawebinar.basejava.storage; +package ru.javawebinar.basejava.storage.junit5; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; @@ -7,10 +7,12 @@ import org.junit.jupiter.api.function.Executable; import ru.javawebinar.basejava.exception.StorageException; import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.Storage; import java.util.stream.IntStream; import static org.junit.jupiter.api.Assertions.*; +import static ru.javawebinar.basejava.storage.Util.STORAGE_LIMIT; public abstract class AbstractArrayStorageTest extends AbstractStorageTest { @@ -34,13 +36,13 @@ void fill() { // arrange String uuid = "New item"; Executable throwingExecutable = () -> { - storage.save(new Resume(uuid)); + storage.save(new Resume(uuid, "Extra soldier")); }; // act and assert assertDoesNotThrow(() -> IntStream.iterate(0, n -> n + 1). - limit(AbstractArrayStorage.STORAGE_LIMIT). - mapToObj(i -> new Resume("Name" + i)). + limit(STORAGE_LIMIT). + mapToObj(i -> new Resume("Name" + i, "Name" + i)). forEach(storage::save)); RuntimeException thrown = assertThrows( diff --git a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java similarity index 80% rename from test/ru/javawebinar/basejava/storage/AbstractStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java index 82b4851..0a48be6 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java @@ -1,11 +1,11 @@ -package ru.javawebinar.basejava.storage; +package ru.javawebinar.basejava.storage.junit5; -import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import ru.javawebinar.basejava.exception.ExistStorageException; import ru.javawebinar.basejava.exception.NotExistStorageException; import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.Storage; import java.util.Arrays; @@ -27,11 +27,6 @@ void beforeEach() { storage.save(R3); } - @AfterEach - void afterEach() { - storage.clear(); - } - @Test void size() throws Exception { assertSize(3); @@ -46,10 +41,10 @@ void clear() throws Exception { @Test void update() throws Exception { - Resume r2New = new Resume(UUID_2); + Resume r2New = new Resume(UUID_2, "New Name"); storage.update(r2New); - assertEquals(r2New, storage.get(UUID_2)); + assertEquals(r2New, storage.get(R2.getUuid())); // assertSame(r2New, storage.get(UUID_2)); } @@ -58,17 +53,16 @@ void update() throws Exception { void updateNonExisting() { assertThrows( NotExistStorageException.class, - () -> storage.update(new Resume("dummy")) + () -> storage.update(FAKE) ); } @Test void save() throws Exception { - Resume r4 = new Resume(UUID_4); - storage.save(r4); + storage.save(R4); assertSize(4); - assertSame(r4, storage.get(UUID_4)); + assertSame(R4, storage.get(UUID_4)); } @@ -93,14 +87,14 @@ void delete() throws Exception { void deleteNonExisting() { assertThrows( NotExistStorageException.class, - () -> storage.delete("dummy") + () -> storage.delete(FAKE.getUuid()) ); } @Test void getAllSorted() throws Exception { - assertEquals(Arrays.asList(R1,R2,R3), storage.getAllSorted()); + assertEquals(Arrays.asList(R1, R2, R3), storage.getAllSorted()); assertSize(3); } @@ -118,10 +112,10 @@ void get() throws Exception { } @Test - void getNonExisting() { + void getNonExistinging() { assertThrows( NotExistStorageException.class, - () -> storage.get("dummy") + () -> storage.get(FAKE.getUuid()) ); } diff --git a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java similarity index 71% rename from test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java index 6ce9f87..b12f5ed 100644 --- a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java @@ -1,7 +1,6 @@ -package ru.javawebinar.basejava.storage.impl; +package ru.javawebinar.basejava.storage.junit5; import org.junit.jupiter.api.DisplayName; -import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; import ru.javawebinar.basejava.storage.ArrayStorage; @DisplayName("ArrayStorage implementation") diff --git a/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java similarity index 66% rename from test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java index ac30618..af5b0ea 100644 --- a/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java @@ -1,7 +1,7 @@ -package ru.javawebinar.basejava.storage.impl; +package ru.javawebinar.basejava.storage.junit5; import org.junit.jupiter.api.DisplayName; -import ru.javawebinar.basejava.storage.AbstractStorageTest; +import ru.javawebinar.basejava.storage.impl.ListStorage; @DisplayName("ListStorage implementation") class ListStorageTest extends AbstractStorageTest { diff --git a/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java new file mode 100644 index 0000000..fa64c93 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java @@ -0,0 +1,11 @@ +package ru.javawebinar.basejava.storage.junit5; + +import org.junit.jupiter.api.DisplayName; +import ru.javawebinar.basejava.storage.impl.MapResumeStorage; + +@DisplayName("MapResumeStorage implementation") +public class MapResumeStorageTest extends AbstractStorageTest { + public MapResumeStorageTest() { + super(new MapResumeStorage()); + } +} diff --git a/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java new file mode 100644 index 0000000..2091a01 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java @@ -0,0 +1,11 @@ +package ru.javawebinar.basejava.storage.junit5; + +import org.junit.jupiter.api.DisplayName; +import ru.javawebinar.basejava.storage.impl.MapUuidStorage; + +@DisplayName("MapUuidStorage implementation") +public class MapUuidStorageTest extends AbstractStorageTest { + public MapUuidStorageTest() { + super(new MapUuidStorage()); + } +} diff --git a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java similarity index 69% rename from test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java index 6b8c2aa..eb840ad 100644 --- a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java @@ -1,7 +1,7 @@ -package ru.javawebinar.basejava.storage.impl; +package ru.javawebinar.basejava.storage.junit5; import org.junit.jupiter.api.DisplayName; -import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; +import ru.javawebinar.basejava.storage.impl.SortedArrayStorage; @DisplayName("SortedArrayStorage implementation") public class SortedArrayStorageTest extends AbstractArrayStorageTest { From 557f3353fe844ca8b18f3b15136c2be6f3d648e9 Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Sat, 24 Aug 2019 02:28:28 +0300 Subject: [PATCH 14/18] ready to review --- src/ru/javawebinar/basejava/MainArray.java | 4 +- .../javawebinar/basejava/MainCollections.java | 8 +- .../basejava/MainTestArrayStorage.java | 6 +- src/ru/javawebinar/basejava/model/Resume.java | 36 ++++--- .../storage/AbstractArrayStorage.java | 7 -- .../javawebinar/basejava/storage/Storage.java | 4 - .../basejava/storage/impl/ListStorage.java | 5 - .../storage/impl/MapResumeStorage.java | 65 ++++++++++++ .../basejava/storage/impl/MapUuidStorage.java | 6 -- .../storage/impl/SortedArrayStorage.java | 2 +- .../basejava/storage/MapUuidStorageTest.java | 29 ------ .../ru/javawebinar/basejava/storage/Util.java | 49 ++++++---- .../storage/junit4/AbstractStorageTest.java | 98 +++++++++++++++++++ .../storage/junit4/ListStorageTest.java | 9 ++ .../AbstractArrayStorageTest.java | 10 +- .../{ => junit5}/AbstractStorageTest.java | 28 +++--- .../{impl => junit5}/ArrayStorageTest.java | 3 +- .../{impl => junit5}/ListStorageTest.java | 4 +- .../storage/junit5/MapResumeStorageTest.java | 11 +++ .../storage/junit5/MapUuidStorageTest.java | 11 +++ .../SortedArrayStorageTest.java | 4 +- 21 files changed, 279 insertions(+), 120 deletions(-) create mode 100644 src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java delete mode 100644 test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java rename test/ru/javawebinar/basejava/storage/{ => junit5}/AbstractArrayStorageTest.java (79%) rename test/ru/javawebinar/basejava/storage/{ => junit5}/AbstractStorageTest.java (80%) rename test/ru/javawebinar/basejava/storage/{impl => junit5}/ArrayStorageTest.java (71%) rename test/ru/javawebinar/basejava/storage/{impl => junit5}/ListStorageTest.java (66%) create mode 100644 test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java rename test/ru/javawebinar/basejava/storage/{impl => junit5}/SortedArrayStorageTest.java (69%) diff --git a/src/ru/javawebinar/basejava/MainArray.java b/src/ru/javawebinar/basejava/MainArray.java index 5290e5d..e2fb2a7 100644 --- a/src/ru/javawebinar/basejava/MainArray.java +++ b/src/ru/javawebinar/basejava/MainArray.java @@ -37,12 +37,12 @@ public static void main(String[] args) throws IOException { System.out.println(ARRAY_STORAGE.size()); break; case "save": - r = new Resume(uuid); + r = new Resume(uuid, "Name"+uuid); ARRAY_STORAGE.save(r); printAll(); break; case "update": - r = new Resume(uuid); + r = new Resume(uuid, "Name"+uuid); ARRAY_STORAGE.update(r); printAll(); break; diff --git a/src/ru/javawebinar/basejava/MainCollections.java b/src/ru/javawebinar/basejava/MainCollections.java index 5b7077f..bff3f7c 100644 --- a/src/ru/javawebinar/basejava/MainCollections.java +++ b/src/ru/javawebinar/basejava/MainCollections.java @@ -6,16 +6,16 @@ public class MainCollections { private static final String UUID_1 = "uuid1"; - private static final Resume RESUME_1 = new Resume(UUID_1); + private static final Resume RESUME_1 = new Resume(UUID_1, "Name1"); private static final String UUID_2 = "uuid2"; - private static final Resume RESUME_2 = new Resume(UUID_2); + private static final Resume RESUME_2 = new Resume(UUID_2, "Name2"); private static final String UUID_3 = "uuid3"; - private static final Resume RESUME_3 = new Resume(UUID_3); + private static final Resume RESUME_3 = new Resume(UUID_3, "Name3"); private static final String UUID_4 = "uuid4"; - private static final Resume RESUME_4 = new Resume(UUID_4); + private static final Resume RESUME_4 = new Resume(UUID_4, "Name4"); public static void main(String[] args) { Collection collection = new ArrayList<>(); diff --git a/src/ru/javawebinar/basejava/MainTestArrayStorage.java b/src/ru/javawebinar/basejava/MainTestArrayStorage.java index 32659d9..9b84ecc 100644 --- a/src/ru/javawebinar/basejava/MainTestArrayStorage.java +++ b/src/ru/javawebinar/basejava/MainTestArrayStorage.java @@ -10,9 +10,9 @@ public class MainTestArrayStorage { static final ArrayStorage ARRAY_STORAGE = new ArrayStorage(); public static void main(String[] args) { - Resume r1 = new Resume("uuid1"); - Resume r2 = new Resume("uuid2"); - Resume r3 = new Resume("uuid3"); + Resume r1 = new Resume("uuid1", "Name1"); + Resume r2 = new Resume("uuid2", "Name2"); + Resume r3 = new Resume("uuid3", "Name3"); ARRAY_STORAGE.save(r1); ARRAY_STORAGE.save(r2); diff --git a/src/ru/javawebinar/basejava/model/Resume.java b/src/ru/javawebinar/basejava/model/Resume.java index 508cc20..bfa6b4e 100644 --- a/src/ru/javawebinar/basejava/model/Resume.java +++ b/src/ru/javawebinar/basejava/model/Resume.java @@ -1,5 +1,6 @@ package ru.javawebinar.basejava.model; +import java.util.Objects; import java.util.UUID; /** @@ -8,42 +9,49 @@ public class Resume implements Comparable { // Unique identifier - private final String uuid; + private String uuid; - public Resume() { - this(UUID.randomUUID().toString()); + private String fullName; + + public Resume(){}; + + public Resume(String fullName) { + this(UUID.randomUUID().toString(), fullName); } - public Resume(String uuid) { + public Resume(String uuid, String fullName) { this.uuid = uuid; + this.fullName = fullName; } public String getUuid() { return uuid; } + @Override + public String toString() { + return uuid; + } + + @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; - Resume resume = (Resume) o; - - return uuid.equals(resume.uuid); + return uuid.equals(resume.uuid) && + fullName.equals(resume.fullName); } @Override public int hashCode() { - return uuid.hashCode(); - } - - @Override - public String toString() { - return uuid; + return Objects.hash(uuid, fullName); } @Override public int compareTo(Resume o) { - return uuid.compareTo(o.uuid); + int candidate = fullName.compareTo(o.fullName); + if (candidate != 0) return candidate; + else return uuid.compareTo(o.uuid); } } \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java index 1af93fb..55fe890 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java @@ -30,13 +30,6 @@ protected void doUpdate(Resume r, Object index) { storage[(Integer) index] = r; } - /** - * @return array, contains only Resumes in storage (without null) - */ -// public Resume[] getAll() { -// return Arrays.copyOfRange(storage, 0, size); -// } - @Override public List getAllSorted() { List resumes = Arrays.asList(Arrays.copyOfRange(storage, 0, size)); diff --git a/src/ru/javawebinar/basejava/storage/Storage.java b/src/ru/javawebinar/basejava/storage/Storage.java index 6832046..baf1c97 100644 --- a/src/ru/javawebinar/basejava/storage/Storage.java +++ b/src/ru/javawebinar/basejava/storage/Storage.java @@ -16,10 +16,6 @@ public interface Storage { void delete(String uuid); -// Resume[] getAll(); - -// List getAll(); - int size(); List getAllSorted(); diff --git a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java index 9c217c3..8e9c42c 100644 --- a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java @@ -49,11 +49,6 @@ public void clear() { list.clear(); } -// @Override -// public Resume[] getAll() { -// return list.toArray(new Resume[list.size()]); -// } - @Override public List getAllSorted() {return new ArrayList<>(list);} diff --git a/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java new file mode 100644 index 0000000..e02dd62 --- /dev/null +++ b/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java @@ -0,0 +1,65 @@ +package ru.javawebinar.basejava.storage.impl; + +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.AbstractStorage; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +public class MapResumeStorage extends AbstractStorage { + private Map map = new HashMap<>(); + + @Override + protected Object getSearchKey(String uuid) { + return map.get(uuid); + } + + @Override + protected void doUpdate(Resume r, Object searchKey) { + map.put(r.getUuid(), r); + } + + @Override + protected boolean isExist(Object searchKey) { + return searchKey != null; + } + + @Override + protected void doSave(Resume r, Object searchKey) { + map.put(r.getUuid(), r); + } + + @Override + protected Resume doGet(Object searchKey) { + return map.get(getUuid(searchKey)); + } + + @Override + protected void doDelete(Object searchKey) { + map.remove(getUuid(searchKey)); + } + + @Override + public void clear() { + map.clear(); + } + + @Override + public int size() { + return map.size(); + } + + @Override + public List getAllSorted() { + return new ArrayList<>(map.values().stream() + .sorted() + .collect(Collectors.toList())); + } + + private String getUuid(Object searchKey) { + return ((Resume) searchKey).getUuid(); + } +} diff --git a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java index a17d213..d97c8a1 100644 --- a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java @@ -49,12 +49,6 @@ public void clear() { map.clear(); } -// @Override -// public Resume[] getAll() { -// Collection values = map.values(); -// return values.toArray(new Resume[map.size()]); -// } - @Override public List getAllSorted() { diff --git a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java index 7482598..40ee653 100644 --- a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java @@ -41,7 +41,7 @@ protected void insertElement(Resume r, int index) { @Override protected Integer getSearchKey(String uuid) { - Resume searchKey = new Resume(uuid); + Resume searchKey = new Resume(uuid, "DummyName"); return Arrays.binarySearch(storage, 0, size, searchKey, RESUME_COMPARATOR); } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java b/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java deleted file mode 100644 index 3abee46..0000000 --- a/test/ru/javawebinar/basejava/storage/MapUuidStorageTest.java +++ /dev/null @@ -1,29 +0,0 @@ -package ru.javawebinar.basejava.storage; - -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; -import ru.javawebinar.basejava.model.Resume; -import ru.javawebinar.basejava.storage.AbstractStorageTest; -import ru.javawebinar.basejava.storage.impl.MapUuidStorage; - -import java.util.Arrays; - -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static ru.javawebinar.basejava.storage.Util.*; - -@DisplayName("MapStorage implementation") -public class MapUuidStorageTest extends AbstractStorageTest { - public MapUuidStorageTest() { - super(new MapUuidStorage()); - } - -// @Test -// void getAll() throws Exception { -// Resume[] test = new Resume[]{R1, R2, R3}; -// Resume[] all = storage.getAll(); -// Arrays.sort(all); -// assertEquals(3, all.length); -// assertArrayEquals(test, all); -// } -} diff --git a/test/ru/javawebinar/basejava/storage/Util.java b/test/ru/javawebinar/basejava/storage/Util.java index 47a4e6c..76b7ab2 100644 --- a/test/ru/javawebinar/basejava/storage/Util.java +++ b/test/ru/javawebinar/basejava/storage/Util.java @@ -2,26 +2,39 @@ import ru.javawebinar.basejava.model.Resume; -class Util { - static final String UUID_1 = "uuid1"; - static final String UUID_2 = "uuid2"; - static final String UUID_3 = "uuid3"; - static final String UUID_4 = "uuid4"; +public class Util { + public static final String UUID_1 = "uuid1"; + public static final String UUID_2 = "uuid2"; + public static final String UUID_3 = "uuid3"; + public static final String UUID_4 = "uuid4"; + public static final String UUID_FAKE = "dummy"; - static final Resume R1; - static final Resume R2; - static final Resume R3; - static final Resume R4; + public static final Resume R1; + public static final Resume R2; + public static final Resume R3; + public static final Resume R4; + public static final Resume FAKE; static { - R1 = new Resume(UUID_1); - R2 = new Resume(UUID_2); - R3 = new Resume(UUID_3); - R4 = new Resume(UUID_3); - -// R1 = new Resume(UUID_1, "Name1"); -// R2 = new Resume(UUID_2, "Name2"); -// R3 = new Resume(UUID_3, "Name3"); -// R4 = new Resume(UUID_3, "Name4"); +// R1 = new Resume(UUID_1); +// R2 = new Resume(UUID_2); +// R3 = new Resume(UUID_3); +// R4 = new Resume(UUID_3); +// FAKE = new Resume(UUID_FAKE); + + R1 = new Resume(UUID_1, "Name1"); + R2 = new Resume(UUID_2, "Name2"); + R3 = new Resume(UUID_3, "Name3"); + R4 = new Resume(UUID_4, "Name4"); + FAKE = new Resume(UUID_FAKE, "DUMMY"); + + +// R1 = new Resume(UUID_1, 1); +// R2 = new Resume(UUID_2, 2); +// R3 = new Resume(UUID_3, 3); +// R4 = new Resume(UUID_3, 4); +// FAKE = new Resume(UUID_FAKE, 111111); + } + public static final int STORAGE_LIMIT = 10000; } diff --git a/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java new file mode 100644 index 0000000..613b3d1 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java @@ -0,0 +1,98 @@ +package ru.javawebinar.basejava.storage.junit4; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import ru.javawebinar.basejava.exception.ExistStorageException; +import ru.javawebinar.basejava.exception.NotExistStorageException; +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.Storage; + +import java.util.Arrays; + +import static org.junit.Assert.*; +import static ru.javawebinar.basejava.storage.Util.*; + +public class AbstractStorageTest { + protected Storage storage; + +// public AbstractStorageTest(){} + + public AbstractStorageTest(Storage storage) { + this.storage = storage; + } + + @Before + public void setUp() throws Exception { + storage.clear(); + storage.save(R1); + storage.save(R2); + storage.save(R3); + } + + @Test + public void clear() { + storage.clear(); + assertEquals(0, storage.size()); + } + + @Test + public void update() { + storage.update(new Resume(UUID_2, "New Name")); + assertEquals(R2, storage.get(R2.getUuid())); + } + + @Test(expected = NotExistStorageException.class) + public void updateNonExisting() throws Exception { + storage.update(FAKE); + } + + @Test + public void getAllSorted() throws Exception { + assertEquals(Arrays.asList(R1, R2, R3), storage.getAllSorted()); + assertEquals(3, storage.size()); + } + + @Test + public void save() throws Exception { + storage.save(R4); + Assert.assertTrue(storage.getAllSorted().contains(R4)); + assertSize(4); + } + + @Test(expected = ExistStorageException.class) + public void saveExisting() throws Exception { + storage.save(R1); + } + + @Test + public void delete() throws Exception { + storage.delete(R2.getUuid()); + Assert.assertFalse(storage.getAllSorted().contains(R2)); + assertSize(2); + } + + @Test(expected = NotExistStorageException.class) + public void deleteNotExisting() throws Exception { + storage.delete(FAKE.getUuid()); + } + + @Test + public void get() throws Exception { + assertGet(R1); + } + + @Test(expected = NotExistStorageException.class) + public void getNonExisting() throws Exception { + storage.get(FAKE.getUuid()); + } + + private void assertSize(int size) { + assertEquals(size, storage.size()); + } + + private void assertGet(Resume r) { + assertEquals(r, storage.get(r.getUuid())); + } + +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java new file mode 100644 index 0000000..e27d48d --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java @@ -0,0 +1,9 @@ +package ru.javawebinar.basejava.storage.junit4; + +import ru.javawebinar.basejava.storage.impl.ListStorage; + +class ListStorageTest extends ru.javawebinar.basejava.storage.junit4.AbstractStorageTest { + public ListStorageTest() { + super(new ListStorage()); + } +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java similarity index 79% rename from test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java index 1639fe4..a22f59a 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java @@ -1,4 +1,4 @@ -package ru.javawebinar.basejava.storage; +package ru.javawebinar.basejava.storage.junit5; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; @@ -7,10 +7,12 @@ import org.junit.jupiter.api.function.Executable; import ru.javawebinar.basejava.exception.StorageException; import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.Storage; import java.util.stream.IntStream; import static org.junit.jupiter.api.Assertions.*; +import static ru.javawebinar.basejava.storage.Util.STORAGE_LIMIT; public abstract class AbstractArrayStorageTest extends AbstractStorageTest { @@ -34,13 +36,13 @@ void fill() { // arrange String uuid = "New item"; Executable throwingExecutable = () -> { - storage.save(new Resume(uuid)); + storage.save(new Resume(uuid, "Extra soldier")); }; // act and assert assertDoesNotThrow(() -> IntStream.iterate(0, n -> n + 1). - limit(AbstractArrayStorage.STORAGE_LIMIT). - mapToObj(i -> new Resume("Name" + i)). + limit(STORAGE_LIMIT). + mapToObj(i -> new Resume("Name" + i, "Name" + i)). forEach(storage::save)); RuntimeException thrown = assertThrows( diff --git a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java similarity index 80% rename from test/ru/javawebinar/basejava/storage/AbstractStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java index 82b4851..0a48be6 100644 --- a/test/ru/javawebinar/basejava/storage/AbstractStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java @@ -1,11 +1,11 @@ -package ru.javawebinar.basejava.storage; +package ru.javawebinar.basejava.storage.junit5; -import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import ru.javawebinar.basejava.exception.ExistStorageException; import ru.javawebinar.basejava.exception.NotExistStorageException; import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.Storage; import java.util.Arrays; @@ -27,11 +27,6 @@ void beforeEach() { storage.save(R3); } - @AfterEach - void afterEach() { - storage.clear(); - } - @Test void size() throws Exception { assertSize(3); @@ -46,10 +41,10 @@ void clear() throws Exception { @Test void update() throws Exception { - Resume r2New = new Resume(UUID_2); + Resume r2New = new Resume(UUID_2, "New Name"); storage.update(r2New); - assertEquals(r2New, storage.get(UUID_2)); + assertEquals(r2New, storage.get(R2.getUuid())); // assertSame(r2New, storage.get(UUID_2)); } @@ -58,17 +53,16 @@ void update() throws Exception { void updateNonExisting() { assertThrows( NotExistStorageException.class, - () -> storage.update(new Resume("dummy")) + () -> storage.update(FAKE) ); } @Test void save() throws Exception { - Resume r4 = new Resume(UUID_4); - storage.save(r4); + storage.save(R4); assertSize(4); - assertSame(r4, storage.get(UUID_4)); + assertSame(R4, storage.get(UUID_4)); } @@ -93,14 +87,14 @@ void delete() throws Exception { void deleteNonExisting() { assertThrows( NotExistStorageException.class, - () -> storage.delete("dummy") + () -> storage.delete(FAKE.getUuid()) ); } @Test void getAllSorted() throws Exception { - assertEquals(Arrays.asList(R1,R2,R3), storage.getAllSorted()); + assertEquals(Arrays.asList(R1, R2, R3), storage.getAllSorted()); assertSize(3); } @@ -118,10 +112,10 @@ void get() throws Exception { } @Test - void getNonExisting() { + void getNonExistinging() { assertThrows( NotExistStorageException.class, - () -> storage.get("dummy") + () -> storage.get(FAKE.getUuid()) ); } diff --git a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java similarity index 71% rename from test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java index 6ce9f87..b12f5ed 100644 --- a/test/ru/javawebinar/basejava/storage/impl/ArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java @@ -1,7 +1,6 @@ -package ru.javawebinar.basejava.storage.impl; +package ru.javawebinar.basejava.storage.junit5; import org.junit.jupiter.api.DisplayName; -import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; import ru.javawebinar.basejava.storage.ArrayStorage; @DisplayName("ArrayStorage implementation") diff --git a/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java similarity index 66% rename from test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java index ac30618..af5b0ea 100644 --- a/test/ru/javawebinar/basejava/storage/impl/ListStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java @@ -1,7 +1,7 @@ -package ru.javawebinar.basejava.storage.impl; +package ru.javawebinar.basejava.storage.junit5; import org.junit.jupiter.api.DisplayName; -import ru.javawebinar.basejava.storage.AbstractStorageTest; +import ru.javawebinar.basejava.storage.impl.ListStorage; @DisplayName("ListStorage implementation") class ListStorageTest extends AbstractStorageTest { diff --git a/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java new file mode 100644 index 0000000..fa64c93 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java @@ -0,0 +1,11 @@ +package ru.javawebinar.basejava.storage.junit5; + +import org.junit.jupiter.api.DisplayName; +import ru.javawebinar.basejava.storage.impl.MapResumeStorage; + +@DisplayName("MapResumeStorage implementation") +public class MapResumeStorageTest extends AbstractStorageTest { + public MapResumeStorageTest() { + super(new MapResumeStorage()); + } +} diff --git a/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java new file mode 100644 index 0000000..2091a01 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java @@ -0,0 +1,11 @@ +package ru.javawebinar.basejava.storage.junit5; + +import org.junit.jupiter.api.DisplayName; +import ru.javawebinar.basejava.storage.impl.MapUuidStorage; + +@DisplayName("MapUuidStorage implementation") +public class MapUuidStorageTest extends AbstractStorageTest { + public MapUuidStorageTest() { + super(new MapUuidStorage()); + } +} diff --git a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java similarity index 69% rename from test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java index 6b8c2aa..eb840ad 100644 --- a/test/ru/javawebinar/basejava/storage/impl/SortedArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java @@ -1,7 +1,7 @@ -package ru.javawebinar.basejava.storage.impl; +package ru.javawebinar.basejava.storage.junit5; import org.junit.jupiter.api.DisplayName; -import ru.javawebinar.basejava.storage.AbstractArrayStorageTest; +import ru.javawebinar.basejava.storage.impl.SortedArrayStorage; @DisplayName("SortedArrayStorage implementation") public class SortedArrayStorageTest extends AbstractArrayStorageTest { From dd8943ecac5d6e11db9ef2429ce333c1dd751e6a Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Fri, 30 Aug 2019 11:35:43 +0300 Subject: [PATCH 15/18] fix resume is not pushed --- src/ru/javawebinar/basejava/model/Resume.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/ru/javawebinar/basejava/model/Resume.java b/src/ru/javawebinar/basejava/model/Resume.java index bfa6b4e..543e94f 100644 --- a/src/ru/javawebinar/basejava/model/Resume.java +++ b/src/ru/javawebinar/basejava/model/Resume.java @@ -19,6 +19,7 @@ public Resume(String fullName) { this(UUID.randomUUID().toString(), fullName); } + public Resume(String uuid, String fullName) { this.uuid = uuid; this.fullName = fullName; From f7c862927e60bc004c93c032dd18ce0389405578 Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Fri, 30 Aug 2019 12:40:57 +0300 Subject: [PATCH 16/18] ready to review all but junit4 --- .../storage/AbstractArrayStorage.java | 4 +- .../basejava/storage/AbstractStorage.java | 8 ++ .../storage/impl/MapResumeStorage.java | 4 +- .../basejava/storage/impl/MapUuidStorage.java | 2 - .../storage/impl/SortedArrayStorage.java | 7 +- .../junit5/AbstractArrayStorageTest.java | 56 -------- .../storage/junit5/AbstractStorageTest.java | 130 ------------------ .../storage/junit5/ArrayStorageTest.java | 12 -- .../storage/junit5/ListStorageTest.java | 11 -- .../storage/junit5/MapResumeStorageTest.java | 11 -- .../storage/junit5/MapUuidStorageTest.java | 11 -- .../junit5/SortedArrayStorageTest.java | 12 -- 12 files changed, 13 insertions(+), 255 deletions(-) delete mode 100644 test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java delete mode 100644 test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java delete mode 100644 test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java delete mode 100644 test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java delete mode 100644 test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java delete mode 100644 test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java delete mode 100644 test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java index 55fe890..94a2f2b 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java @@ -11,7 +11,7 @@ * Array based storage for Resumes */ public abstract class AbstractArrayStorage extends AbstractStorage { - protected static final int STORAGE_LIMIT = 10000; + protected static final int STORAGE_LIMIT = 10_000; protected Resume[] storage = new Resume[STORAGE_LIMIT]; protected int size = 0; @@ -68,5 +68,5 @@ protected boolean isExist(Object index) { protected abstract void insertElement(Resume r, int index); - protected abstract Integer getSearchKey(String uuid); +// protected abstract Integer getSearchKey(String uuid); } \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/AbstractStorage.java b/src/ru/javawebinar/basejava/storage/AbstractStorage.java index ce813a8..9698ec3 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractStorage.java @@ -4,6 +4,8 @@ import ru.javawebinar.basejava.exception.NotExistStorageException; import ru.javawebinar.basejava.model.Resume; +import java.util.List; + public abstract class AbstractStorage implements Storage { protected abstract Object getSearchKey(String uuid); @@ -18,21 +20,27 @@ public abstract class AbstractStorage implements Storage { protected abstract void doDelete(Object searchKey); + public abstract List getAllSorted(); + + @Override public void update(Resume r) { Object searchKey = getExistedSearchKey(r.getUuid()); doUpdate(r, searchKey); } + @Override public void save(Resume r) { Object searchKey = getNotExistedSearchKey(r.getUuid()); doSave(r, searchKey); } + @Override public void delete(String uuid) { Object searchKey = getExistedSearchKey(uuid); doDelete(searchKey); } + @Override public Resume get(String uuid) { Object searchKey = getExistedSearchKey(uuid); return doGet(searchKey); diff --git a/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java index e02dd62..e51357e 100644 --- a/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java @@ -13,7 +13,7 @@ public class MapResumeStorage extends AbstractStorage { private Map map = new HashMap<>(); @Override - protected Object getSearchKey(String uuid) { + protected Resume getSearchKey(String uuid) { return map.get(uuid); } @@ -34,7 +34,7 @@ protected void doSave(Resume r, Object searchKey) { @Override protected Resume doGet(Object searchKey) { - return map.get(getUuid(searchKey)); + return (Resume) searchKey; } @Override diff --git a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java index d97c8a1..4d32135 100644 --- a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java @@ -9,8 +9,6 @@ import java.util.Map; import java.util.stream.Collectors; -// TODO implement -// TODO create new MapStorage with search key not uuid public class MapUuidStorage extends AbstractStorage { private Map map = new HashMap<>(); diff --git a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java index 40ee653..17398a6 100644 --- a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java @@ -16,12 +16,7 @@ public int compare(Resume o1, Resume o2) { } */ - private static final Comparator RESUME_COMPARATOR = new Comparator() { - @Override - public int compare(Resume o1, Resume o2) { - return o1.getUuid().compareTo(o2.getUuid()); - } - }; + private static final Comparator RESUME_COMPARATOR = Comparator.comparing(Resume::getUuid); @Override protected void fillDeletedElement(int index) { diff --git a/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java deleted file mode 100644 index a22f59a..0000000 --- a/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java +++ /dev/null @@ -1,56 +0,0 @@ -package ru.javawebinar.basejava.storage.junit5; - -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Nested; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.function.Executable; -import ru.javawebinar.basejava.exception.StorageException; -import ru.javawebinar.basejava.model.Resume; -import ru.javawebinar.basejava.storage.Storage; - -import java.util.stream.IntStream; - -import static org.junit.jupiter.api.Assertions.*; -import static ru.javawebinar.basejava.storage.Util.STORAGE_LIMIT; - - -public abstract class AbstractArrayStorageTest extends AbstractStorageTest { - - protected AbstractArrayStorageTest(Storage storage) { - super(storage); - } - - - @Nested - class SaveOverflow { - - @BeforeEach - void setUp() { - storage.clear(); - } - - @Test - @DisplayName("Should not throw within size limit, then throws when overflow") - void fill() { - // arrange - String uuid = "New item"; - Executable throwingExecutable = () -> { - storage.save(new Resume(uuid, "Extra soldier")); - }; - - // act and assert - assertDoesNotThrow(() -> IntStream.iterate(0, n -> n + 1). - limit(STORAGE_LIMIT). - mapToObj(i -> new Resume("Name" + i, "Name" + i)). - forEach(storage::save)); - - RuntimeException thrown = assertThrows( - StorageException.class, throwingExecutable, "Should throw generic StorageException" - ); - - assertEquals("Storage overflow", thrown.getMessage()); - } - } - -} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java deleted file mode 100644 index 0a48be6..0000000 --- a/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java +++ /dev/null @@ -1,130 +0,0 @@ -package ru.javawebinar.basejava.storage.junit5; - -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import ru.javawebinar.basejava.exception.ExistStorageException; -import ru.javawebinar.basejava.exception.NotExistStorageException; -import ru.javawebinar.basejava.model.Resume; -import ru.javawebinar.basejava.storage.Storage; - -import java.util.Arrays; - -import static org.junit.jupiter.api.Assertions.*; -import static ru.javawebinar.basejava.storage.Util.*; - -public abstract class AbstractStorageTest { - protected Storage storage; - - protected AbstractStorageTest(Storage storage) { - this.storage = storage; - } - - @BeforeEach - void beforeEach() { - storage.clear(); - storage.save(R1); - storage.save(R2); - storage.save(R3); - } - - @Test - void size() throws Exception { - assertSize(3); - } - - @Test - void clear() throws Exception { - storage.clear(); - assertSize(0); - } - - - @Test - void update() throws Exception { - Resume r2New = new Resume(UUID_2, "New Name"); - storage.update(r2New); - - assertEquals(r2New, storage.get(R2.getUuid())); -// assertSame(r2New, storage.get(UUID_2)); - } - - - @Test - void updateNonExisting() { - assertThrows( - NotExistStorageException.class, - () -> storage.update(FAKE) - ); - } - - @Test - void save() throws Exception { - storage.save(R4); - - assertSize(4); - assertSame(R4, storage.get(UUID_4)); - } - - - @Test - void saveExisting() throws Exception { - assertThrows(ExistStorageException.class, - () -> storage.save(R1)); - } - - - @Test - void delete() throws Exception { - storage.delete(UUID_2); - assertAll("storage size is decreased, and access to deleted item correctly throws", - () -> assertEquals(2, storage.size()), - () -> assertThrows(NotExistStorageException.class, - () -> storage.get(UUID_2)) - ); - } - - @Test - void deleteNonExisting() { - assertThrows( - NotExistStorageException.class, - () -> storage.delete(FAKE.getUuid()) - ); - } - - - @Test - void getAllSorted() throws Exception { - assertEquals(Arrays.asList(R1, R2, R3), storage.getAllSorted()); - assertSize(3); - } - -// @Test -// void getAll() throws Exception { -// Resume[] test = new Resume[]{R1, R2, R3}; -// assertEquals(3, storage.getAll().length); -// assertArrayEquals(test, storage.getAll()); -// } - - - @Test - void get() throws Exception { - assertGet(R1); - } - - @Test - void getNonExistinging() { - assertThrows( - NotExistStorageException.class, - () -> storage.get(FAKE.getUuid()) - ); - } - - - protected void assertSize(int size) { - assertEquals(size, storage.size()); - } - - private void assertGet(Resume r) { - assertEquals(r, storage.get(r.getUuid())); - } -} diff --git a/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java deleted file mode 100644 index b12f5ed..0000000 --- a/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java +++ /dev/null @@ -1,12 +0,0 @@ -package ru.javawebinar.basejava.storage.junit5; - -import org.junit.jupiter.api.DisplayName; -import ru.javawebinar.basejava.storage.ArrayStorage; - -@DisplayName("ArrayStorage implementation") -public class ArrayStorageTest extends AbstractArrayStorageTest { - - public ArrayStorageTest() { - super(new ArrayStorage()); - } -} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java deleted file mode 100644 index af5b0ea..0000000 --- a/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java +++ /dev/null @@ -1,11 +0,0 @@ -package ru.javawebinar.basejava.storage.junit5; - -import org.junit.jupiter.api.DisplayName; -import ru.javawebinar.basejava.storage.impl.ListStorage; - -@DisplayName("ListStorage implementation") -class ListStorageTest extends AbstractStorageTest { - public ListStorageTest() { - super(new ListStorage()); - } -} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java deleted file mode 100644 index fa64c93..0000000 --- a/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java +++ /dev/null @@ -1,11 +0,0 @@ -package ru.javawebinar.basejava.storage.junit5; - -import org.junit.jupiter.api.DisplayName; -import ru.javawebinar.basejava.storage.impl.MapResumeStorage; - -@DisplayName("MapResumeStorage implementation") -public class MapResumeStorageTest extends AbstractStorageTest { - public MapResumeStorageTest() { - super(new MapResumeStorage()); - } -} diff --git a/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java deleted file mode 100644 index 2091a01..0000000 --- a/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java +++ /dev/null @@ -1,11 +0,0 @@ -package ru.javawebinar.basejava.storage.junit5; - -import org.junit.jupiter.api.DisplayName; -import ru.javawebinar.basejava.storage.impl.MapUuidStorage; - -@DisplayName("MapUuidStorage implementation") -public class MapUuidStorageTest extends AbstractStorageTest { - public MapUuidStorageTest() { - super(new MapUuidStorage()); - } -} diff --git a/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java deleted file mode 100644 index eb840ad..0000000 --- a/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java +++ /dev/null @@ -1,12 +0,0 @@ -package ru.javawebinar.basejava.storage.junit5; - -import org.junit.jupiter.api.DisplayName; -import ru.javawebinar.basejava.storage.impl.SortedArrayStorage; - -@DisplayName("SortedArrayStorage implementation") -public class SortedArrayStorageTest extends AbstractArrayStorageTest { - - public SortedArrayStorageTest() { - super(new SortedArrayStorage()); - } -} \ No newline at end of file From 7a28500f0051a146feea6d051b46e6e2fc097986 Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Sat, 31 Aug 2019 15:31:10 +0300 Subject: [PATCH 17/18] all seemingly fixed --- src/ru/javawebinar/basejava/MainArray.java | 16 +-- .../javawebinar/basejava/MainReflection.java | 18 +-- .../basejava/MainTestArrayStorage.java | 3 +- .../storage/AbstractArrayStorage.java | 20 ++- .../basejava/storage/AbstractStorage.java | 22 ++- .../javawebinar/basejava/storage/Storage.java | 4 +- .../basejava/storage/impl/ArrayStorage.java | 7 +- .../basejava/storage/impl/ListStorage.java | 12 +- .../storage/impl/MapResumeStorage.java | 15 +- .../basejava/storage/impl/MapUuidStorage.java | 19 +-- .../storage/impl/SortedArrayStorage.java | 4 +- .../junit4/AbstractArrayStorageTest.java | 32 +++++ .../storage/junit4/AbstractStorageTest.java | 13 +- .../storage/junit4/ArrayStorageTest.java | 10 ++ .../storage/junit4/ListStorageTest.java | 3 +- .../storage/junit4/MapResumeStorageTest.java | 11 ++ .../storage/junit4/MapUuidStorageTest.java | 10 ++ .../junit4/SortedArrayStorageTest.java | 11 ++ .../storage/junit4/StorageTestSuite.java | 19 +++ .../junit5/AbstractArrayStorageTest.java | 56 ++++++++ .../storage/junit5/AbstractStorageTest.java | 130 ++++++++++++++++++ .../storage/junit5/ArrayStorageTest.java | 12 ++ .../storage/junit5/ListStorageTest.java | 11 ++ .../storage/junit5/MapResumeStorageTest.java | 11 ++ .../storage/junit5/MapUuidStorageTest.java | 11 ++ .../junit5/SortedArrayStorageTest.java | 12 ++ 26 files changed, 414 insertions(+), 78 deletions(-) create mode 100644 test/ru/javawebinar/basejava/storage/junit4/AbstractArrayStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit4/ArrayStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit4/MapResumeStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit4/MapUuidStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit4/SortedArrayStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit4/StorageTestSuite.java create mode 100644 test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java create mode 100644 test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java diff --git a/src/ru/javawebinar/basejava/MainArray.java b/src/ru/javawebinar/basejava/MainArray.java index e2fb2a7..bc9b166 100644 --- a/src/ru/javawebinar/basejava/MainArray.java +++ b/src/ru/javawebinar/basejava/MainArray.java @@ -1,7 +1,7 @@ package ru.javawebinar.basejava; import ru.javawebinar.basejava.model.Resume; -import ru.javawebinar.basejava.storage.ArrayStorage; +import ru.javawebinar.basejava.storage.impl.ArrayStorage; import ru.javawebinar.basejava.storage.Storage; import java.io.BufferedReader; @@ -17,7 +17,7 @@ public class MainArray { public static void main(String[] args) throws IOException { BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); - Resume r; + Resume resume; while (true) { System.out.print("Введите одну из команд - (list | save uuid | delete uuid | get uuid | update uuid | clear | exit): "); String[] params = reader.readLine().trim().toLowerCase().split(" "); @@ -37,13 +37,13 @@ public static void main(String[] args) throws IOException { System.out.println(ARRAY_STORAGE.size()); break; case "save": - r = new Resume(uuid, "Name"+uuid); - ARRAY_STORAGE.save(r); + resume = new Resume(uuid, "Name"+uuid); + ARRAY_STORAGE.save(resume); printAll(); break; case "update": - r = new Resume(uuid, "Name"+uuid); - ARRAY_STORAGE.update(r); + resume = new Resume(uuid, "Name"+uuid); + ARRAY_STORAGE.update(resume); printAll(); break; case "delete": @@ -72,8 +72,8 @@ static void printAll() { if (all.size() == 0) { System.out.println("Empty"); } else { - for (Resume r : all) { - System.out.println(r); + for (Resume resume : all) { + System.out.println(resume); } } System.out.println("----------------------------"); diff --git a/src/ru/javawebinar/basejava/MainReflection.java b/src/ru/javawebinar/basejava/MainReflection.java index c9df96a..84d7c86 100644 --- a/src/ru/javawebinar/basejava/MainReflection.java +++ b/src/ru/javawebinar/basejava/MainReflection.java @@ -9,22 +9,22 @@ public class MainReflection { public static void main(String[] args) throws IllegalAccessException { - Resume r = new Resume("New Person"); - Field field = r.getClass().getDeclaredFields()[0]; + Resume resume = new Resume("New Person"); + Field field = resume.getClass().getDeclaredFields()[0]; field.setAccessible(true); System.out.println(field.getName()); - System.out.println(field.get(r)); - field.set(r, "new_uuid"); - // TODO : invoke r.toString via reflection - System.out.println(r); + System.out.println(field.get(resume)); + field.set(resume, "new_uuid"); + // TODO : invoke resume.toString via reflection + System.out.println(resume); - System.out.println(field.get(r)); + System.out.println(field.get(resume)); try { - Method toString = r.getClass().getMethod("toString"); + Method toString = resume.getClass().getMethod("toString"); try { - Object invoke = toString.invoke(r); + Object invoke = toString.invoke(resume); System.out.println(invoke); } catch (IllegalArgumentException e) { } diff --git a/src/ru/javawebinar/basejava/MainTestArrayStorage.java b/src/ru/javawebinar/basejava/MainTestArrayStorage.java index 9b84ecc..d4ff5b8 100644 --- a/src/ru/javawebinar/basejava/MainTestArrayStorage.java +++ b/src/ru/javawebinar/basejava/MainTestArrayStorage.java @@ -1,7 +1,8 @@ package ru.javawebinar.basejava; import ru.javawebinar.basejava.model.Resume; -import ru.javawebinar.basejava.storage.ArrayStorage; +import ru.javawebinar.basejava.storage.impl.ArrayStorage; + /** * Test ru.javawebinar.basejava.storage.impl.ArrayStorage diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java index 94a2f2b..40a29ec 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java @@ -26,24 +26,21 @@ public void clear() { } @Override - protected void doUpdate(Resume r, Object index) { - storage[(Integer) index] = r; + protected void doUpdate(Resume resume, Object index) { + storage[(Integer) index] = resume; } @Override - public List getAllSorted() { - List resumes = Arrays.asList(Arrays.copyOfRange(storage, 0, size)); - Collections.sort(resumes); - return resumes; + public List doCopyAll() { + return Arrays.asList(Arrays.copyOfRange(storage, 0, size)); } - @Override - protected void doSave(Resume r, Object index) { + protected void doSave(Resume resume, Object index) { if (size == STORAGE_LIMIT) { - throw new StorageException("Storage overflow", r.getUuid()); + throw new StorageException("Storage overflow", resume.getUuid()); } else { - insertElement(r, (Integer) index); + insertElement(resume, (Integer) index); size++; } } @@ -66,7 +63,6 @@ protected boolean isExist(Object index) { protected abstract void fillDeletedElement(int index); - protected abstract void insertElement(Resume r, int index); + protected abstract void insertElement(Resume resume, int index); -// protected abstract Integer getSearchKey(String uuid); } \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/storage/AbstractStorage.java b/src/ru/javawebinar/basejava/storage/AbstractStorage.java index 9698ec3..3b78f9c 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractStorage.java @@ -4,6 +4,7 @@ import ru.javawebinar.basejava.exception.NotExistStorageException; import ru.javawebinar.basejava.model.Resume; +import java.util.Collections; import java.util.List; public abstract class AbstractStorage implements Storage { @@ -20,18 +21,18 @@ public abstract class AbstractStorage implements Storage { protected abstract void doDelete(Object searchKey); - public abstract List getAllSorted(); + protected abstract List doCopyAll(); @Override - public void update(Resume r) { - Object searchKey = getExistedSearchKey(r.getUuid()); - doUpdate(r, searchKey); + public void update(Resume resume) { + Object searchKey = getExistedSearchKey(resume.getUuid()); + doUpdate(resume, searchKey); } @Override - public void save(Resume r) { - Object searchKey = getNotExistedSearchKey(r.getUuid()); - doSave(r, searchKey); + public void save(Resume resume) { + Object searchKey = getNotExistedSearchKey(resume.getUuid()); + doSave(resume, searchKey); } @Override @@ -46,6 +47,13 @@ public Resume get(String uuid) { return doGet(searchKey); } + @Override + public List getAllSorted() { + List list = doCopyAll(); + Collections.sort(list); + return list; + } + private Object getExistedSearchKey(String uuid) { Object searchKey = getSearchKey(uuid); if (!isExist(searchKey)) { diff --git a/src/ru/javawebinar/basejava/storage/Storage.java b/src/ru/javawebinar/basejava/storage/Storage.java index baf1c97..a29b66b 100644 --- a/src/ru/javawebinar/basejava/storage/Storage.java +++ b/src/ru/javawebinar/basejava/storage/Storage.java @@ -8,9 +8,9 @@ public interface Storage { void clear(); - void update(Resume r); + void update(Resume resume); - void save(Resume r); + void save(Resume resume); Resume get(String uuid); diff --git a/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java index b9722d8..ab33615 100644 --- a/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/ArrayStorage.java @@ -1,6 +1,7 @@ -package ru.javawebinar.basejava.storage; +package ru.javawebinar.basejava.storage.impl; import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.AbstractArrayStorage; /** * Array based storage for Resumes @@ -13,8 +14,8 @@ protected void fillDeletedElement(int index) { } @Override - protected void insertElement(Resume r, int index) { - storage[size] = r; + protected void insertElement(Resume resume, int index) { + storage[size] = resume; } protected Integer getSearchKey(String uuid) { diff --git a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java index 8e9c42c..fb53659 100644 --- a/src/ru/javawebinar/basejava/storage/impl/ListStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/ListStorage.java @@ -25,13 +25,13 @@ protected boolean isExist(Object searchKey) { } @Override - protected void doUpdate(Resume r, Object searchKey) { - list.set((Integer) searchKey, r); + protected void doUpdate(Resume resume, Object searchKey) { + list.set((Integer) searchKey, resume); } @Override - protected void doSave(Resume r, Object searchKey) { - list.add(r); + protected void doSave(Resume resume, Object searchKey) { + list.add(resume); } @Override @@ -50,7 +50,9 @@ public void clear() { } @Override - public List getAllSorted() {return new ArrayList<>(list);} + public List doCopyAll() { + return new ArrayList<>(list); + } @Override public int size() { diff --git a/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java index e51357e..69147b5 100644 --- a/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java @@ -18,8 +18,8 @@ protected Resume getSearchKey(String uuid) { } @Override - protected void doUpdate(Resume r, Object searchKey) { - map.put(r.getUuid(), r); + protected void doUpdate(Resume resume, Object searchKey) { + map.put(resume.getUuid(), resume); } @Override @@ -28,8 +28,8 @@ protected boolean isExist(Object searchKey) { } @Override - protected void doSave(Resume r, Object searchKey) { - map.put(r.getUuid(), r); + protected void doSave(Resume resume, Object searchKey) { + map.put(resume.getUuid(), resume); } @Override @@ -53,12 +53,9 @@ public int size() { } @Override - public List getAllSorted() { - return new ArrayList<>(map.values().stream() - .sorted() - .collect(Collectors.toList())); + public List doCopyAll() { + return new ArrayList<>(map.values()); } - private String getUuid(Object searchKey) { return ((Resume) searchKey).getUuid(); } diff --git a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java index 4d32135..a7d4da5 100644 --- a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java @@ -3,10 +3,7 @@ import ru.javawebinar.basejava.model.Resume; import ru.javawebinar.basejava.storage.AbstractStorage; -import java.util.Collection; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; import java.util.stream.Collectors; public class MapUuidStorage extends AbstractStorage { @@ -18,8 +15,8 @@ protected String getSearchKey(String uuid) { } @Override - protected void doUpdate(Resume r, Object searchKey) { - map.put((String) searchKey, r); + protected void doUpdate(Resume resume, Object searchKey) { + map.put((String) searchKey, resume); } @Override @@ -28,8 +25,8 @@ protected boolean isExist(Object searchKey) { } @Override - protected void doSave(Resume r, Object searchKey) { - map.put((String) searchKey, r); + protected void doSave(Resume resume, Object searchKey) { + map.put((String) searchKey, resume); } @Override @@ -49,10 +46,8 @@ public void clear() { @Override - public List getAllSorted() { - return map.values().stream() - .sorted() - .collect(Collectors.toList()); + public List doCopyAll() { + return new ArrayList<>(map.values()); } @Override diff --git a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java index 17398a6..2ad9106 100644 --- a/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/SortedArrayStorage.java @@ -27,11 +27,11 @@ protected void fillDeletedElement(int index) { } @Override - protected void insertElement(Resume r, int index) { + protected void insertElement(Resume resume, int index) { // http://codereview.stackexchange.com/questions/36221/binary-search-for-inserting-in-array#answer-36239 int insertIdx = -index - 1; System.arraycopy(storage, insertIdx, storage, insertIdx + 1, size - insertIdx); - storage[insertIdx] = r; + storage[insertIdx] = resume; } @Override diff --git a/test/ru/javawebinar/basejava/storage/junit4/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/AbstractArrayStorageTest.java new file mode 100644 index 0000000..aa71629 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit4/AbstractArrayStorageTest.java @@ -0,0 +1,32 @@ +package ru.javawebinar.basejava.storage.junit4; + + +import org.junit.Assert; +import org.junit.Test; +import ru.javawebinar.basejava.exception.StorageException; +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.Storage; + +import static ru.javawebinar.basejava.storage.Util.STORAGE_LIMIT; + +/** + * gkislin + * 12.06.2016 + */ +public abstract class AbstractArrayStorageTest extends AbstractStorageTest { + protected AbstractArrayStorageTest(Storage storage) { + super(storage); + } + + @Test(expected = StorageException.class) + public void saveOverflow() throws Exception { + try { + for (int i = 4; i <= STORAGE_LIMIT; i++) { + storage.save(new Resume("Name" + i)); + } + } catch (StorageException e) { + Assert.fail(); + } + storage.save(new Resume("Overflow")); + } +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java index 613b3d1..8f150b2 100644 --- a/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java @@ -13,11 +13,9 @@ import static org.junit.Assert.*; import static ru.javawebinar.basejava.storage.Util.*; -public class AbstractStorageTest { +public abstract class AbstractStorageTest { protected Storage storage; -// public AbstractStorageTest(){} - public AbstractStorageTest(Storage storage) { this.storage = storage; } @@ -38,8 +36,9 @@ public void clear() { @Test public void update() { - storage.update(new Resume(UUID_2, "New Name")); - assertEquals(R2, storage.get(R2.getUuid())); + Resume r2New = new Resume(UUID_2, "New Name"); + storage.update(r2New); + assertEquals(r2New, storage.get(R2.getUuid())); } @Test(expected = NotExistStorageException.class) @@ -91,8 +90,8 @@ private void assertSize(int size) { assertEquals(size, storage.size()); } - private void assertGet(Resume r) { - assertEquals(r, storage.get(r.getUuid())); + private void assertGet(Resume resume) { + assertEquals(resume, storage.get(resume.getUuid())); } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit4/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/ArrayStorageTest.java new file mode 100644 index 0000000..8f0d0ff --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit4/ArrayStorageTest.java @@ -0,0 +1,10 @@ +package ru.javawebinar.basejava.storage.junit4; + +import ru.javawebinar.basejava.storage.impl.ArrayStorage; + +public class ArrayStorageTest extends AbstractArrayStorageTest { + + public ArrayStorageTest() { + super(new ArrayStorage()); + } +} diff --git a/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java index e27d48d..bd45f9a 100644 --- a/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java @@ -1,8 +1,9 @@ package ru.javawebinar.basejava.storage.junit4; +import org.junit.Before; import ru.javawebinar.basejava.storage.impl.ListStorage; -class ListStorageTest extends ru.javawebinar.basejava.storage.junit4.AbstractStorageTest { +public class ListStorageTest extends ru.javawebinar.basejava.storage.junit4.AbstractStorageTest { public ListStorageTest() { super(new ListStorage()); } diff --git a/test/ru/javawebinar/basejava/storage/junit4/MapResumeStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/MapResumeStorageTest.java new file mode 100644 index 0000000..10c6a11 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit4/MapResumeStorageTest.java @@ -0,0 +1,11 @@ +package ru.javawebinar.basejava.storage.junit4; + +import ru.javawebinar.basejava.storage.impl.MapResumeStorage; +import ru.javawebinar.basejava.storage.impl.MapUuidStorage; + +public class MapResumeStorageTest extends AbstractStorageTest { + + public MapResumeStorageTest() { + super(new MapResumeStorage()); + } +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit4/MapUuidStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/MapUuidStorageTest.java new file mode 100644 index 0000000..37b87e5 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit4/MapUuidStorageTest.java @@ -0,0 +1,10 @@ +package ru.javawebinar.basejava.storage.junit4; + +import ru.javawebinar.basejava.storage.impl.MapUuidStorage; + +public class MapUuidStorageTest extends AbstractStorageTest { + + public MapUuidStorageTest() { + super(new MapUuidStorage()); + } +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit4/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/SortedArrayStorageTest.java new file mode 100644 index 0000000..12f1af1 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit4/SortedArrayStorageTest.java @@ -0,0 +1,11 @@ +package ru.javawebinar.basejava.storage.junit4; + +import ru.javawebinar.basejava.storage.impl.ArrayStorage; +import ru.javawebinar.basejava.storage.impl.SortedArrayStorage; + +public class SortedArrayStorageTest extends AbstractArrayStorageTest { + + public SortedArrayStorageTest() { + super(new SortedArrayStorage()); + } +} diff --git a/test/ru/javawebinar/basejava/storage/junit4/StorageTestSuite.java b/test/ru/javawebinar/basejava/storage/junit4/StorageTestSuite.java new file mode 100644 index 0000000..6765029 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit4/StorageTestSuite.java @@ -0,0 +1,19 @@ +package ru.javawebinar.basejava.storage.junit4; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import ru.javawebinar.basejava.storage.junit4.*; + + +@RunWith(Suite.class) +@Suite.SuiteClasses( + { + ListStorageTest.class, + MapUuidStorageTest.class, + MapResumeStorageTest.class, + ArrayStorageTest.class, + SortedArrayStorageTest.class + }) +public class StorageTestSuite { + +} diff --git a/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java new file mode 100644 index 0000000..a22f59a --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java @@ -0,0 +1,56 @@ +package ru.javawebinar.basejava.storage.junit5; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.function.Executable; +import ru.javawebinar.basejava.exception.StorageException; +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.Storage; + +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.*; +import static ru.javawebinar.basejava.storage.Util.STORAGE_LIMIT; + + +public abstract class AbstractArrayStorageTest extends AbstractStorageTest { + + protected AbstractArrayStorageTest(Storage storage) { + super(storage); + } + + + @Nested + class SaveOverflow { + + @BeforeEach + void setUp() { + storage.clear(); + } + + @Test + @DisplayName("Should not throw within size limit, then throws when overflow") + void fill() { + // arrange + String uuid = "New item"; + Executable throwingExecutable = () -> { + storage.save(new Resume(uuid, "Extra soldier")); + }; + + // act and assert + assertDoesNotThrow(() -> IntStream.iterate(0, n -> n + 1). + limit(STORAGE_LIMIT). + mapToObj(i -> new Resume("Name" + i, "Name" + i)). + forEach(storage::save)); + + RuntimeException thrown = assertThrows( + StorageException.class, throwingExecutable, "Should throw generic StorageException" + ); + + assertEquals("Storage overflow", thrown.getMessage()); + } + } + +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java new file mode 100644 index 0000000..e6bbbb6 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java @@ -0,0 +1,130 @@ +package ru.javawebinar.basejava.storage.junit5; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import ru.javawebinar.basejava.exception.ExistStorageException; +import ru.javawebinar.basejava.exception.NotExistStorageException; +import ru.javawebinar.basejava.model.Resume; +import ru.javawebinar.basejava.storage.Storage; + +import java.util.Arrays; + +import static org.junit.jupiter.api.Assertions.*; +import static ru.javawebinar.basejava.storage.Util.*; + +public abstract class AbstractStorageTest { + protected Storage storage; + + protected AbstractStorageTest(Storage storage) { + this.storage = storage; + } + + @BeforeEach + void beforeEach() { + storage.clear(); + storage.save(R1); + storage.save(R2); + storage.save(R3); + } + + @Test + void size() throws Exception { + assertSize(3); + } + + @Test + void clear() throws Exception { + storage.clear(); + assertSize(0); + } + + + @Test + void update() throws Exception { + Resume r2New = new Resume(UUID_2, "New Name"); + storage.update(r2New); + + assertEquals(r2New, storage.get(R2.getUuid())); +// assertSame(r2New, storage.get(UUID_2)); + } + + + @Test + void updateNonExisting() { + assertThrows( + NotExistStorageException.class, + () -> storage.update(FAKE) + ); + } + + @Test + void save() throws Exception { + storage.save(R4); + + assertSize(4); + assertSame(R4, storage.get(UUID_4)); + } + + + @Test + void saveExisting() throws Exception { + assertThrows(ExistStorageException.class, + () -> storage.save(R1)); + } + + + @Test + void delete() throws Exception { + storage.delete(UUID_2); + assertAll("storage size is decreased, and access to deleted item correctly throws", + () -> assertEquals(2, storage.size()), + () -> assertThrows(NotExistStorageException.class, + () -> storage.get(UUID_2)) + ); + } + + @Test + void deleteNonExisting() { + assertThrows( + NotExistStorageException.class, + () -> storage.delete(FAKE.getUuid()) + ); + } + + + @Test + void getAllSorted() throws Exception { + assertEquals(Arrays.asList(R1, R2, R3), storage.getAllSorted()); + assertSize(3); + } + +// @Test +// void getAll() throws Exception { +// Resume[] test = new Resume[]{R1, R2, R3}; +// assertEquals(3, storage.getAll().length); +// assertArrayEquals(test, storage.getAll()); +// } + + + @Test + void get() throws Exception { + assertGet(R1); + } + + @Test + void getNonExistinging() { + assertThrows( + NotExistStorageException.class, + () -> storage.get(FAKE.getUuid()) + ); + } + + + protected void assertSize(int size) { + assertEquals(size, storage.size()); + } + + private void assertGet(Resume resume) { + assertEquals(resume, storage.get(resume.getUuid())); + } +} diff --git a/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java new file mode 100644 index 0000000..0cd0fd1 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java @@ -0,0 +1,12 @@ +package ru.javawebinar.basejava.storage.junit5; + +import org.junit.jupiter.api.DisplayName; +import ru.javawebinar.basejava.storage.impl.ArrayStorage; + +@DisplayName("ArrayStorage implementation") +public class ArrayStorageTest extends AbstractArrayStorageTest { + + public ArrayStorageTest() { + super(new ArrayStorage()); + } +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java new file mode 100644 index 0000000..af5b0ea --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java @@ -0,0 +1,11 @@ +package ru.javawebinar.basejava.storage.junit5; + +import org.junit.jupiter.api.DisplayName; +import ru.javawebinar.basejava.storage.impl.ListStorage; + +@DisplayName("ListStorage implementation") +class ListStorageTest extends AbstractStorageTest { + public ListStorageTest() { + super(new ListStorage()); + } +} \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java new file mode 100644 index 0000000..fa64c93 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java @@ -0,0 +1,11 @@ +package ru.javawebinar.basejava.storage.junit5; + +import org.junit.jupiter.api.DisplayName; +import ru.javawebinar.basejava.storage.impl.MapResumeStorage; + +@DisplayName("MapResumeStorage implementation") +public class MapResumeStorageTest extends AbstractStorageTest { + public MapResumeStorageTest() { + super(new MapResumeStorage()); + } +} diff --git a/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java new file mode 100644 index 0000000..2091a01 --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java @@ -0,0 +1,11 @@ +package ru.javawebinar.basejava.storage.junit5; + +import org.junit.jupiter.api.DisplayName; +import ru.javawebinar.basejava.storage.impl.MapUuidStorage; + +@DisplayName("MapUuidStorage implementation") +public class MapUuidStorageTest extends AbstractStorageTest { + public MapUuidStorageTest() { + super(new MapUuidStorage()); + } +} diff --git a/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java new file mode 100644 index 0000000..eb840ad --- /dev/null +++ b/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java @@ -0,0 +1,12 @@ +package ru.javawebinar.basejava.storage.junit5; + +import org.junit.jupiter.api.DisplayName; +import ru.javawebinar.basejava.storage.impl.SortedArrayStorage; + +@DisplayName("SortedArrayStorage implementation") +public class SortedArrayStorageTest extends AbstractArrayStorageTest { + + public SortedArrayStorageTest() { + super(new SortedArrayStorage()); + } +} \ No newline at end of file From 0bcc246e07c378bda12dbbaceb708259bfd62c4c Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Sun, 1 Sep 2019 16:03:30 +0300 Subject: [PATCH 18/18] fixed delete test renamed all juint5 classes --- src/ru/javawebinar/basejava/MainArray.java | 6 +++--- .../javawebinar/basejava/MainReflection.java | 19 ++++--------------- src/ru/javawebinar/basejava/model/Resume.java | 5 ++++- .../storage/AbstractArrayStorage.java | 1 - .../storage/impl/MapResumeStorage.java | 2 +- .../basejava/storage/impl/MapUuidStorage.java | 6 ++++-- .../junit4/AbstractArrayStorageTest.java | 10 ++++------ .../storage/junit4/AbstractStorageTest.java | 10 +++++----- .../storage/junit4/ListStorageTest.java | 3 +-- .../storage/junit4/MapResumeStorageTest.java | 1 - .../junit4/SortedArrayStorageTest.java | 1 - .../storage/junit4/StorageTestSuite.java | 1 - ...st.java => AbstractArrayStorageTest5.java} | 4 ++-- ...ageTest.java => AbstractStorageTest5.java} | 4 ++-- ...torageTest.java => ArrayStorageTest5.java} | 4 ++-- ...StorageTest.java => ListStorageTest5.java} | 4 ++-- ...geTest.java => MapResumeStorageTest5.java} | 4 ++-- ...rageTest.java => MapUuidStorageTest5.java} | 4 ++-- ...Test.java => SortedArrayStorageTest5.java} | 4 ++-- 19 files changed, 40 insertions(+), 53 deletions(-) rename test/ru/javawebinar/basejava/storage/junit5/{AbstractArrayStorageTest.java => AbstractArrayStorageTest5.java} (91%) rename test/ru/javawebinar/basejava/storage/junit5/{AbstractStorageTest.java => AbstractStorageTest5.java} (96%) rename test/ru/javawebinar/basejava/storage/junit5/{ArrayStorageTest.java => ArrayStorageTest5.java} (70%) rename test/ru/javawebinar/basejava/storage/junit5/{ListStorageTest.java => ListStorageTest5.java} (73%) rename test/ru/javawebinar/basejava/storage/junit5/{MapResumeStorageTest.java => MapResumeStorageTest5.java} (70%) rename test/ru/javawebinar/basejava/storage/junit5/{MapUuidStorageTest.java => MapUuidStorageTest5.java} (71%) rename test/ru/javawebinar/basejava/storage/junit5/{SortedArrayStorageTest.java => SortedArrayStorageTest5.java} (69%) diff --git a/src/ru/javawebinar/basejava/MainArray.java b/src/ru/javawebinar/basejava/MainArray.java index bc9b166..6deb931 100644 --- a/src/ru/javawebinar/basejava/MainArray.java +++ b/src/ru/javawebinar/basejava/MainArray.java @@ -1,8 +1,8 @@ package ru.javawebinar.basejava; import ru.javawebinar.basejava.model.Resume; -import ru.javawebinar.basejava.storage.impl.ArrayStorage; import ru.javawebinar.basejava.storage.Storage; +import ru.javawebinar.basejava.storage.impl.ArrayStorage; import java.io.BufferedReader; import java.io.IOException; @@ -37,12 +37,12 @@ public static void main(String[] args) throws IOException { System.out.println(ARRAY_STORAGE.size()); break; case "save": - resume = new Resume(uuid, "Name"+uuid); + resume = new Resume(uuid, "Name" + uuid); ARRAY_STORAGE.save(resume); printAll(); break; case "update": - resume = new Resume(uuid, "Name"+uuid); + resume = new Resume(uuid, "Name" + uuid); ARRAY_STORAGE.update(resume); printAll(); break; diff --git a/src/ru/javawebinar/basejava/MainReflection.java b/src/ru/javawebinar/basejava/MainReflection.java index 84d7c86..387bdba 100644 --- a/src/ru/javawebinar/basejava/MainReflection.java +++ b/src/ru/javawebinar/basejava/MainReflection.java @@ -8,7 +8,7 @@ public class MainReflection { - public static void main(String[] args) throws IllegalAccessException { + public static void main(String[] args) throws IllegalAccessException, NoSuchMethodException, InvocationTargetException { Resume resume = new Resume("New Person"); Field field = resume.getClass().getDeclaredFields()[0]; field.setAccessible(true); @@ -20,21 +20,10 @@ public static void main(String[] args) throws IllegalAccessException { System.out.println(field.get(resume)); - try { - Method toString = resume.getClass().getMethod("toString"); - - try { - Object invoke = toString.invoke(resume); - System.out.println(invoke); - - } catch (IllegalArgumentException e) { } - catch (IllegalAccessException e) { } - catch (InvocationTargetException e) { } - - } catch (SecurityException e) { } - catch (NoSuchMethodException e) { } - + Method toString = resume.getClass().getMethod("toString"); + Object invoke = toString.invoke(resume); + System.out.println(invoke); } } \ No newline at end of file diff --git a/src/ru/javawebinar/basejava/model/Resume.java b/src/ru/javawebinar/basejava/model/Resume.java index 543e94f..86c602b 100644 --- a/src/ru/javawebinar/basejava/model/Resume.java +++ b/src/ru/javawebinar/basejava/model/Resume.java @@ -13,7 +13,10 @@ public class Resume implements Comparable { private String fullName; - public Resume(){}; + public Resume() { + } + + ; public Resume(String fullName) { this(UUID.randomUUID().toString(), fullName); diff --git a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java index 40a29ec..67ee870 100644 --- a/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java +++ b/src/ru/javawebinar/basejava/storage/AbstractArrayStorage.java @@ -4,7 +4,6 @@ import ru.javawebinar.basejava.model.Resume; import java.util.Arrays; -import java.util.Collections; import java.util.List; /** diff --git a/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java index 69147b5..f3cc2a9 100644 --- a/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/MapResumeStorage.java @@ -7,7 +7,6 @@ import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.stream.Collectors; public class MapResumeStorage extends AbstractStorage { private Map map = new HashMap<>(); @@ -56,6 +55,7 @@ public int size() { public List doCopyAll() { return new ArrayList<>(map.values()); } + private String getUuid(Object searchKey) { return ((Resume) searchKey).getUuid(); } diff --git a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java index a7d4da5..93142af 100644 --- a/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java +++ b/src/ru/javawebinar/basejava/storage/impl/MapUuidStorage.java @@ -3,8 +3,10 @@ import ru.javawebinar.basejava.model.Resume; import ru.javawebinar.basejava.storage.AbstractStorage; -import java.util.*; -import java.util.stream.Collectors; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; public class MapUuidStorage extends AbstractStorage { private Map map = new HashMap<>(); diff --git a/test/ru/javawebinar/basejava/storage/junit4/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/AbstractArrayStorageTest.java index aa71629..494e48b 100644 --- a/test/ru/javawebinar/basejava/storage/junit4/AbstractArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit4/AbstractArrayStorageTest.java @@ -9,19 +9,17 @@ import static ru.javawebinar.basejava.storage.Util.STORAGE_LIMIT; -/** - * gkislin - * 12.06.2016 - */ + public abstract class AbstractArrayStorageTest extends AbstractStorageTest { protected AbstractArrayStorageTest(Storage storage) { super(storage); } + @Test(expected = StorageException.class) - public void saveOverflow() throws Exception { + public void saveOverFlowException() throws Exception { try { - for (int i = 4; i <= STORAGE_LIMIT; i++) { + for (int i = storage.size() + 1; i <= STORAGE_LIMIT; i++) { storage.save(new Resume("Name" + i)); } } catch (StorageException e) { diff --git a/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java index 8f150b2..9527402 100644 --- a/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit4/AbstractStorageTest.java @@ -10,7 +10,7 @@ import java.util.Arrays; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; import static ru.javawebinar.basejava.storage.Util.*; public abstract class AbstractStorageTest { @@ -55,7 +55,7 @@ public void getAllSorted() throws Exception { @Test public void save() throws Exception { storage.save(R4); - Assert.assertTrue(storage.getAllSorted().contains(R4)); + assertGet(R4); assertSize(4); } @@ -64,16 +64,16 @@ public void saveExisting() throws Exception { storage.save(R1); } - @Test + @Test(expected = NotExistStorageException.class) public void delete() throws Exception { storage.delete(R2.getUuid()); - Assert.assertFalse(storage.getAllSorted().contains(R2)); assertSize(2); + storage.get(R2.getUuid()); } @Test(expected = NotExistStorageException.class) public void deleteNotExisting() throws Exception { - storage.delete(FAKE.getUuid()); + storage.delete(FAKE.getUuid()); // UUID_FAKE } @Test diff --git a/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java index bd45f9a..ae80c4e 100644 --- a/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit4/ListStorageTest.java @@ -1,9 +1,8 @@ package ru.javawebinar.basejava.storage.junit4; -import org.junit.Before; import ru.javawebinar.basejava.storage.impl.ListStorage; -public class ListStorageTest extends ru.javawebinar.basejava.storage.junit4.AbstractStorageTest { +public class ListStorageTest extends ru.javawebinar.basejava.storage.junit4.AbstractStorageTest { public ListStorageTest() { super(new ListStorage()); } diff --git a/test/ru/javawebinar/basejava/storage/junit4/MapResumeStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/MapResumeStorageTest.java index 10c6a11..c575baa 100644 --- a/test/ru/javawebinar/basejava/storage/junit4/MapResumeStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit4/MapResumeStorageTest.java @@ -1,7 +1,6 @@ package ru.javawebinar.basejava.storage.junit4; import ru.javawebinar.basejava.storage.impl.MapResumeStorage; -import ru.javawebinar.basejava.storage.impl.MapUuidStorage; public class MapResumeStorageTest extends AbstractStorageTest { diff --git a/test/ru/javawebinar/basejava/storage/junit4/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit4/SortedArrayStorageTest.java index 12f1af1..275ea9f 100644 --- a/test/ru/javawebinar/basejava/storage/junit4/SortedArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit4/SortedArrayStorageTest.java @@ -1,6 +1,5 @@ package ru.javawebinar.basejava.storage.junit4; -import ru.javawebinar.basejava.storage.impl.ArrayStorage; import ru.javawebinar.basejava.storage.impl.SortedArrayStorage; public class SortedArrayStorageTest extends AbstractArrayStorageTest { diff --git a/test/ru/javawebinar/basejava/storage/junit4/StorageTestSuite.java b/test/ru/javawebinar/basejava/storage/junit4/StorageTestSuite.java index 6765029..5c192bd 100644 --- a/test/ru/javawebinar/basejava/storage/junit4/StorageTestSuite.java +++ b/test/ru/javawebinar/basejava/storage/junit4/StorageTestSuite.java @@ -2,7 +2,6 @@ import org.junit.runner.RunWith; import org.junit.runners.Suite; -import ru.javawebinar.basejava.storage.junit4.*; @RunWith(Suite.class) diff --git a/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest5.java similarity index 91% rename from test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest5.java index a22f59a..9409122 100644 --- a/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/AbstractArrayStorageTest5.java @@ -15,9 +15,9 @@ import static ru.javawebinar.basejava.storage.Util.STORAGE_LIMIT; -public abstract class AbstractArrayStorageTest extends AbstractStorageTest { +public abstract class AbstractArrayStorageTest5 extends AbstractStorageTest5 { - protected AbstractArrayStorageTest(Storage storage) { + protected AbstractArrayStorageTest5(Storage storage) { super(storage); } diff --git a/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest5.java similarity index 96% rename from test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest5.java index e6bbbb6..f942f2c 100644 --- a/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/AbstractStorageTest5.java @@ -12,10 +12,10 @@ import static org.junit.jupiter.api.Assertions.*; import static ru.javawebinar.basejava.storage.Util.*; -public abstract class AbstractStorageTest { +public abstract class AbstractStorageTest5 { protected Storage storage; - protected AbstractStorageTest(Storage storage) { + protected AbstractStorageTest5(Storage storage) { this.storage = storage; } diff --git a/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest5.java similarity index 70% rename from test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest5.java index 0cd0fd1..05e765d 100644 --- a/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/ArrayStorageTest5.java @@ -4,9 +4,9 @@ import ru.javawebinar.basejava.storage.impl.ArrayStorage; @DisplayName("ArrayStorage implementation") -public class ArrayStorageTest extends AbstractArrayStorageTest { +public class ArrayStorageTest5 extends AbstractArrayStorageTest5 { - public ArrayStorageTest() { + public ArrayStorageTest5() { super(new ArrayStorage()); } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest5.java similarity index 73% rename from test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/ListStorageTest5.java index af5b0ea..83fe040 100644 --- a/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/ListStorageTest5.java @@ -4,8 +4,8 @@ import ru.javawebinar.basejava.storage.impl.ListStorage; @DisplayName("ListStorage implementation") -class ListStorageTest extends AbstractStorageTest { - public ListStorageTest() { +class ListStorageTest5 extends AbstractStorageTest5 { + public ListStorageTest5() { super(new ListStorage()); } } \ No newline at end of file diff --git a/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest5.java similarity index 70% rename from test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest5.java index fa64c93..84e1136 100644 --- a/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/MapResumeStorageTest5.java @@ -4,8 +4,8 @@ import ru.javawebinar.basejava.storage.impl.MapResumeStorage; @DisplayName("MapResumeStorage implementation") -public class MapResumeStorageTest extends AbstractStorageTest { - public MapResumeStorageTest() { +public class MapResumeStorageTest5 extends AbstractStorageTest5 { + public MapResumeStorageTest5() { super(new MapResumeStorage()); } } diff --git a/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest5.java similarity index 71% rename from test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest5.java index 2091a01..75ddebb 100644 --- a/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/MapUuidStorageTest5.java @@ -4,8 +4,8 @@ import ru.javawebinar.basejava.storage.impl.MapUuidStorage; @DisplayName("MapUuidStorage implementation") -public class MapUuidStorageTest extends AbstractStorageTest { - public MapUuidStorageTest() { +public class MapUuidStorageTest5 extends AbstractStorageTest5 { + public MapUuidStorageTest5() { super(new MapUuidStorage()); } } diff --git a/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java b/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest5.java similarity index 69% rename from test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java rename to test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest5.java index eb840ad..463affd 100644 --- a/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest.java +++ b/test/ru/javawebinar/basejava/storage/junit5/SortedArrayStorageTest5.java @@ -4,9 +4,9 @@ import ru.javawebinar.basejava.storage.impl.SortedArrayStorage; @DisplayName("SortedArrayStorage implementation") -public class SortedArrayStorageTest extends AbstractArrayStorageTest { +public class SortedArrayStorageTest5 extends AbstractArrayStorageTest5 { - public SortedArrayStorageTest() { + public SortedArrayStorageTest5() { super(new SortedArrayStorage()); } } \ No newline at end of file