diff --git a/src/incorrectResult.bin b/src/incorrectResult.bin new file mode 100644 index 0000000..35740a7 Binary files /dev/null and b/src/incorrectResult.bin differ diff --git a/src/main/java/Actor.java b/src/main/java/Actor.java index 3fe1397..811da46 100644 --- a/src/main/java/Actor.java +++ b/src/main/java/Actor.java @@ -1,17 +1,75 @@ package main.java; import java.io.Serializable; +import java.util.Objects; public class Actor implements Serializable { private String firstName; private String lastName; + private String country; - public Actor(String firstName, String lastName) { + public Actor(String firstName, String lastName, String country) { + setFirstName(firstName); + setLastName(lastName); + setCountry(country); + } + + public void setFirstName(String firstName) { + if (firstName == null || firstName == "") { + throw new IllegalArgumentException("First Name shouldn't be empty."); + } this.firstName = firstName; + } + + public String getFirstName() { + return firstName; + } + + public void setLastName(String lastName) { + if (lastName == null || lastName == "") { + throw new IllegalArgumentException("Last Name shouldn't be empty."); + } this.lastName = lastName; - } + } + + public String getLastName() { + return lastName; + } + + public void setCountry(String country) { + if (country == null) { + throw new IllegalArgumentException("Country shouldn't be null."); + } + this.country = country; + } + + public String getCountry() { + return country; + } + + @Override + public int hashCode(){ + return Objects.hash(firstName, lastName, country); + } + + @Override + public boolean equals(Object compareObject) { + if (compareObject == null) { + return false; + } + if (this == compareObject) { + return true; + }; + if (!(compareObject instanceof Actor)) { + return false; + } + Actor compareActor = (Actor) compareObject; + return (Objects.equals(firstName, compareActor.firstName) && + Objects.equals(lastName, compareActor.lastName) && + Objects.equals(country, compareActor.country)); + } - @Override + @Override public String toString() { - return firstName + " " + lastName; + return firstName + " " + lastName + " (" + country + ")"; } } diff --git a/src/main/java/Film.java b/src/main/java/Film.java index a6eaec9..9a898e8 100644 --- a/src/main/java/Film.java +++ b/src/main/java/Film.java @@ -1,19 +1,37 @@ package main.java; import java.io.Serializable; import java.util.ArrayList; +import java.util.HashSet; +import java.util.Objects; +import java.util.Set; public class Film implements Serializable { + private String filmName; + private String country; private int release; - private ArrayList mainFilmActors; + private Set mainFilmActors; - public Film(String filmName, int release, ArrayList mainFilmActors) { - this.filmName = filmName; - this.release = release; - this.mainFilmActors = mainFilmActors; + public Film(String filmName, String country, int release, Set mainFilmActors) { + setFilmName(filmName); + setCountry(country); + setRelease(release); + this.mainFilmActors = new HashSet<>(); + setMainActors(mainFilmActors); + } + + public Film(String filmName, String country, int release, Actor actor) { + setFilmName(filmName); + setCountry(country); + setRelease(release); + this.mainFilmActors = new HashSet<>(); + setMainActors(actor); } public void setFilmName(String filmName) { + if (filmName == null || filmName == "") { + throw new IllegalArgumentException("Film Name shouldn't be empty."); + } this.filmName = filmName; } @@ -21,19 +39,89 @@ public String getFilmName(){ return filmName; } - public void setMainActors(ArrayList mainFilmActors) { - this.mainFilmActors = mainFilmActors; + public void setRelease(int release) { + if (release == 0) { + throw new IllegalArgumentException("Release year shouldn't be 0."); + } + this.release = release; + } + + public int getRelease(){ + return release; } - public ArrayList getMainActors() { + public void setCountry(String country) { + if (country == null) { + throw new IllegalArgumentException("Country shouldn't be empty."); + } + this.country = country; + } + + public String getCountry(){ + return country; + } + + public void setMainActors(Actor actor) { + if (actor == null) { + throw new IllegalArgumentException("Actors List shouldn't be null."); + } + this.mainFilmActors.add(actor); + } + + public void setMainActors(Set mainFilmActors) { + if (mainFilmActors == null) { + throw new IllegalArgumentException("Actors List shouldn't be null."); + } + this.mainFilmActors.addAll(mainFilmActors); + } + + public Set getMainActors() { return mainFilmActors; } + public void addActor(Actor actor) { + if (actor == null) { + throw new IllegalArgumentException("Actor shouldn't be null."); + } + mainFilmActors.add(actor); + } + + public void deleteActor(Actor actor){ + mainFilmActors.remove(actor); + } + + @Override + public int hashCode(){ + int mainFilmActorsHashCode = 0; + for (Actor actor : mainFilmActors) { + mainFilmActorsHashCode += Objects.hashCode(actor); + } + return Objects.hash(filmName, country, release)+ mainFilmActorsHashCode; + } + + @Override + public boolean equals(Object compareObject) { + if (compareObject == null) { + return false; + } + if (this == compareObject) { + return true; + } + if (!(compareObject instanceof Film)) { + return false; + } + Film compareFilm = (Film) compareObject; + return (Objects.equals(filmName, compareFilm.filmName) && + Objects.equals(mainFilmActors, compareFilm.mainFilmActors) && + Objects.equals(release, compareFilm.release) && + Objects.equals(country, compareFilm.country)); + } + @Override public String toString() { - String filmInfo = "Film: " + filmName + " (" + release + ")\n" + "Stars: "; + String filmInfo = "Film: " + filmName + " (" + country + ", " + release + ")\n" + "Stars: "; for (Actor actor : mainFilmActors) { - filmInfo += actor.toString() + "\n"; + filmInfo = filmInfo + actor.toString() + "\n"; } return filmInfo; } diff --git a/src/main/java/FilmsCollection.java b/src/main/java/FilmsCollection.java index ada6ab4..d4cde25 100644 --- a/src/main/java/FilmsCollection.java +++ b/src/main/java/FilmsCollection.java @@ -1,67 +1,86 @@ package main.java; + import java.io.*; -import java.util.ArrayList; -import java.util.Date; -import java.util.Calendar; +import java.util.*; public class FilmsCollection implements Serializable { - private ArrayList films; + private Set films; - public FilmsCollection(){ - films = new ArrayList(); + public FilmsCollection() { + films = new HashSet(); } - public void serialisationCollection(Object object, String filePath) { - try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath))) { - oos.writeObject(object); - } catch (IOException e) { - e.printStackTrace(); - } + public FilmsCollection(Film film) { + this.films = new HashSet<>(); + setFilms(film); } + public FilmsCollection(Set films) { + this.films = new HashSet<>(); + setFilms(films); + } + public void setFilms(Film film) { + if (films == null) { + throw new IllegalArgumentException("Films list shouldn't be null."); + } + this.films.add(film); + } - public void deserialisationCollection(String fileName) { - try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileName))) { - FilmsCollection filmsCollection = (FilmsCollection)in.readObject(); - - } catch (FileNotFoundException e) { - e.printStackTrace(); - } catch (IOException e) { - e.printStackTrace(); - } catch (ClassNotFoundException e) { - e.printStackTrace(); + public void setFilms(Set films) { + if (films == null) { + throw new IllegalArgumentException("Films list shouldn't be null."); } + this.films.addAll(films); + } + + public Set getFilms() { + return films; } public void addFilmToCollection(Film newFilm) { films.add(newFilm); } - public boolean deleteFilmFromCollectionByName(String name) { - boolean flag = films.removeIf(film -> film.getFilmName().equals(name)); - if (!flag) { - System.out.println("Film " + name + "hasn't been found"); - } - return flag; + public void deleteFilmFromCollection(Film film) { + films.remove(film); } - public boolean deleteActorFromFilm(String filmName, String name) { - boolean flag = false; - for (Film film : films){ - if (film.getFilmName().equals(filmName)) { - flag = film.getMainActors().removeIf(actor -> film.getMainActors().equals(name)); - } - } - if (!flag) { - System.out.println("Actor " + name + "hasn't been found"); + public static void serialisationCollection(Object object, String filePath) { + try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath))) { + oos.writeObject(object); + } catch (IOException e) { + e.printStackTrace(); } - return flag; } - public void addActorToMainActorsList(String filmName, String name) { + public static FilmsCollection deserialisationCollection(String fileName) { + FilmsCollection filmsCollection = null; + try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileName))) { + filmsCollection = (FilmsCollection) in.readObject(); + } catch (FileNotFoundException e) { + System.out.println("Не удается найти указанный файл " + fileName); + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } catch (StreamCorruptedException e) { + System.out.println("Deserialisation error"); + } catch (IOException e) { + e.printStackTrace(); + } + return filmsCollection; + } + @Override + public String toString() { + StringBuilder filmCollectionInfo = new StringBuilder("Films collection:"); + if (films.size() != 0) { + for (Film film : films) { + filmCollectionInfo.append(film.toString()); + } + } + return filmCollectionInfo.toString(); } + } diff --git a/src/main/java/Main.java b/src/main/java/Main.java deleted file mode 100644 index b5fabc0..0000000 --- a/src/main/java/Main.java +++ /dev/null @@ -1,46 +0,0 @@ -package main.java; - -import java.util.ArrayList; -import java.util.Arrays; - -import static java.util.Arrays.*; - - -public class Main { - - public static void main(String[] args) { - - FilmsCollection filmsCollection = new FilmsCollection(); - - //Create actors - Actor actor1 = new Actor("Tom", "Hanks"); - Actor actor2 = new Actor("Catherine", "Zeta-Jones"); - Actor actor3 = new Actor("Helen", "Hunt"); - Actor actor4 = new Actor("Antonio", "Banderas"); - Actor actor5 = new Actor("Anthony", "Hopkins"); - - //Create films collection - Actor [] arrayActors = {actor1,actor2}; - ArrayList listActors = new ArrayList (Arrays.asList(arrayActors)); - Film film = new Film("The Terminal", 2004, listActors); - filmsCollection.addFilmToCollection(film); - - arrayActors[1] = actor3; - listActors = new ArrayList (Arrays.asList(arrayActors)); - film = new Film("Cast Away", 2000, listActors); - filmsCollection.addFilmToCollection(film); - - Actor [] arrayActors1 = {actor2, actor4, actor5}; - listActors = new ArrayList (Arrays.asList(arrayActors)); - film = new Film("The Mask of Zorro", 1998, listActors); - filmsCollection.addFilmToCollection(film); - - - //Serialisation - filmsCollection.serialisationCollection(filmsCollection,"result.bin"); - - filmsCollection.deserialisationCollection("result.bin"); - System.out.println(""); - - } -} diff --git a/src/test/java/ActorTest.java b/src/test/java/ActorTest.java new file mode 100644 index 0000000..40ea213 --- /dev/null +++ b/src/test/java/ActorTest.java @@ -0,0 +1,128 @@ +package test.java; + +import main.java.Actor; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import static org.junit.Assert.*; + + +public class ActorTest { + @Rule + public ExpectedException thrown = ExpectedException.none(); + + @Test + public void createActorWithNullFirstName() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("First Name shouldn't be empty."); + Actor actor = new Actor(null,"LastName1", "Country1"); + } + + @Test + public void createActorWithEmptyFirstName() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("First Name shouldn't be empty."); + Actor actor = new Actor("","LastName1", "Country1"); + } + + @Test + public void createActorWithNullLastName() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Last Name shouldn't be empty."); + Actor actor = new Actor("FirstName1",null, "Country1"); + } + + @Test + public void createActorWithEmptyLastName() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Last Name shouldn't be empty."); + Actor actor = new Actor("FirstName1","", "Country1"); + } + + @Test + public void createActorWithNullCountry() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Country shouldn't be null."); + Actor actor = new Actor("FirstName1","LastName1", null); + } + + @Test + public void createActorWithValidValues() { + Actor actor = new Actor("FirstName1","LastName1", "Country1"); + assertEquals("Incorrect FirstName: ","FirstName1",actor.getFirstName()); + assertEquals("Incorrect LastName: ","LastName1",actor.getLastName()); + assertEquals("Incorrect Country: ","Country1",actor.getCountry()); + } + + @Test + public void updateActorWithValidFirstName() { + Actor actor = new Actor("FirstName1","LastName1", "Country1"); + assertEquals("Incorrect FirstName: ","FirstName1",actor.getFirstName()); + assertEquals("Incorrect LastName: ","LastName1",actor.getLastName()); + assertEquals("Incorrect Country: ","Country1",actor.getCountry()); + actor.setFirstName(actor.getFirstName() + "-new"); + assertEquals("Incorrect FirstName: ","FirstName1-new",actor.getFirstName()); + assertEquals("Incorrect LastName: ","LastName1",actor.getLastName()); + assertEquals("Incorrect Country: ","Country1",actor.getCountry()); + } + + @Test + public void updateActorWithValidLastName() { + Actor actor = new Actor("FirstName1","LastName1", "Country1"); + assertEquals("Incorrect FirstName: ","FirstName1",actor.getFirstName()); + assertEquals("Incorrect LastName: ","LastName1",actor.getLastName()); + assertEquals("Incorrect Country: ","Country1",actor.getCountry()); + actor.setLastName(actor.getLastName() + "-new"); + assertEquals("Incorrect FirstName: ","FirstName1",actor.getFirstName()); + assertEquals("Incorrect LastName: ","LastName1-new",actor.getLastName()); + assertEquals("Incorrect Country: ","Country1",actor.getCountry()); + } + + @Test + public void updateActorWithValidCountry() { + Actor actor = new Actor("FirstName1","LastName1", "Country1"); + assertEquals("Incorrect FirstName: ","FirstName1",actor.getFirstName()); + assertEquals("Incorrect LastName: ","LastName1",actor.getLastName()); + assertEquals("Incorrect Country: ","Country1",actor.getCountry()); + actor.setCountry(actor.getCountry() + "-new"); + assertEquals("Incorrect FirstName: ","FirstName1",actor.getFirstName()); + assertEquals("Incorrect LastName: ","LastName1",actor.getLastName()); + assertEquals("Incorrect Country: ","Country1-new",actor.getCountry()); + } + + @Test + public void checkToStringMethod() { + Actor actor = new Actor("FirstName1", "LastName1", "Country1"); + String result = "FirstName1 LastName1 (Country1)"; + assertEquals("Incorrect Actor: ", result, actor.toString()); + } + + @Test + public void checkEqualsMethodForTrueCase() { + Actor actor = new Actor("FirstName1", "LastName1", "Country1"); + Actor actor1 = new Actor("FirstName1", "LastName1", "Country1"); + assertTrue(actor.equals(actor1)); + } + + @Test + public void checkEqualsMethodForDifferentFirstName() { + Actor actor = new Actor("FirstName1", "LastName1", "Country1"); + Actor actor1 = new Actor("FirstName2", "LastName1", "Country1"); + assertFalse(actor.equals(actor1)); + } + + @Test + public void checkEqualsMethodForDifferentLastName() { + Actor actor = new Actor("FirstName1", "LastName1", "Country1"); + Actor actor1 = new Actor("FirstName1", "LastName2", "Country1"); + assertFalse(actor.equals(actor1)); + } + + @Test + public void checkEqualsMethodForDifferentCountry() { + Actor actor = new Actor("FirstName1", "LastName1", "Country1"); + Actor actor1 = new Actor("FirstName1", "LastName1", "Country2"); + assertFalse(actor.equals(actor1)); + } + +} diff --git a/src/test/java/FilmTest.java b/src/test/java/FilmTest.java new file mode 100644 index 0000000..cc81fff --- /dev/null +++ b/src/test/java/FilmTest.java @@ -0,0 +1,103 @@ +package test.java; + +import main.java.Actor; +import main.java.Film; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; + +import java.util.HashSet; +import java.util.Set; + +import static org.junit.Assert.*; + +public class FilmTest { + @Rule + public ExpectedException thrown = ExpectedException.none(); + + @Test + public void createFilmWithOneActor() { + Actor actor = new Actor("FirstName1","LastName1", "Country1"); + Film film = new Film("Film1" ,"Country1", 2000, actor); + String result = "Film: Film1 (Country1, 2000)\n" + + "Stars: FirstName1 LastName1 (Country1)\n"; + assertEquals("Incorrect Film: ", result, film.toString()); + } + + @Test + public void createFilmWithThreeActors() { + Set actors = new HashSet<>(); + for (int i=0; i<=3; i++) { + actors.add(new Actor("FirstName"+i,"LastName"+i, "Country"+i)); + } + Film film = new Film("Film1" ,"Country1", 2000, actors); + assertEquals("Incorrect Film: ", 4, film.getMainActors().size()); + } + + @Test + public void createFilmWithNullFilmName() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Film Name shouldn't be empty."); + Film film = new Film(null ,"Country1", 2000, new Actor("FirstName","LastName", "Country")); + } + + @Test + public void createFilmWithNullCountry() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Country shouldn't be empty."); + Film film = new Film("FilmName" ,null, 2000, new Actor("FirstName","LastName", "Country")); + } + + @Test + public void createFilmWithNullRelease() { + thrown.expect(IllegalArgumentException.class); + thrown.expectMessage("Release year shouldn't be 0."); + Film film = new Film("FilmName" ,"Country", 0, new Actor("FirstName","LastName", "Country")); + } + + @Test + public void addActorNotFromFilmList() { + Film newFilm = createFilmForTest("Film1", "Country1", 2000, 5); + newFilm.addActor(new Actor("FirstName6","LastName6", "Country6")); + Set actors = newFilm.getMainActors(); + assertEquals(6, actors.size()); + } + + @Test + public void addActorAlreadyAddedToFilmList() { + Film newFilm = createFilmForTest("Film1", "Country1", 2000, 7); + int initialActorsNumber = newFilm.getMainActors().size(); + newFilm.addActor(new Actor("FirstName6","LastName6", "Country6")); + Set actors = newFilm.getMainActors(); + assertEquals(initialActorsNumber, actors.size()); + } + + @Test + public void deleteExistingActor() { + Film newFilm = createFilmForTest("Film1", "Country1", 2000, 10); + int initialActorsNumber = newFilm.getMainActors().size(); + newFilm.deleteActor(new Actor("FirstName6","LastName6", "Country6")); + Set actors = newFilm.getMainActors(); + assertEquals(initialActorsNumber-1, actors.size()); + } + + @Test + public void deleteNonExistingActor() { + Film newFilm = createFilmForTest("Film1", "Country1", 2000, 10); + int initialActorsNumber = newFilm.getMainActors().size(); + newFilm.deleteActor(new Actor("FirstName11","LastName11", "Country11")); + Set actors = newFilm.getMainActors(); + assertEquals(initialActorsNumber, actors.size()); + } + + //Create film for tests with specify number of Actors + public static Film createFilmForTest(String filmName, String country, int release, int numberActors){ + Set actors = new HashSet<>(); + for (int i=0; i films = new HashSet<>(); + for (int i = 0; i < 10; i++) { + Film newFilm = FilmTest.createFilmForTest("FilmName" + i, "Country" + i, 2000, 10); + films.add(newFilm); + } + FilmsCollection filmsCollection = new FilmsCollection(films); + assertEquals(10, filmsCollection.getFilms().size()); + } + + @Test + public void newFilmIsAddedToCollection() { + Set films = new HashSet<>(); + for (int i = 0; i < 10; i++) { + Film newFilm = FilmTest.createFilmForTest("FilmName" + i, "Country" + i, 2000, 10); + films.add(newFilm); + } + FilmsCollection filmsCollection = new FilmsCollection(films); + int initialFilmsNumber = filmsCollection.getFilms().size(); + Film newFilm = FilmTest.createFilmForTest("FilmName11", "Country11", 2011, 10); + filmsCollection.addFilmToCollection(newFilm); + assertEquals(initialFilmsNumber + 1, filmsCollection.getFilms().size()); + } + + @Test + public void existingFilmIsNotAddedToCollection() { + Set films = new HashSet<>(); + for (int i = 0; i <= 10; i++) { + Film newFilm = FilmTest.createFilmForTest("FilmName" + i, "Country" + i, 2000, 10); + films.add(newFilm); + } + FilmsCollection filmsCollection = new FilmsCollection(films); + int initialFilmsNumber = filmsCollection.getFilms().size(); + Film existingFilm = FilmTest.createFilmForTest("FilmName10", "Country10", 2000, 10); + filmsCollection.addFilmToCollection(existingFilm); + assertEquals(initialFilmsNumber, filmsCollection.getFilms().size()); + } + + @Test + public void existingFilmIsDeleteFromCollection() { + Set films = new HashSet<>(); + for (int i = 0; i <= 10; i++) { + Film newFilm = FilmTest.createFilmForTest("FilmName" + i, "Country" + i, 2000, 10); + films.add(newFilm); + } + FilmsCollection filmsCollection = new FilmsCollection(films); + int initialFilmsNumber = filmsCollection.getFilms().size(); + Film existingFilm = FilmTest.createFilmForTest("FilmName10", "Country10", 2000, 10); + filmsCollection.deleteFilmFromCollection(existingFilm); + assertEquals(initialFilmsNumber - 1, filmsCollection.getFilms().size()); + } + + @Test + public void nonExistingFilmIsDeleteFromCollection() { + Set films = new HashSet<>(); + for (int i = 0; i <= 10; i++) { + Film newFilm = FilmTest.createFilmForTest("FilmName" + i, "Country" + i, 2000, 10); + films.add(newFilm); + } + FilmsCollection filmsCollection = new FilmsCollection(films); + int initialFilmsNumber = filmsCollection.getFilms().size(); + Film existingFilm = FilmTest.createFilmForTest("FilmName10", "Country10", 2010, 10); + filmsCollection.deleteFilmFromCollection(existingFilm); + assertEquals(initialFilmsNumber, filmsCollection.getFilms().size()); + } + + @Test + public void checkSerialisationFilmCollection() { + Set films = new HashSet<>(); + for (int i = 0; i < 10; i++) { + Film newFilm = FilmTest.createFilmForTest("FilmName" + i, "Country" + i, 2000, 10); + films.add(newFilm); + } + FilmsCollection initialFilmsCollection = new FilmsCollection(films); + initialFilmsCollection.serialisationCollection(initialFilmsCollection,"result.bin"); + FilmsCollection deserialisationFilmsCollection = FilmsCollection.deserialisationCollection("result.bin"); + assertEquals(10, deserialisationFilmsCollection.getFilms().size()); + } + + @Test + public void checkDeserialisationNonExistingFileWithFilmCollection() { + assertNull(FilmsCollection.deserialisationCollection("result11.bin")); + } + + @Test + public void checkDeserialisationIncorrectFileWithFilmCollection(){ + assertNull(FilmsCollection.deserialisationCollection("src/incorrectResult.bin")); + } +} diff --git a/src/test/java/SerialisationTest.java b/src/test/java/SerialisationTest.java deleted file mode 100644 index 7cd816f..0000000 --- a/src/test/java/SerialisationTest.java +++ /dev/null @@ -1,4 +0,0 @@ -package test.java; - -public class SerialisationTest { -}