From c6e436431d427e1187f28ac1dd468e1c75e2c31a Mon Sep 17 00:00:00 2001 From: Kailash201 <109354852+Kailash201@users.noreply.github.com> Date: Fri, 10 Nov 2023 16:02:58 +0800 Subject: [PATCH 1/2] add testcase for addtimecommand --- .../logic/parser/AddCommandParser.java | 1 - .../seedu/address/logic/parser/CliSyntax.java | 4 +- .../address/logic/parser/ParserUtil.java | 27 -- .../seedu/address/model/ModelManager.java | 11 +- .../seedu/address/model/TimeInterval.java | 13 +- .../seedu/address/model/person/Person.java | 5 +- .../logic/commands/AddTimeCommandTest.java | 409 ++++++++++++++++++ .../address/logic/parser/ParserUtilTest.java | 44 -- .../seedu/address/testutil/PersonBuilder.java | 10 +- .../address/testutil/TimeIntervalBuilder.java | 5 + .../testutil/TypicalTimeIntervals.java | 54 +++ 11 files changed, 488 insertions(+), 95 deletions(-) create mode 100644 src/test/java/seedu/address/logic/commands/AddTimeCommandTest.java create mode 100644 src/test/java/seedu/address/testutil/TypicalTimeIntervals.java diff --git a/src/main/java/seedu/address/logic/parser/AddCommandParser.java b/src/main/java/seedu/address/logic/parser/AddCommandParser.java index be23cd6a227..b87a92d0f07 100644 --- a/src/main/java/seedu/address/logic/parser/AddCommandParser.java +++ b/src/main/java/seedu/address/logic/parser/AddCommandParser.java @@ -43,7 +43,6 @@ public AddCommand parse(String args) throws ParseException { Phone phone = ParserUtil.parsePhone(argMultimap.getValue(PREFIX_PHONE).get()); Email email = ParserUtil.parseEmail(argMultimap.getValue(PREFIX_EMAIL).get()); - // edit here of add more than 1 group if (arePrefixesPresent(argMultimap, PREFIX_GROUPTAG)) { Group group = ParserUtil.parseGroup(argMultimap.getValue(PREFIX_GROUPTAG).get()); groupList.add(group); diff --git a/src/main/java/seedu/address/logic/parser/CliSyntax.java b/src/main/java/seedu/address/logic/parser/CliSyntax.java index 8f237ebee16..636e9367e12 100644 --- a/src/main/java/seedu/address/logic/parser/CliSyntax.java +++ b/src/main/java/seedu/address/logic/parser/CliSyntax.java @@ -11,10 +11,8 @@ public class CliSyntax { public static final Prefix PREFIX_EMAIL = new Prefix("e/"); public static final Prefix PREFIX_GROUPTAG = new Prefix("g/"); public static final Prefix PREFIX_ADDRESS = new Prefix("a/"); - public static final Prefix PREFIX_TAG = new Prefix("t/"); + public static final Prefix PREFIX_FREETIME = new Prefix("t/"); - public static final Prefix PREFIX_ENDINTERVAL = new Prefix(";"); - public static final Prefix PREFIX_TOFRO = new Prefix("-"); public static final Prefix PREFIX_GROUPREMARK = new Prefix("r/"); public static final Prefix PREFIX_DURATION = new Prefix("d/"); diff --git a/src/main/java/seedu/address/logic/parser/ParserUtil.java b/src/main/java/seedu/address/logic/parser/ParserUtil.java index 2e905fe010c..ea3cf5b0b82 100644 --- a/src/main/java/seedu/address/logic/parser/ParserUtil.java +++ b/src/main/java/seedu/address/logic/parser/ParserUtil.java @@ -131,33 +131,6 @@ public static Group parseGroup(String groupName) throws ParseException { return group; } - /** - * Parses a {@code String tag} into a {@code Tag}. - * Leading and trailing whitespaces will be trimmed. - * - * @throws ParseException if the given {@code tag} is invalid. - */ - public static Tag parseTag(String tag) throws ParseException { - requireNonNull(tag); - String trimmedTag = tag.trim(); - if (!Tag.isValidTagName(trimmedTag)) { - throw new ParseException(Tag.MESSAGE_CONSTRAINTS); - } - return new Tag(trimmedTag); - } - - /** - * Parses {@code Collection tags} into a {@code Set}. - */ - public static Set parseTags(Collection tags) throws ParseException { - requireNonNull(tags); - final Set tagSet = new HashSet<>(); - for (String tagName : tags) { - tagSet.add(parseTag(tagName)); - } - return tagSet; - } - /** * Parses a {@code String groupName} into a {@code Group}. * Leading and trailing whitespaces will be trimmed. diff --git a/src/main/java/seedu/address/model/ModelManager.java b/src/main/java/seedu/address/model/ModelManager.java index 93953b9850c..5e228ab7d50 100644 --- a/src/main/java/seedu/address/model/ModelManager.java +++ b/src/main/java/seedu/address/model/ModelManager.java @@ -218,13 +218,10 @@ public Pair ungroupPerson(String personName, String groupName) th public String addTimeToPerson(Name toAddPerson, ArrayList toAddTime) throws CommandException { requireNonNull(toAddPerson); Person person = addressBook.getPerson(toAddPerson.fullName); - try { - String msg = person.addFreeTime(toAddTime); - forceUpdateList(); - return msg; - } catch (CommandException e) { - throw new CommandException(e.getMessage()); - } + String msg = person.addFreeTime(toAddTime); + forceUpdateList(); + return msg; + } /** diff --git a/src/main/java/seedu/address/model/TimeInterval.java b/src/main/java/seedu/address/model/TimeInterval.java index 1f87aed7204..dc2a56ab837 100644 --- a/src/main/java/seedu/address/model/TimeInterval.java +++ b/src/main/java/seedu/address/model/TimeInterval.java @@ -42,15 +42,10 @@ public TimeInterval(Time start, Time end) { * @return Returns true if the timeInterval overlaps with one another. */ public static boolean isTimeIntervalOverlap(ArrayList intervals) { - for (int i = 0; i < intervals.size(); i++) { - for (int j = i + 1; j < intervals.size(); j++) { - int startComparison = intervals.get(i).compareStart(intervals.get(j)); - int endComparison = intervals.get(i).compareEnd(intervals.get(j)); - boolean noClash = ((startComparison < 0 && endComparison < 0) - || (startComparison > 0 && endComparison > 0)); - if ((startComparison == 0 && endComparison == 0) || !noClash) { - return true; - } + intervals.sort(TimeInterval::compareStart); + for (int i = 0; i < intervals.size() - 1; i++) { + if (intervals.get(i).isClash(intervals.get(i + 1))) { + return true; } } return false; diff --git a/src/main/java/seedu/address/model/person/Person.java b/src/main/java/seedu/address/model/person/Person.java index df43d9bc889..f3c95e7db15 100644 --- a/src/main/java/seedu/address/model/person/Person.java +++ b/src/main/java/seedu/address/model/person/Person.java @@ -178,7 +178,8 @@ public boolean equals(Object other) { return name.equals(otherPerson.name) && phone.equals(otherPerson.phone) && email.equals(otherPerson.email) - && personGroups.equals(otherPerson.personGroups); + && personGroups.equals(otherPerson.personGroups) + && timeIntervalList.equals(otherPerson.timeIntervalList); } @Override @@ -205,7 +206,7 @@ public void addFreeTime(TimeInterval toAddFreeTime) { this.timeIntervalList.addTime(toAddFreeTime); } - public String addFreeTime(ArrayList toAddFreeTime) throws CommandException { + public String addFreeTime(ArrayList toAddFreeTime) { return this.timeIntervalList.addTime(toAddFreeTime); } diff --git a/src/test/java/seedu/address/logic/commands/AddTimeCommandTest.java b/src/test/java/seedu/address/logic/commands/AddTimeCommandTest.java new file mode 100644 index 00000000000..bd488642d8a --- /dev/null +++ b/src/test/java/seedu/address/logic/commands/AddTimeCommandTest.java @@ -0,0 +1,409 @@ +package seedu.address.logic.commands; + +import static java.util.Objects.requireNonNull; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.fail; +import static seedu.address.testutil.Assert.assertThrows; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.function.Predicate; +import org.junit.jupiter.api.Test; +import javafx.collections.ObservableList; +import javafx.util.Pair; +import seedu.address.commons.core.GuiSettings; +import seedu.address.logic.Messages; +import seedu.address.logic.commands.exceptions.CommandException; +import seedu.address.model.Model; +import seedu.address.model.ReadOnlyAddressBook; +import seedu.address.model.ReadOnlyUserPrefs; +import seedu.address.model.TimeInterval; +import seedu.address.model.TimeIntervalList; +import seedu.address.model.group.Group; +import seedu.address.model.group.GroupRemark; +import seedu.address.model.person.Name; +import seedu.address.model.person.Person; +import seedu.address.testutil.PersonBuilder; +import seedu.address.testutil.TimeIntervalBuilder; +import seedu.address.testutil.TypicalTimeIntervals; + +public class AddTimeCommandTest { + + @Test + public void constructor_nullArguments_throwsNullPointerException() { + assertThrows(NullPointerException.class, () -> new AddTimeCommand(null, null)); + } + + @Test + public void execute_personDoesNotExit_throwException() { + Person validPerson = new PersonBuilder().build(); + ModelStubWithPerson modelStub = new ModelStubWithPerson(validPerson.getName()); + Person toAdd = new PersonBuilder().withName("doesnotexistperson").build(); + TimeInterval timeInterval = new TimeIntervalBuilder().build(); + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(timeInterval); + + try { + CommandResult commandResult = new AddTimeCommand(toAdd.getName(), timeIntervalArrayList).execute(modelStub); + assertThrows(CommandException.class, () -> new AddTimeCommand(toAdd.getName(), + timeIntervalArrayList).execute(modelStub)); + } catch (CommandException e) { + assertEquals(e.getMessage(), "Person does not exists"); + } + } + + @Test + public void execute_AddSingleTimeToPerson_addSuccessful() { + Person validPerson = new PersonBuilder().build(); + ModelStubWithPerson modelStub = new ModelStubWithPerson(validPerson); + TimeInterval timeInterval = new TimeIntervalBuilder().build(); + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(timeInterval); + String status = "These times have been added:\n" + timeInterval.toString() + "\n"; + + try { + CommandResult commandResult = new AddTimeCommand(validPerson.getName(), + timeIntervalArrayList).execute(modelStub); + assertEquals(String.format(AddTimeCommand.MESSAGE_SUCCESS + status, Messages.format(validPerson.getName())), + commandResult.getFeedbackToUser()); + assertEquals(timeInterval, modelStub.personList.get(0).getTime().iterator().next()); + } catch (CommandException e) { + fail(); + } + + } + + @Test + public void execute_AddMultipleTimeWithNoOverlapToPerson_addSuccessful_addMsg() { + Person validPerson = new PersonBuilder().build(); + ModelStubWithPerson modelStub = new ModelStubWithPerson(validPerson); + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalOneNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalTwoNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalThreeNoOverlap); + + String status = "These times have been added:\n" + TypicalTimeIntervals.timeIntervalOneNoOverlap.toString() + + "\n" + TypicalTimeIntervals.timeIntervalTwoNoOverlap.toString() + + "\n" + TypicalTimeIntervals.timeIntervalThreeNoOverlap.toString() + + "\n"; + + try { + CommandResult commandResult = new AddTimeCommand(validPerson.getName(), + timeIntervalArrayList).execute(modelStub); + assertEquals(String.format(AddTimeCommand.MESSAGE_SUCCESS + status, Messages.format(validPerson.getName())), + commandResult.getFeedbackToUser()); + + assertEquals("\n" + TypicalTimeIntervals.timeIntervalOneNoOverlap.toString() + + "\n" + TypicalTimeIntervals.timeIntervalTwoNoOverlap.toString() + + "\n" + TypicalTimeIntervals.timeIntervalThreeNoOverlap.toString(), + modelStub.personList.get(0).getTime().toString()); + } catch (CommandException e) { + fail(); + } + } + + @Test + public void execute_AddMultipleTimeToPersonWithOneExistingOverlappingTime_addUnSuccessful_clashMsg() { + Person validPerson = new PersonBuilder().withTimeInterval(TypicalTimeIntervals.timeIntervalTwoOverlapA).build(); + ModelStubWithPerson modelStub = new ModelStubWithPerson(validPerson); + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalOneOverlapA); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalThreeOverlapA); + + String status = "There is a clash in these input timings with your existing timings:\n" + + TypicalTimeIntervals.timeIntervalOneOverlapA.toString() + + "\n" + TypicalTimeIntervals.timeIntervalThreeOverlapA.toString() + + "\n"; + + try { + CommandResult commandResult = new AddTimeCommand(validPerson.getName(), + timeIntervalArrayList).execute(modelStub); + assertEquals(String.format(AddTimeCommand.MESSAGE_SUCCESS + status, Messages.format(validPerson.getName())), + commandResult.getFeedbackToUser()); + + assertEquals("\n" + TypicalTimeIntervals.timeIntervalTwoOverlapA.toString(), + modelStub.personList.get(0).getTime().toString()); + } catch (CommandException e) { + fail(); + } + } + + @Test + public void execute_AddMultipleTimeToPersonWithOneExistingOverlappingTime_addHalfSuccessful_clashAndAddMsg() { + Person validPerson = new PersonBuilder().withTimeInterval(TypicalTimeIntervals.timeIntervalTwoOverlapA).build(); + ModelStubWithPerson modelStub = new ModelStubWithPerson(validPerson); + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalOneOverlapA); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalThreeNoOverlap); + + String status = "There is a clash in these input timings with your existing timings:\n" + + TypicalTimeIntervals.timeIntervalOneOverlapA.toString() + + "\n" + "These times have been added:" + + "\n" + TypicalTimeIntervals.timeIntervalThreeNoOverlap.toString() + + "\n"; + + try { + CommandResult commandResult = new AddTimeCommand(validPerson.getName(), + timeIntervalArrayList).execute(modelStub); + assertEquals(String.format(AddTimeCommand.MESSAGE_SUCCESS + status, Messages.format(validPerson.getName())), + commandResult.getFeedbackToUser()); + + assertEquals("\n" + TypicalTimeIntervals.timeIntervalTwoOverlapA.toString() + + "\n" + TypicalTimeIntervals.timeIntervalThreeNoOverlap.toString(), + modelStub.personList.get(0).getTime().toString()); + } catch (CommandException e) { + fail(); + } + } + + @Test + public void execute_AddMultipleTimeToPersonWithTwoExistingOverlappingTime_addUnSuccessful_clashMsg() { + Person validPerson = new PersonBuilder().withTimeInterval(TypicalTimeIntervals.timeIntervalOneOverlapA) + .withTimeInterval(TypicalTimeIntervals.timeIntervalFourOverlapA).build(); + ModelStubWithPerson modelStub = new ModelStubWithPerson(validPerson); + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalTwoOverlapA); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalFiveOverlapA); + + String status = "There is a clash in these input timings with your existing timings:\n" + + TypicalTimeIntervals.timeIntervalTwoOverlapA.toString() + + "\n" + TypicalTimeIntervals.timeIntervalFiveOverlapA.toString() + + "\n"; + + try { + CommandResult commandResult = new AddTimeCommand(validPerson.getName(), + timeIntervalArrayList).execute(modelStub); + assertEquals(String.format(AddTimeCommand.MESSAGE_SUCCESS + status, Messages.format(validPerson.getName())), + commandResult.getFeedbackToUser()); + + assertEquals("\n" + TypicalTimeIntervals.timeIntervalOneOverlapA.toString() + + "\n" + TypicalTimeIntervals.timeIntervalFourOverlapA.toString(), + modelStub.personList.get(0).getTime().toString()); + } catch (CommandException e) { + fail(); + } + } + + @Test + public void execute_AddMultipleTimeToPersonWithTwoExistingOverlappingTime_addHalfSuccessful_clashAndAddMsg() { + Person validPerson = new PersonBuilder().withTimeInterval(TypicalTimeIntervals.timeIntervalOneOverlapA) + .withTimeInterval(TypicalTimeIntervals.timeIntervalFourOverlapA).build(); + ModelStubWithPerson modelStub = new ModelStubWithPerson(validPerson); + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalTwoOverlapA); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalThreeNoOverlap); + + String status = "There is a clash in these input timings with your existing timings:\n" + + TypicalTimeIntervals.timeIntervalTwoOverlapA.toString() + + "\n" + "These times have been added:" + + "\n" + TypicalTimeIntervals.timeIntervalThreeNoOverlap.toString() + + "\n"; + + try { + CommandResult commandResult = new AddTimeCommand(validPerson.getName(), + timeIntervalArrayList).execute(modelStub); + assertEquals(String.format(AddTimeCommand.MESSAGE_SUCCESS + status, Messages.format(validPerson.getName())), + commandResult.getFeedbackToUser()); + + assertEquals("\n" + TypicalTimeIntervals.timeIntervalOneOverlapA.toString() + + "\n" + TypicalTimeIntervals.timeIntervalFourOverlapA.toString() + + "\n" + TypicalTimeIntervals.timeIntervalThreeNoOverlap.toString(), + modelStub.personList.get(0).getTime().toString()); + } catch (CommandException e) { + fail(); + } + } + + + private class ModelStub implements Model { + + @Override + public void setUserPrefs(ReadOnlyUserPrefs userPrefs) { + throw new AssertionError("This method should not be called"); + } + + @Override + public ReadOnlyUserPrefs getUserPrefs() { + throw new AssertionError("This method should not be called"); + } + + @Override + public GuiSettings getGuiSettings() { + throw new AssertionError("This method should not be called"); + } + + @Override + public void setGuiSettings(GuiSettings guiSettings) { + throw new AssertionError("This method should not be called"); + } + + @Override + public Path getAddressBookFilePath() { + throw new AssertionError("This method should not be called"); + } + + @Override + public void setAddressBookFilePath(Path addressBookFilePath) { + throw new AssertionError("This method should not be called"); + } + + @Override + public void setAddressBook(ReadOnlyAddressBook addressBook) { + throw new AssertionError("This method should not be called"); + } + + @Override + public ReadOnlyAddressBook getAddressBook() { + throw new AssertionError("This method should not be called"); + } + + @Override + public void addPerson(Person person) { + throw new AssertionError("This method should not be called"); + } + + @Override + public Person deletePerson(String personName) throws CommandException { + throw new AssertionError("This method should not be called"); + } + + @Override + public boolean hasPerson(Person person) { + throw new AssertionError("This method should not be called"); + } + + @Override + public boolean hasPerson(Name personName) { + throw new AssertionError("This method should not be called"); + } + + @Override + public Pair groupPerson(String personName, String groupName) throws CommandException { + throw new AssertionError("This method should not be called"); + } + + @Override + public Pair ungroupPerson(String personName, String groupName) throws CommandException { + throw new AssertionError("This method should not be called"); + } + + @Override + public String addTimeToPerson(Name toAddPerson, ArrayList toAddTime) throws CommandException { + throw new AssertionError("This method should not be called"); + } + + @Override + public TimeIntervalList getTimeFromPerson(Name personName) throws CommandException { + throw new AssertionError("This method should not be called"); + } + + @Override + public String deleteTimeFromPerson(Name personName, ArrayList toDeleteTime) { + throw new AssertionError("This method should not be called"); + } + + @Override + public void addGroup(Group g) { + throw new AssertionError("This method should not be called"); + } + + @Override + public Group deleteGroup(String groupName) throws CommandException { + throw new AssertionError("This method should not be called"); + } + + @Override + public boolean hasGroup(Group group) { + throw new AssertionError("This method should not be called"); + } + + @Override + public Group findGroup(String groupName) throws CommandException { + throw new AssertionError("This method should not be called"); + } + + @Override + public Group addGroupRemark(String groupName, GroupRemark groupRemark) throws CommandException { + throw new AssertionError("This method should not be called"); + } + + @Override + public String addTimeToGroup(Group toAdd, ArrayList toAddTime) throws CommandException { + throw new AssertionError("This method should not be called"); + } + + @Override + public String deleteTimeFromGroup(Group group, ArrayList toDeleteTime) throws CommandException { + throw new AssertionError("This method should not be called"); + } + + @Override + public TimeIntervalList getTimeFromGroup(Group group) throws CommandException { + throw new AssertionError("This method should not be called"); + } + + @Override + public ObservableList getFilteredPersonList() { + throw new AssertionError("This method should not be called"); + } + + @Override + public ObservableList getFilteredGroupList() { + throw new AssertionError("This method should not be called"); + } + + @Override + public void updateFilteredPersonList(Predicate predicate) { + throw new AssertionError("This method should not be called"); + } + + @Override + public void updateFilteredGroupList(Predicate predicate) { + throw new AssertionError("This method should not be called"); + } + + @Override + public boolean hasEmail(Person toAdd) { + throw new AssertionError("This method should not be called"); + } + + @Override + public boolean hasPhone(Person toAdd) { + throw new AssertionError("This method should not be called"); + } + } + + + private class ModelStubWithPerson extends ModelStub { + private final Name personName; + + private final ArrayList personList = new ArrayList<>(); + + ModelStubWithPerson(Name personName) { + requireNonNull(personName); + this.personName = personName; + } + + ModelStubWithPerson(Person person) { + requireNonNull(person); + personList.add(person); + personName = person.getName(); + } + + @Override + public boolean hasPerson(Name personName) { + requireNonNull(personName); + return this.personName.equals(personName); + } + + @Override + public String addTimeToPerson(Name personName, ArrayList toAddTime) { + Person p = personList.get(0); + String status = p.addFreeTime(toAddTime); + return status; + } + + } + + + +} diff --git a/src/test/java/seedu/address/logic/parser/ParserUtilTest.java b/src/test/java/seedu/address/logic/parser/ParserUtilTest.java index 4256788b1a7..23071ce8e2f 100644 --- a/src/test/java/seedu/address/logic/parser/ParserUtilTest.java +++ b/src/test/java/seedu/address/logic/parser/ParserUtilTest.java @@ -148,49 +148,5 @@ public void parseEmail_validValueWithWhitespace_returnsTrimmedEmail() throws Exc assertEquals(expectedEmail, ParserUtil.parseEmail(emailWithWhitespace)); } - @Test - public void parseTag_null_throwsNullPointerException() { - assertThrows(NullPointerException.class, () -> ParserUtil.parseTag(null)); - } - - @Test - public void parseTag_invalidValue_throwsParseException() { - assertThrows(ParseException.class, () -> ParserUtil.parseTag(INVALID_TAG)); - } - - @Test - public void parseTag_validValueWithoutWhitespace_returnsTag() throws Exception { - Tag expectedTag = new Tag(VALID_TAG_1); - assertEquals(expectedTag, ParserUtil.parseTag(VALID_TAG_1)); - } - - @Test - public void parseTag_validValueWithWhitespace_returnsTrimmedTag() throws Exception { - String tagWithWhitespace = WHITESPACE + VALID_TAG_1 + WHITESPACE; - Tag expectedTag = new Tag(VALID_TAG_1); - assertEquals(expectedTag, ParserUtil.parseTag(tagWithWhitespace)); - } - @Test - public void parseTags_null_throwsNullPointerException() { - assertThrows(NullPointerException.class, () -> ParserUtil.parseTags(null)); - } - - @Test - public void parseTags_collectionWithInvalidTags_throwsParseException() { - assertThrows(ParseException.class, () -> ParserUtil.parseTags(Arrays.asList(VALID_TAG_1, INVALID_TAG))); - } - - @Test - public void parseTags_emptyCollection_returnsEmptySet() throws Exception { - assertTrue(ParserUtil.parseTags(Collections.emptyList()).isEmpty()); - } - - @Test - public void parseTags_collectionWithValidTags_returnsTagSet() throws Exception { - Set actualTagSet = ParserUtil.parseTags(Arrays.asList(VALID_TAG_1, VALID_TAG_2)); - Set expectedTagSet = new HashSet(Arrays.asList(new Tag(VALID_TAG_1), new Tag(VALID_TAG_2))); - - assertEquals(expectedTagSet, actualTagSet); - } } diff --git a/src/test/java/seedu/address/testutil/PersonBuilder.java b/src/test/java/seedu/address/testutil/PersonBuilder.java index 8964cd2dc1c..8967b200d52 100644 --- a/src/test/java/seedu/address/testutil/PersonBuilder.java +++ b/src/test/java/seedu/address/testutil/PersonBuilder.java @@ -4,6 +4,7 @@ import seedu.address.logic.parser.ParserUtil; import seedu.address.logic.parser.exceptions.ParseException; +import seedu.address.model.TimeInterval; import seedu.address.model.TimeIntervalList; import seedu.address.model.group.Group; import seedu.address.model.group.GroupList; @@ -66,11 +67,16 @@ public PersonBuilder withPhone(String phone) { return this; } - public PersonBuilder withTimeInterval(String timeIntervalList) throws ParseException { + public PersonBuilder withTimeIntervalList(String timeIntervalList) throws ParseException { this.timeIntervalList.addTime(ParserUtil.parseEachInterval(timeIntervalList)); return this; } + public PersonBuilder withTimeInterval(TimeInterval timeInterval) { + this.timeIntervalList.addTime(timeInterval); + return this; + } + /** * Sets the {@code GroupList} of the {@code args} that we are building. */ @@ -90,7 +96,7 @@ public PersonBuilder withEmail(String email) { } public Person build() { - return new Person(name, phone, email, grpList); + return new Person(name, phone, email, grpList, timeIntervalList); } } diff --git a/src/test/java/seedu/address/testutil/TimeIntervalBuilder.java b/src/test/java/seedu/address/testutil/TimeIntervalBuilder.java index b9d15dcabbc..74e8aebc87e 100644 --- a/src/test/java/seedu/address/testutil/TimeIntervalBuilder.java +++ b/src/test/java/seedu/address/testutil/TimeIntervalBuilder.java @@ -1,6 +1,7 @@ package seedu.address.testutil; import seedu.address.model.Time; +import seedu.address.model.TimeInterval; import java.time.DayOfWeek; import java.time.LocalTime; @@ -24,4 +25,8 @@ public TimeIntervalBuilder withStartTimeAndEndTime(Time start, Time end) { return this; } + public TimeInterval build() { + return new TimeInterval(start, end); + } + } diff --git a/src/test/java/seedu/address/testutil/TypicalTimeIntervals.java b/src/test/java/seedu/address/testutil/TypicalTimeIntervals.java new file mode 100644 index 00000000000..7393e870797 --- /dev/null +++ b/src/test/java/seedu/address/testutil/TypicalTimeIntervals.java @@ -0,0 +1,54 @@ +package seedu.address.testutil; + +import java.time.DayOfWeek; +import java.time.LocalTime; +import seedu.address.model.TimeInterval; + +public class TypicalTimeIntervals { + + public static TimeInterval timeIntervalOneNoOverlap = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(10, 00)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(11, 00)).build()).build(); + + public static TimeInterval timeIntervalTwoNoOverlap = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(12, 00)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(13, 00)).build()).build(); + + public static TimeInterval timeIntervalThreeNoOverlap = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(14, 00)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(15, 00)).build()).build(); + + + public static TimeInterval timeIntervalOneOverlapA = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(10, 00)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(11, 00)).build()).build(); + + public static TimeInterval timeIntervalTwoOverlapA = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(10, 30)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(11, 30)).build()).build(); + + public static TimeInterval timeIntervalThreeOverlapA = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(11, 00)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(12, 00)).build()).build(); + + public static TimeInterval timeIntervalFourOverlapA = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(11, 35)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(12, 30)).build()).build(); + + public static TimeInterval timeIntervalFiveOverlapA = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(12, 00)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(13, 00)).build()).build(); + + + + + +} From 1454c07f715755ad5c7ef9a7998d5dc648acfeff Mon Sep 17 00:00:00 2001 From: Kailash201 <109354852+Kailash201@users.noreply.github.com> Date: Fri, 10 Nov 2023 18:22:57 +0800 Subject: [PATCH 2/2] add testcase for timeinterval --- src/main/java/seedu/address/model/Time.java | 2 + .../seedu/address/model/TimeInterval.java | 3 + .../commands/AddCommandIntegrationTest.java | 2 +- .../logic/parser/AddCommandParserTest.java | 2 +- .../seedu/address/model/TimeIntervalTest.java | 172 ++++++++++++++++++ .../seedu/address/testutil/PersonBuilder.java | 1 + .../address/testutil/TypicalPersons.java | 3 + .../testutil/TypicalTimeIntervals.java | 39 ++++ 8 files changed, 222 insertions(+), 2 deletions(-) create mode 100644 src/test/java/seedu/address/model/TimeIntervalTest.java diff --git a/src/main/java/seedu/address/model/Time.java b/src/main/java/seedu/address/model/Time.java index 287aecc9aea..fb5253a5da6 100644 --- a/src/main/java/seedu/address/model/Time.java +++ b/src/main/java/seedu/address/model/Time.java @@ -28,6 +28,8 @@ public class Time { * @param hour The time of the day. */ public Time(DayOfWeek day, LocalTime hour) { + requireNonNull(day); + requireNonNull(hour); this.day = day; this.hour = hour; } diff --git a/src/main/java/seedu/address/model/TimeInterval.java b/src/main/java/seedu/address/model/TimeInterval.java index dc2a56ab837..e97447c72b1 100644 --- a/src/main/java/seedu/address/model/TimeInterval.java +++ b/src/main/java/seedu/address/model/TimeInterval.java @@ -1,6 +1,7 @@ package seedu.address.model; +import static java.util.Objects.requireNonNull; import static seedu.address.logic.parser.CliSyntax.PREFIX_FREETIME; import java.time.DayOfWeek; @@ -31,6 +32,8 @@ public class TimeInterval { * @param end The end time of the interval. */ public TimeInterval(Time start, Time end) { + requireNonNull(start); + requireNonNull(end); this.start = start; this.end = end; } diff --git a/src/test/java/seedu/address/logic/commands/AddCommandIntegrationTest.java b/src/test/java/seedu/address/logic/commands/AddCommandIntegrationTest.java index 162a0c86031..4d686b08157 100644 --- a/src/test/java/seedu/address/logic/commands/AddCommandIntegrationTest.java +++ b/src/test/java/seedu/address/logic/commands/AddCommandIntegrationTest.java @@ -42,7 +42,7 @@ public void execute_newPerson_success() { public void execute_duplicatePerson_throwsCommandException() { Person personInList = model.getAddressBook().getPersonList().get(0); assertCommandFailure(new AddCommand(personInList), model, - AddCommand.MESSAGE_DUPLICATE_PERSON); + String.format(AddCommand.MESSAGE_DUPLICATE_PERSON, personInList.getName().toString())); } } diff --git a/src/test/java/seedu/address/logic/parser/AddCommandParserTest.java b/src/test/java/seedu/address/logic/parser/AddCommandParserTest.java index 654bfdb6455..56bfc8e5852 100644 --- a/src/test/java/seedu/address/logic/parser/AddCommandParserTest.java +++ b/src/test/java/seedu/address/logic/parser/AddCommandParserTest.java @@ -46,7 +46,7 @@ public void parse_allFieldsPresent_success() { Person expectedPerson = new PersonBuilder(BOB).build(); // whitespace only preamble - assertParseSuccess(parser, PREAMBLE_WHITESPACE + NAME_DESC_BOB + PHONE_DESC_BOB + EMAIL_DESC_BOB + 9(parser, PREAMBLE_WHITESPACE + NAME_DESC_BOB + PHONE_DESC_BOB + EMAIL_DESC_BOB + GROUP_DESC_BOB, new AddCommand(expectedPerson)); diff --git a/src/test/java/seedu/address/model/TimeIntervalTest.java b/src/test/java/seedu/address/model/TimeIntervalTest.java new file mode 100644 index 00000000000..8ce1ca10f34 --- /dev/null +++ b/src/test/java/seedu/address/model/TimeIntervalTest.java @@ -0,0 +1,172 @@ +package seedu.address.model; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static seedu.address.testutil.Assert.assertThrows; +import java.time.DayOfWeek; +import java.time.LocalTime; +import java.util.ArrayList; +import org.junit.jupiter.api.Test; +import seedu.address.testutil.TimeBuilder; +import seedu.address.testutil.TypicalTimeIntervals; + +public class TimeIntervalTest { + + @Test + public void constructor_nullArguments_throwsNullPointerException() { + assertThrows(NullPointerException.class, () -> new TimeInterval(null, null)); + } + + @Test + public void isTimeIntervalOverlap_noOverlaps_returnFalse() { + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalOneNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalTwoNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalThreeNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalFourNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalFiveNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalSixNoOverlap); + assertFalse(TimeInterval.isTimeIntervalOverlap(timeIntervalArrayList)); + } + + //all time interval overlaps + @Test + public void isTimeIntervalOverlap_OverlapsA_returnTrue() { + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalOneOverlapA); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalTwoOverlapA); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalThreeOverlapA); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalFourOverlapA); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalFiveOverlapA); + assertTrue(TimeInterval.isTimeIntervalOverlap(timeIntervalArrayList)); + } + + @Test + public void isTimeIntervalOverlap_OneOverlapsA_returnTrue() { + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalOneOverlapA); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalThreeNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalFourNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalTwoOverlapA); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalFiveNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalSixNoOverlap); + assertTrue(TimeInterval.isTimeIntervalOverlap(timeIntervalArrayList)); + } + + @Test + public void isTimeIntervalOverlap_EqualOverlapsA_returnTrue() { + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalOneOverlapA); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalFiveNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalSixNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalThreeOverlapA); + assertTrue(TimeInterval.isTimeIntervalOverlap(timeIntervalArrayList)); + } + + @Test + public void isTimeIntervalOverlap_InsideOutsideOverlapsB_returnTrue() { + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalOneOverlapB); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalFourNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalFiveNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalTwoOverlapB); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalSixNoOverlap); + assertTrue(TimeInterval.isTimeIntervalOverlap(timeIntervalArrayList)); + } + + @Test + public void isTimeIntervalOverlap_DiffDaysOverlapsC_returnTrue() { + ArrayList timeIntervalArrayList = new ArrayList<>(); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalOneOverlapC); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalFourNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalFiveNoOverlap); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalTwoOverlapC); + timeIntervalArrayList.add(TypicalTimeIntervals.timeIntervalSixNoOverlap); + assertTrue(TimeInterval.isTimeIntervalOverlap(timeIntervalArrayList)); + } + + @Test + public void isValidTimeIntervalSyntax_validInput_returnTrue() { + String input = "mon 1200 - fri 1300"; + assertTrue(TimeInterval.isValidTimeIntervalSyntax(input)); + } + + @Test + public void isValidTimeIntervalSyntax_inValidInput_returnFalse() { + String input = "mon 1200 - "; + assertFalse(TimeInterval.isValidTimeIntervalSyntax(input)); + } + + @Test + public void isValidTimeIntervalSyntax_inValidInputA_returnFalse() { + String input = "mon 1200 fri 2200"; + assertFalse(TimeInterval.isValidTimeIntervalSyntax(input)); + } + + @Test + public void isValidTimeIntervalSyntax_inValidInputB_returnFalse() { + String input = "mon1200 - fri 2200"; + assertFalse(TimeInterval.isValidTimeIntervalSyntax(input)); + } + + @Test + public void isValidTimeIntervalSyntax_inValidInputC_returnFalse() { + String input = "mon 1300 - fri"; + assertFalse(TimeInterval.isValidTimeIntervalSyntax(input)); + } + + @Test + public void isValidTimeIntervalLogic_validInput_returnTrue() { + Time start = new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(2,00)).build(); + Time end = new TimeBuilder().withDayAndHour(DayOfWeek.WEDNESDAY, LocalTime.of(2,00)).build(); + assertTrue(TimeInterval.isValidTimeIntervalLogic(start, end)); + } + + @Test + public void isValidTimeIntervalLogic_validInputB_returnFalse() { + Time start = new TimeBuilder().withDayAndHour(DayOfWeek.TUESDAY, LocalTime.of(23,59)).build(); + Time end = new TimeBuilder().withDayAndHour(DayOfWeek.WEDNESDAY, LocalTime.of(00,00)).build(); + assertTrue(TimeInterval.isValidTimeIntervalLogic(start, end)); + } + + @Test + public void isValidTimeIntervalLogic_inValidInputEqual_returnFalse() { + Time start = new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(2,00)).build(); + Time end = new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(2,00)).build(); + assertFalse(TimeInterval.isValidTimeIntervalLogic(start, end)); + } + + @Test + public void isValidTimeIntervalLogic_inValidInputEndBeforeStart_returnFalse() { + Time start = new TimeBuilder().withDayAndHour(DayOfWeek.WEDNESDAY, LocalTime.of(12,00)).build(); + Time end = new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(2,00)).build(); + assertFalse(TimeInterval.isValidTimeIntervalLogic(start, end)); + } + + @Test + public void isValidTimeIntervalLogic_inValidInputEndBeforeStartA_returnFalse() { + Time start = new TimeBuilder().withDayAndHour(DayOfWeek.WEDNESDAY, LocalTime.of(12,00)).build(); + Time end = new TimeBuilder().withDayAndHour(DayOfWeek.WEDNESDAY, LocalTime.of(11,59)).build(); + assertFalse(TimeInterval.isValidTimeIntervalLogic(start, end)); + } + + @Test + public void isValidTimeIntervalLogic_inValidInputEndBeforeStartB_returnFalse() { + Time start = new TimeBuilder().withDayAndHour(DayOfWeek.SUNDAY, LocalTime.of(12,00)).build(); + Time end = new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(00,00)).build(); + assertFalse(TimeInterval.isValidTimeIntervalLogic(start, end)); + } + + + + + + + + + + + + + +} diff --git a/src/test/java/seedu/address/testutil/PersonBuilder.java b/src/test/java/seedu/address/testutil/PersonBuilder.java index 8967b200d52..cd01e3f894d 100644 --- a/src/test/java/seedu/address/testutil/PersonBuilder.java +++ b/src/test/java/seedu/address/testutil/PersonBuilder.java @@ -49,6 +49,7 @@ public PersonBuilder(Person personToCopy) { phone = personToCopy.getPhone(); email = personToCopy.getEmail(); grpList = personToCopy.getGroups(); + timeIntervalList = personToCopy.getTime(); } /** diff --git a/src/test/java/seedu/address/testutil/TypicalPersons.java b/src/test/java/seedu/address/testutil/TypicalPersons.java index c78826c5d01..1b7fddc3ddb 100644 --- a/src/test/java/seedu/address/testutil/TypicalPersons.java +++ b/src/test/java/seedu/address/testutil/TypicalPersons.java @@ -8,6 +8,7 @@ import static seedu.address.logic.commands.CommandTestUtil.VALID_NAME_BOB; import static seedu.address.logic.commands.CommandTestUtil.VALID_PHONE_AMY; import static seedu.address.logic.commands.CommandTestUtil.VALID_PHONE_BOB; +import static seedu.address.logic.commands.CommandTestUtil.VALID_TIME_MON; import java.util.ArrayList; import java.util.Arrays; @@ -54,6 +55,8 @@ public class TypicalPersons { public static final Person BOB = new PersonBuilder().withName(VALID_NAME_BOB).withPhone(VALID_PHONE_BOB) .withEmail(VALID_EMAIL_BOB).withGroupList(VALID_GROUP_BOB).build(); + + public static final String KEYWORD_MATCHING_MEIER = "Meier"; // A keyword that matches MEIER private TypicalPersons() {} // prevents instantiation diff --git a/src/test/java/seedu/address/testutil/TypicalTimeIntervals.java b/src/test/java/seedu/address/testutil/TypicalTimeIntervals.java index 7393e870797..b46754d236b 100644 --- a/src/test/java/seedu/address/testutil/TypicalTimeIntervals.java +++ b/src/test/java/seedu/address/testutil/TypicalTimeIntervals.java @@ -21,6 +21,21 @@ public class TypicalTimeIntervals { .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(14, 00)).build(), new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(15, 00)).build()).build(); + public static TimeInterval timeIntervalFourNoOverlap = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(22, 00)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(23, 00)).build()).build(); + + public static TimeInterval timeIntervalFiveNoOverlap = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(21, 05)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(21, 9)).build()).build(); + + public static TimeInterval timeIntervalSixNoOverlap = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(21, 12)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(21, 23)).build()).build(); + public static TimeInterval timeIntervalOneOverlapA = new TimeIntervalBuilder() .withStartTimeAndEndTime(new TimeBuilder() @@ -48,6 +63,30 @@ public class TypicalTimeIntervals { new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(13, 00)).build()).build(); + public static TimeInterval timeIntervalOneOverlapB = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(5, 00)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(12, 00)).build()).build(); + + public static TimeInterval timeIntervalTwoOverlapB = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(6, 00)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(8, 00)).build()).build(); + + public static TimeInterval timeIntervalOneOverlapC = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.MONDAY, LocalTime.of(5, 00)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.WEDNESDAY, LocalTime.of(12, 00)).build()).build(); + + public static TimeInterval timeIntervalTwoOverlapC = new TimeIntervalBuilder() + .withStartTimeAndEndTime(new TimeBuilder() + .withDayAndHour(DayOfWeek.WEDNESDAY, LocalTime.of(6, 00)).build(), + new TimeBuilder().withDayAndHour(DayOfWeek.FRIDAY, LocalTime.of(8, 00)).build()).build(); + + + + +