lesson 6. Исправление ошибок

AlbertoJava · AlbertoJava · commit 25ecc3bcc472 · 2019-08-14T19:15:12.000+03:00
diff --git a/src/com/urise/webapp/MainReflection.java b/src/com/urise/webapp/MainReflection.java
@@ -1,38 +1,17 @@
 package com.urise.webapp;
 
 import com.urise.webapp.model.Resume;
-import com.urise.webapp.storage.SortedArrayStorage;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.util.Arrays;
 
 public class MainReflection{
-
- private static final String UUID_1 = "UUID_1";
- private static final String UUID_2 = "UUID_2";
- private static final String UUID_3 = "UUID_3";
- private static final String UUID_4 = "UUID_4";
- private static final Resume R_1 = new Resume(UUID_1,"FIO_1");
- private static final Resume R_2 = new Resume(UUID_2,"FIO_2");
- private static final Resume R_3 = new Resume(UUID_3,"FIO_3");
- private static final Resume R_4 = new Resume(UUID_4,"FIO_4");
-
 public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException{
 Resume test = new Resume("test");
+ System.out.println(test);
 Method method = test.getClass().getMethod("toString");
 System.out.println(method.invoke(test));
- SortedArrayStorage storage = new SortedArrayStorage();
- storage.getStorage()[0]=R_1;
- storage.getStorage()[1]=R_2;
- storage.getStorage()[2]=R_3;
-
- storage.save(R_4);
 
- System.out.println(storage.getStorage().length);
- System.out.println(Arrays.binarySearch(storage.getStorage(),0,9, R_2));
 }
 
-
-
 }
diff --git a/src/com/urise/webapp/model/Resume.java b/src/com/urise/webapp/model/Resume.java
@@ -1,12 +1,12 @@
 package com.urise.webapp.model;
 
-import java.util.Comparator;
+import java.util.Objects;
 import java.util.UUID;
 
 /**
 * Initial resume class
 */
