From b0da3ee8d43f7a32aaf0fade9f36dede0965e786 Mon Sep 17 00:00:00 2001 From: Lev Tikhonov Date: Wed, 10 Jul 2019 14:44:39 +0300 Subject: [PATCH 01/10] 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/10] 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/10] 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/10] 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/10] 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/10] 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/10] 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/10] 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/10] 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/10] 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);