-public class Resume implements Comparator<Resume>, Comparable<Resume>{
+public class Resume implements Comparable<Resume>{
 
 // Unique identifier
 private final String uuid;
@@ -17,6 +17,8 @@ public Resume(String fullName){
 }
 
 public Resume(String uuid, String fullName){
+ Objects.requireNonNull(fullName, "fullName must not be null");
+ Objects.requireNonNull(uuid, "uuid must not be null");
 this.uuid = uuid;
 this.fullName = fullName;
 }
@@ -31,34 +33,28 @@ public String getFullName(){
 
 @Override
 public String toString(){
- return uuid;
+ return uuid + "(" + fullName + ")";
 }
 
- @Override
- public int compare(Resume o1, Resume o2){
- return o1.getUuid().equals(o2.getUuid())?
- o1.getFullName().compareTo(o2.getFullName()):
- o1.getUuid().compareTo(o2.getUuid());
- }
-
-
 @Override
 public boolean equals(Object o){
 if (this == o) return true;
 if (o == null || getClass() != o.getClass()) return false;
-
 Resume resume = (Resume) o;
-
+ if (!uuid.equals(resume.uuid)) return false;
 return uuid.equals(resume.uuid);
 }
 
 @Override
 public int hashCode(){
- return uuid.hashCode();
+ int result = uuid.hashCode();
+ result = 31 * result + fullName.hashCode();
+ return result;
 }
 
 @Override
 public int compareTo(Resume o){
- return this.getFullName().equals(o.fullName)?this.getUuid().compareTo(o.getUuid()):this.getFullName().compareTo(o.getFullName());
+ int cmp = fullName.compareTo(o.fullName);
+ return cmp != 0 ? cmp : uuid.compareTo(o.getUuid());
 }
 }
diff --git a/src/com/urise/webapp/storage/AbstractArrayStorage.java b/src/com/urise/webapp/storage/AbstractArrayStorage.java
@@ -9,11 +9,7 @@
 import java.util.stream.Stream;
 
 public abstract class AbstractArrayStorage extends AbstractStorage{
- protected static final int MAX_SIZE = 10_0000;
-
- public Resume[] getStorage(){
- return storage;
- }
+ protected static final int MAX_SIZE = 10_000;
 
 protected Resume[] storage = new Resume[MAX_SIZE];
 protected int resumeCounter = 0;
@@ -24,8 +20,8 @@ public void clear(){
 }
 
 @Override
- protected Resume doGet(Object existedSearchKey){
- return storage[(Integer) existedSearchKey];
+ protected Resume doGet(Object index){
+ return storage[(Integer) index];
 }
 
 @Override
@@ -49,13 +45,13 @@ protected void doSave(Resume resume, Object index){
 if (resumeCounter >= MAX_SIZE){
 throw new StorageException("Storage overflow", resume.getUuid());
 }
- insertResume((Integer) index, resume);
+ insertResume(resume,(Integer) index);
 resumeCounter++;
 }
 
 @Override
- protected Stream<Resume> getStream(){
- return Arrays.stream(storage,0,resumeCounter);
+ protected List<Resume> doCopyAll(){
+ return Arrays.asList(Arrays.copyOfRange(storage,0,resumeCounter));
 }
 
 public int size(){
@@ -67,7 +63,7 @@ protected boolean isExist(Object index){
 return (Integer) index >= 0;
 }
 
- protected abstract void insertResume(int index, Resume resume);
+ protected abstract void insertResume(Resume resume, int index);
 
 protected abstract void deleteResume(int index);
 }
diff --git a/src/com/urise/webapp/storage/AbstractStorage.java b/src/com/urise/webapp/storage/AbstractStorage.java
@@ -3,30 +3,37 @@
 import com.urise.webapp.exception.ExistStorageException;
 import com.urise.webapp.exception.NotExistStorageException;
 import com.urise.webapp.model.Resume;
+
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
+
 
 public abstract class AbstractStorage implements Storage{
+ Comparator<Resume> RESUME_COMAPATOR= Comparator.comparing(Resume::getUuid);
 
 protected abstract void doUpdate(Resume resume, Object searchKey);
 
 protected abstract boolean isExist(Object searchKey);
 
 protected abstract void doSave(Resume resume, Object searchKey);
 
- protected abstract Resume doGet(Object existedSearchKey);
+ protected abstract Resume doGet(Object searchKey);
 
 protected abstract void doDelete(Object searchKey);
 
 protected abstract Object getSearchKey(String uuid);
 
- protected abstract Stream<Resume> getStream();
+ protected abstract List<Resume> doCopyAll();
 
 public List<Resume> getAllSorted(){
- return getStream().sorted().collect(Collectors.toList());
+ List<Resume> list =doCopyAll();
+ Collections.sort(list);
+ return list;
 }
 
+
+
 public void save(Resume resume){
 doSave(resume, getNotExistedSearchKey(resume.getUuid()));
 }
diff --git a/src/com/urise/webapp/storage/ArrayStorage.java b/src/com/urise/webapp/storage/ArrayStorage.java
@@ -19,7 +19,7 @@ protected Integer getSearchKey(String uuid){
 
 
 @Override
- protected void insertResume(int index, Resume resume){
+ protected void insertResume(Resume resume,int index){
 storage[resumeCounter] = resume;
 }
 
diff --git a/src/com/urise/webapp/storage/ListStorage.java b/src/com/urise/webapp/storage/ListStorage.java
@@ -51,8 +51,8 @@ public void clear(){
 }
 
 @Override
- protected Stream<Resume> getStream(){
- return list.stream();
+ protected List<Resume> doCopyAll(){
+ return new ArrayList<>(list);
 }
 
 @Override
diff --git a/src/com/urise/webapp/storage/MapResumeStorage.java b/src/com/urise/webapp/storage/MapResumeStorage.java
@@ -2,23 +2,23 @@
 
 import com.urise.webapp.model.Resume;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.lang.reflect.Array;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-public class MapStoragePairedKey extends AbstractStorage{
+public class MapResumeStorage extends AbstractStorage{
 private Map<String, Resume> mapStorage = new HashMap<>();
 
 @Override
 protected void doUpdate(Resume resume, Object searchKey){
+
 mapStorage.put(((Resume)searchKey).getUuid(), resume);
 }
 
 @Override
 protected boolean isExist(Object searchKey){
- return searchKey==null?false:true;
+ return searchKey != null;
 }
 
 @Override
@@ -28,27 +28,29 @@ protected void doSave(Resume resume, Object searchKey){
 
 @Override
 protected Resume doGet(Object searchKey){
+
 return (Resume)searchKey;
 }
 
 @Override
 protected void doDelete(Object searchKey){
+
 mapStorage.remove(((Resume)searchKey).getUuid());
 }
 
 @Override
- protected Object getSearchKey(String uuid){
+ protected Resume getSearchKey(String uuid){
 return mapStorage.get(uuid);
 }
 
 @Override
- public void clear(){
- mapStorage.clear();
+ protected List<Resume> doCopyAll(){
+ return new ArrayList(mapStorage.values());
 }
 
 @Override
- public Stream<Resume> getStream(){
- return mapStorage.values().stream();
+ public void clear(){
+ mapStorage.clear();
 }
 
 @Override
diff --git a/src/com/urise/webapp/storage/MapStorage.java b/src/com/urise/webapp/storage/MapStorage.java
@@ -2,14 +2,11 @@
 
 import com.urise.webapp.model.Resume;
 
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
+import java.util.*;
+
 
 public class MapStorage extends AbstractStorage{
- private Map<String, Resume> mapStorage = new HashMap();
+ private Map<String, Resume> mapStorage = new HashMap<>();
 
 @Override
 protected void doUpdate(Resume resume, Object searchKey){
@@ -47,8 +44,8 @@ public void clear(){
 }
 
 @Override
- protected Stream<Resume> getStream(){
- return mapStorage.values().stream();
+ protected List<Resume> doCopyAll(){
+ return new ArrayList<>(mapStorage.values());
 }
 
 @Override
diff --git a/src/com/urise/webapp/storage/SortedArrayStorage.java b/src/com/urise/webapp/storage/SortedArrayStorage.java
@@ -12,19 +12,20 @@
 public class SortedArrayStorage extends AbstractArrayStorage{
 @Override
 protected Integer getSearchKey(String uuid){
- Resume resume = new Resume(uuid,"FIO_1");
- if (resumeCounter==0) return -1;
- String[] uuids = Arrays.stream(storage).limit(resumeCounter).map(r->r.getUuid()).toArray(String[]::new);
+ Resume resume = new Resume(uuid,"defaultFullName");
+ // if (resumeCounter==0) return -1;
+ // String[] uuids = Arrays.stream(storage).limit(resumeCounter).map(r->r.getUuid()).toArray(String[]::new);
 // Arrays.stream(storage).filter(r->r.getUuid().equals(uuid)).count();
 //return Arrays.binarySearch(storage, 0, resumeCounter, resume);
 /* Arrays.stream(storage)
 .sorted(Comparator.comparing(Resume::getUuid))
 .toArray();*/
- return Arrays.binarySearch(uuids,uuid);
+ //return Arrays.binarySearch(uuids,uuid);
+ return Arrays.binarySearch(storage,0,resumeCounter,resume,RESUME_COMAPATOR);
 }
 
 @Override
- protected void insertResume(int index, Resume resume){
+ protected void insertResume(Resume resume, int index){
 int indexResume = -index - 1;
 System.arraycopy(storage, indexResume, storage, indexResume + 1, resumeCounter - indexResume);
 storage[indexResume] = resume;
diff --git a/test/com/urise/webapp/storage/AbstractArrayStorageTest.java b/test/com/urise/webapp/storage/AbstractArrayStorageTest.java
@@ -4,15 +4,15 @@
 import com.urise.webapp.model.Resume;
 import org.junit.Test;
 
-
 import static com.urise.webapp.storage.AbstractArrayStorage.MAX_SIZE;
 import static org.junit.Assert.fail;
 
-public abstract class AbstractArrayStorageTest extends AbstractStorageTest{
+public abstract class AbstractArrayStorageTest extends AbstractStorageTest{
 
 public AbstractArrayStorageTest(AbstractArrayStorage storage){
 super(storage);
 }
+
 @Test(expected = StorageException.class)
 public void sizeOverLoaded(){
 try{
@@ -23,6 +23,6 @@ public void sizeOverLoaded(){
 } catch (StorageException e){
 fail();
 }
- storage.save(new Resume("FIO_" + MAX_SIZE+1));
+ storage.save(new Resume("FIO_" + MAX_SIZE + 1));
 }
 }
diff --git a/test/com/urise/webapp/storage/AbstractStorageTest.java b/test/com/urise/webapp/storage/AbstractStorageTest.java
diff --git a/test/com/urise/webapp/storage/AllStorageTest.java b/test/com/urise/webapp/storage/AllStorageTest.java
diff --git a/test/com/urise/webapp/storage/MapResumeStorageTest.java b/test/com/urise/webapp/storage/MapResumeStorageTest.java
diff --git a/test/com/urise/webapp/storage/MapStoragePairedKeyTest.java b/test/com/urise/webapp/storage/MapStoragePairedKeyTest.java

-Original file line number
+Diff line change
@@ @@ -1,38 +1,17 @@ @@
 packagecom.urise.webapp;
 importcom.urise.webapp.model.Resume;
 -importcom.urise.webapp.storage.SortedArrayStorage;
 importjava.lang.reflect.InvocationTargetException;
 importjava.lang.reflect.Method;
 -importjava.util.Arrays;
 publicclassMainReflection{
+-
 -privatestaticfinalStringUUID_1 = "UUID_1";
 -privatestaticfinalStringUUID_2 = "UUID_2";
 -privatestaticfinalStringUUID_3 = "UUID_3";
 -privatestaticfinalStringUUID_4 = "UUID_4";
 -privatestaticfinalResumeR_1 = newResume(UUID_1,"FIO_1");
 -privatestaticfinalResumeR_2 = newResume(UUID_2,"FIO_2");
 -privatestaticfinalResumeR_3 = newResume(UUID_3,"FIO_3");
 -privatestaticfinalResumeR_4 = newResume(UUID_4,"FIO_4");
+-
 publicstaticvoidmain(String[] args) throwsNoSuchMethodException, InvocationTargetException, IllegalAccessException{
 Resumetest = newResume("test");
 +System.out.println(test);
 Methodmethod = test.getClass().getMethod("toString");
 System.out.println(method.invoke(test));
 -SortedArrayStoragestorage = newSortedArrayStorage();
 -storage.getStorage()[0]=R_1;
 -storage.getStorage()[1]=R_2;
 -storage.getStorage()[2]=R_3;
+-
 -storage.save(R_4);
 -System.out.println(storage.getStorage().length);
 -System.out.println(Arrays.binarySearch(storage.getStorage(),0,9, R_2));
+ }
+-
+-
+}
-Original file line number
+Diff line change
@@ @@ -1,12 +1,12 @@ @@
 packagecom.urise.webapp.model;
 -importjava.util.Comparator;
 +importjava.util.Objects;
 importjava.util.UUID;
 /**
  * Initial resume class
  */
 -publicclassResumeimplementsComparator<Resume>, Comparable<Resume>{
 +publicclassResumeimplementsComparable<Resume>{
 // Unique identifier
 privatefinalStringuuid;
+ }
 publicResume(Stringuuid, StringfullName){
 +Objects.requireNonNull(fullName, "fullName must not be null");
 +Objects.requireNonNull(uuid, "uuid must not be null");
 this.uuid = uuid;
 this.fullName = fullName;
+ }
 @Override
 publicStringtoString(){
 -returnuuid;
 +returnuuid + "(" + fullName + ")";
+ }
 -@Override
 -publicintcompare(Resumeo1, Resumeo2){
 -returno1.getUuid().equals(o2.getUuid())?
 -o1.getFullName().compareTo(o2.getFullName()):
 -o1.getUuid().compareTo(o2.getUuid());
 - }
+-
+-
 @Override
 publicbooleanequals(Objecto){
 if (this == o) returntrue;
 if (o == null || getClass() != o.getClass()) returnfalse;
+-
 Resumeresume = (Resume) o;
+-
 +if (!uuid.equals(resume.uuid)) returnfalse;
 returnuuid.equals(resume.uuid);
+ }
 @Override
 publicinthashCode(){
 -returnuuid.hashCode();
 +intresult = uuid.hashCode();
 +result = 31 * result + fullName.hashCode();
 +returnresult;
+ }
 @Override
 publicintcompareTo(Resumeo){
 -returnthis.getFullName().equals(o.fullName)?this.getUuid().compareTo(o.getUuid()):this.getFullName().compareTo(o.getFullName());
 +intcmp = fullName.compareTo(o.fullName);
 +returncmp != 0 ? cmp : uuid.compareTo(o.getUuid());
+ }
+}
Original file line number	Diff line number	Diff line change
`@@ -9,11 +9,7 @@`
`9`	`9`	`importjava.util.stream.Stream;`
`10`	`10`
`11`	`11`	`publicabstractclassAbstractArrayStorageextendsAbstractStorage{`
`12`		`-protectedstaticfinalintMAX_SIZE = 10_0000;`
`13`		`-`
`14`		`-publicResume[] getStorage(){`
`15`		`-returnstorage;`
`16`		`- }`
	`12`	`+protectedstaticfinalintMAX_SIZE = 10_000;`
`17`	`13`
`18`	`14`	`protectedResume[] storage = newResume[MAX_SIZE];`
`19`	`15`	`protectedintresumeCounter = 0;`
`@@ -24,8 +20,8 @@ public void clear(){`
`24`	`20`	`}`
`25`	`21`
`26`	`22`	`@Override`
`27`		`-protectedResumedoGet(ObjectexistedSearchKey){`
`28`		`-returnstorage[(Integer) existedSearchKey];`
	`23`	`+protectedResumedoGet(Objectindex){`
	`24`	`+returnstorage[(Integer) index];`
`29`	`25`	`}`
`30`	`26`
`31`	`27`	`@Override`
`@@ -49,13 +45,13 @@ protected void doSave(Resume resume, Object index){`
`49`	`45`	`if (resumeCounter >= MAX_SIZE){`
`50`	`46`	`thrownewStorageException("Storage overflow", resume.getUuid());`
`51`	`47`	`}`
`52`		`-insertResume((Integer) index, resume);`
	`48`	`+insertResume(resume,(Integer) index);`
`53`	`49`	`resumeCounter++;`
`54`	`50`	`}`
`55`	`51`
`56`	`52`	`@Override`
`57`		`-protectedStream<Resume> getStream(){`
`58`		`-returnArrays.stream(storage,0,resumeCounter);`
	`53`	`+protectedList<Resume> doCopyAll(){`
	`54`	`+returnArrays.asList(Arrays.copyOfRange(storage,0,resumeCounter));`
`59`	`55`	`}`
`60`	`56`
`61`	`57`	`publicintsize(){`
`@@ -67,7 +63,7 @@ protected boolean isExist(Object index){`
`67`	`63`	`return (Integer) index >= 0;`
`68`	`64`	`}`
`69`	`65`
`70`		`-protectedabstractvoidinsertResume(intindex, Resumeresume);`
	`66`	`+protectedabstractvoidinsertResume(Resumeresume, intindex);`
`71`	`67`
`72`	`68`	`protectedabstractvoiddeleteResume(intindex);`
`73`	`69`	`}`
-Original file line number
+Diff line change
 importcom.urise.webapp.exception.ExistStorageException;
 importcom.urise.webapp.exception.NotExistStorageException;
 importcom.urise.webapp.model.Resume;
++
 +importjava.util.Collections;
 +importjava.util.Comparator;
 importjava.util.List;
 -importjava.util.stream.Collectors;
 -importjava.util.stream.Stream;
++
 publicabstractclassAbstractStorageimplementsStorage{
 +Comparator<Resume> RESUME_COMAPATOR= Comparator.comparing(Resume::getUuid);
 protectedabstractvoiddoUpdate(Resumeresume, ObjectsearchKey);
 protectedabstractbooleanisExist(ObjectsearchKey);
 protectedabstractvoiddoSave(Resumeresume, ObjectsearchKey);
 -protectedabstractResumedoGet(ObjectexistedSearchKey);
 +protectedabstractResumedoGet(ObjectsearchKey);
 protectedabstractvoiddoDelete(ObjectsearchKey);
 protectedabstractObjectgetSearchKey(Stringuuid);
 -protectedabstractStream<Resume> getStream();
 +protectedabstractList<Resume> doCopyAll();
 publicList<Resume> getAllSorted(){
 -returngetStream().sorted().collect(Collectors.toList());
 +List<Resume> list =doCopyAll();
 +Collections.sort(list);
 +returnlist;
+ }
++
++
 publicvoidsave(Resumeresume){
 doSave(resume, getNotExistedSearchKey(resume.getUuid()));
+ }
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ protected Integer getSearchKey(String uuid){`
`19`	`19`
`20`	`20`
`21`	`21`	`@Override`
`22`		`-protectedvoidinsertResume(intindex, Resumeresume){`
	`22`	`+protectedvoidinsertResume(Resumeresume,intindex){`
`23`	`23`	`storage[resumeCounter] = resume;`
`24`	`24`	`}`
`25`	`25`
Original file line number	Diff line number	Diff line change
`@@ -51,8 +51,8 @@ public void clear(){`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`@Override`
`54`		`-protectedStream<Resume> getStream(){`
`55`		`-returnlist.stream();`
	`54`	`+protectedList<Resume> doCopyAll(){`
	`55`	`+returnnewArrayList<>(list);`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`@Override`
-Original file line number
+Diff line change
 importcom.urise.webapp.model.Resume;
 -importjava.util.HashMap;
 -importjava.util.List;
 -importjava.util.Map;
 +importjava.lang.reflect.Array;
 +importjava.util.*;
 importjava.util.stream.Collectors;
 importjava.util.stream.Stream;
 -publicclassMapStoragePairedKeyextendsAbstractStorage{
 +publicclassMapResumeStorageextendsAbstractStorage{
 privateMap<String, Resume> mapStorage = newHashMap<>();
 @Override
 protectedvoiddoUpdate(Resumeresume, ObjectsearchKey){
++
 mapStorage.put(((Resume)searchKey).getUuid(), resume);
+ }
 @Override
 protectedbooleanisExist(ObjectsearchKey){
 -returnsearchKey==null?false:true;
 +returnsearchKey != null;
+ }
 @Override
 @Override
 protectedResumedoGet(ObjectsearchKey){
++
 return (Resume)searchKey;
+ }
 @Override
 protectedvoiddoDelete(ObjectsearchKey){
++
 mapStorage.remove(((Resume)searchKey).getUuid());
+ }
 @Override
 -protectedObjectgetSearchKey(Stringuuid){
 +protectedResumegetSearchKey(Stringuuid){
 returnmapStorage.get(uuid);
+ }
 @Override
 -publicvoidclear(){
 -mapStorage.clear();
 +protectedList<Resume> doCopyAll(){
 +returnnewArrayList(mapStorage.values());
+ }
 @Override
 -publicStream<Resume> getStream(){
 -returnmapStorage.values().stream();
 +publicvoidclear(){
 +mapStorage.clear();
+ }
 @Override
Original file line number	Diff line number	Diff line change
`@@ -4,15 +4,15 @@`
`4`	`4`	`importcom.urise.webapp.model.Resume;`
`5`	`5`	`importorg.junit.Test;`
`6`	`6`
`7`		`-`
`8`	`7`	`importstaticcom.urise.webapp.storage.AbstractArrayStorage.MAX_SIZE;`
`9`	`8`	`importstaticorg.junit.Assert.fail;`
`10`	`9`
`11`		`-publicabstractclassAbstractArrayStorageTestextendsAbstractStorageTest{`
	`10`	`+publicabstractclassAbstractArrayStorageTestextendsAbstractStorageTest{`
`12`	`11`
`13`	`12`	`publicAbstractArrayStorageTest(AbstractArrayStoragestorage){`
`14`	`13`	`super(storage);`
`15`	`14`	`}`
	`15`	`+`
`16`	`16`	`@Test(expected = StorageException.class)`
`17`	`17`	`publicvoidsizeOverLoaded(){`
`18`	`18`	`try{`
`@@ -23,6 +23,6 @@ public void sizeOverLoaded(){`
`23`	`23`	`} catch (StorageExceptione){`
`24`	`24`	`fail();`
`25`	`25`	`}`
`26`		`-storage.save(newResume("FIO_" + MAX_SIZE+1));`
	`26`	`+storage.save(newResume("FIO_" + MAX_SIZE + 1));`
`27`	`27`	`}`
`28`	`28`	`}`