From 95034059478888113b2967638901425ab28845dd Mon Sep 17 00:00:00 2001 From: Mariana Date: Tue, 3 Jun 2025 19:55:50 +0100 Subject: [PATCH] add Junit tests generated by AI --- .../java/MakeItFit/MakeItFitTest.java | 321 ++++++++++++++++ .../activities/ActivityManagerTest.java | 71 ++++ .../MakeItFit/activities/ActivityTest.java | 197 ++++++++++ .../activities/implementation/PushUpTest.java | 121 ++++++ .../implementation/RunningTest.java | 145 ++++++++ .../activities/implementation/TrailTest.java | 197 ++++++++++ .../implementation/WeightSquatTest.java | 154 ++++++++ .../activities/types/DistanceTest.java | 156 ++++++++ .../types/DistanceWithAltimetryTest.java | 219 +++++++++++ .../activities/types/RepetitionsTest.java | 192 ++++++++++ .../types/RepetitionsWithWeightsTest.java | 207 +++++++++++ .../queries/HowManyAltimetryDoneTest.java | 83 +++++ .../MakeItFit/queries/HowManyKMsDoneTest.java | 81 ++++ .../MostDemandingTrainingPlanTest.java | 111 ++++++ .../queries/MostDoneActivityTest.java | 69 ++++ .../MakeItFit/queries/QueriesManagerTest.java | 109 ++++++ .../queries/WhoBurnsMoreCaloriesTest.java | 109 ++++++ .../queries/WhoDidTheMostActivitiesTest.java | 120 ++++++ .../java/MakeItFit/time/TimeManagerTest.java | 101 +++++ .../trainingPlan/TrainingPlanManagerTest.java | 175 +++++++++ .../trainingPlan/TrainingPlanTest.java | 189 ++++++++++ .../java/MakeItFit/users/UserManagerTest.java | 302 +++++++++++++++ .../java/MakeItFit/users/UserTest.java | 347 ++++++++++++++++++ .../MakeItFit/users/types/AmateurTest.java | 115 ++++++ .../MakeItFit/users/types/OccasionalTest.java | 163 ++++++++ .../users/types/ProfessionalTest.java | 173 +++++++++ .../MakeItFit/utils/EmailValidatorTest.java | 68 ++++ .../MakeItFit/utils/ExtendedRandomTest.java | 62 ++++ .../MakeItFit/utils/MakeItFitDateTest.java | 99 +++++ .../java/MakeItFit/utils/MyTupleTest.java | 64 ++++ 30 files changed, 4520 insertions(+) create mode 100644 src/aiunittests/java/MakeItFit/MakeItFitTest.java create mode 100644 src/aiunittests/java/MakeItFit/activities/ActivityManagerTest.java create mode 100644 src/aiunittests/java/MakeItFit/activities/ActivityTest.java create mode 100644 src/aiunittests/java/MakeItFit/activities/implementation/PushUpTest.java create mode 100644 src/aiunittests/java/MakeItFit/activities/implementation/RunningTest.java create mode 100644 src/aiunittests/java/MakeItFit/activities/implementation/TrailTest.java create mode 100644 src/aiunittests/java/MakeItFit/activities/implementation/WeightSquatTest.java create mode 100644 src/aiunittests/java/MakeItFit/activities/types/DistanceTest.java create mode 100644 src/aiunittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java create mode 100644 src/aiunittests/java/MakeItFit/activities/types/RepetitionsTest.java create mode 100644 src/aiunittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java create mode 100644 src/aiunittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java create mode 100644 src/aiunittests/java/MakeItFit/queries/HowManyKMsDoneTest.java create mode 100644 src/aiunittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java create mode 100644 src/aiunittests/java/MakeItFit/queries/MostDoneActivityTest.java create mode 100644 src/aiunittests/java/MakeItFit/queries/QueriesManagerTest.java create mode 100644 src/aiunittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java create mode 100644 src/aiunittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java create mode 100644 src/aiunittests/java/MakeItFit/time/TimeManagerTest.java create mode 100644 src/aiunittests/java/MakeItFit/trainingPlan/TrainingPlanManagerTest.java create mode 100644 src/aiunittests/java/MakeItFit/trainingPlan/TrainingPlanTest.java create mode 100644 src/aiunittests/java/MakeItFit/users/UserManagerTest.java create mode 100644 src/aiunittests/java/MakeItFit/users/UserTest.java create mode 100644 src/aiunittests/java/MakeItFit/users/types/AmateurTest.java create mode 100644 src/aiunittests/java/MakeItFit/users/types/OccasionalTest.java create mode 100644 src/aiunittests/java/MakeItFit/users/types/ProfessionalTest.java create mode 100644 src/aiunittests/java/MakeItFit/utils/EmailValidatorTest.java create mode 100644 src/aiunittests/java/MakeItFit/utils/ExtendedRandomTest.java create mode 100644 src/aiunittests/java/MakeItFit/utils/MakeItFitDateTest.java create mode 100644 src/aiunittests/java/MakeItFit/utils/MyTupleTest.java diff --git a/src/aiunittests/java/MakeItFit/MakeItFitTest.java b/src/aiunittests/java/MakeItFit/MakeItFitTest.java new file mode 100644 index 0000000..ea91bbb --- /dev/null +++ b/src/aiunittests/java/MakeItFit/MakeItFitTest.java @@ -0,0 +1,321 @@ +package MakeItFit; +import java.io.File; +import java.io.FileNotFoundException; +import java.util.List; +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.exceptions.EntityDoesNotExistException; +import MakeItFit.exceptions.ExistingEntityConflictException; +import MakeItFit.trainingPlan.TrainingPlan; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.utils.MakeItFitDate; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +public class MakeItFitTest { + + private MakeItFit mif; + private String testEmail = "test@example.com"; + private String email1 = "user1@example.com"; + private String email2 = "user2@example.com"; + private MakeItFitDate testDate1 = MakeItFitDate.of(2023, 5, 1); + private MakeItFitDate testDate2 = MakeItFitDate.of(2023, 5, 31); + private String fileName = "makeitfit_test.dat"; + private UUID testUserId; + + @Before + public void setUp() throws Exception { + mif = new MakeItFit(); + + // Setup for general user tests + mif.createUser("Test User", + 30, + Gender.Male, + 70.5f, + 175, + 72, + 5, + "Test Address", + "123456789", + testEmail, + 3, + "Amateur"); + testUserId = mif.getUser(testEmail).getCode(); + + // Setup for query tests + mif.createUser("Active User", + 30, + Gender.Male, + 75.0f, + 180, + 70, + 8, + "Active St", + "111111111", + email1, + 5, + "Professional"); + mif.createUser("Casual User", + 35, + Gender.Female, + 60.0f, + 165, + 65, + 5, + "Casual St", + "222222222", + email2, + 2, + "Amateur"); + + // Add activities for query tests + Activity a1 = new PushUp(); // In date range + Activity a2 = new PushUp(); // In date range + Activity a3 = new PushUp(); // Outside date range + Activity a4 = new PushUp(); // In date range + Activity a5 = new PushUp(); // Outside date range + + mif.addActivityToUser(email1, a1); + mif.addActivityToUser(email1, a2); + mif.addActivityToUser(email1, a3); + mif.addActivityToUser(email2, a4); + mif.addActivityToUser(email2, a5); + } + + // User Management Tests + @Test + public void testCreateAndGetUser() throws Exception { + User user = mif.getUser(testEmail); + assertNotNull(user); + assertEquals("Test User", user.getName()); + assertEquals(testEmail, user.getEmail()); + } + + @Test(expected = ExistingEntityConflictException.class) + public void testCreateDuplicateUser() throws Exception { + mif.createUser("Test User", + 30, + Gender.Male, + 70.5f, + 175, + 72, + 5, + "Test Address", + "123456789", + testEmail, + 3, + "Amateur"); + } + + @Test + public void testRemoveUserByEmail() throws Exception { + assertTrue(mif.existsUserWithEmail(testEmail)); + mif.removeUser(testEmail); + assertFalse(mif.existsUserWithEmail(testEmail)); + } + + @Test + public void testRemoveUserByUUID() throws Exception { + User user = mif.getUser(testEmail); + UUID userId = user.getCode(); + + assertTrue(mif.existsUserWithEmail(testEmail)); + mif.removeUser(userId); + assertFalse(mif.existsUserWithEmail(testEmail)); + } + + @Test(expected = EntityDoesNotExistException.class) + public void testRemoveNonExistentUser() throws Exception { + mif.removeUser(UUID.randomUUID()); + } + + @Test + public void testUpdateUserDetails() throws Exception { + mif.updateUserName("Updated Name", testEmail); + mif.updateUserAge(31, testEmail); + mif.updateUserWeight(71.0f, testEmail); + mif.updateUserHeight(176, testEmail); + + User updatedUser = mif.getUser("test@example.com"); + assertEquals("Updated Name", updatedUser.getName()); + assertEquals(31, updatedUser.getAge()); + assertEquals(71.0f, updatedUser.getWeight(), 0.001); + assertEquals(176, updatedUser.getHeight()); + } + + @Test + public void testUserActivitiesManagement() throws Exception { + Activity activity = new PushUp(); + mif.addActivityToUser(testEmail, activity); + + List activities = mif.getActivitiesFromUser(testEmail); + assertEquals(1, activities.size()); + + mif.removeActivityFromUser(testEmail, activity.getCode()); + activities = mif.getActivitiesFromUser(testEmail); + assertEquals(0, activities.size()); + } + + // Training Plan Tests + @Test + public void testCreateAndGetTrainingPlan() throws Exception { + MakeItFitDate startDate = MakeItFitDate.of(2023, 6, 1); + UUID planId = mif.createTrainingPlan(testUserId, startDate); + + TrainingPlan plan = mif.getTrainingPlan(planId); + assertNotNull(plan); + assertEquals(testUserId, plan.getUserCode()); + assertEquals(startDate, plan.getStartDate()); + } + + @Test + public void testRemoveTrainingPlan() throws Exception { + MakeItFitDate startDate = MakeItFitDate.of(2023, 6, 1); + UUID planId = mif.createTrainingPlan(testUserId, startDate); + + assertNotNull(mif.getTrainingPlan(planId)); + mif.removeTrainingPlan(planId); + + try { + mif.getTrainingPlan(planId); + fail("Expected exception not thrown"); + } catch (IllegalArgumentException e) { + // Expected + } + } + + @Test + public void testGetTrainingPlansFromUser() throws Exception { + MakeItFitDate date1 = MakeItFitDate.of(2023, 6, 1); + MakeItFitDate date2 = MakeItFitDate.of(2023, 7, 1); + + UUID planId1 = mif.createTrainingPlan(testUserId, date1); + UUID planId2 = mif.createTrainingPlan(testUserId, date2); + + List plans = mif.getTrainingPlansFromUser(testUserId); + assertEquals(2, plans.size()); + assertTrue(plans.stream().anyMatch(p -> p.getCode().equals(planId1))); + assertTrue(plans.stream().anyMatch(p -> p.getCode().equals(planId2))); + } + + @Test + public void testConstructTrainingPlanByObjectives() throws Exception { + MakeItFitDate startDate = MakeItFitDate.of(2023, 6, 1); + UUID planId = mif.createTrainingPlan(testUserId, startDate); + TrainingPlan plan = mif.getTrainingPlan(planId); + + mif.constructTrainingPlanByObjectives(plan, true, 3, 5, 2, 500); + assertFalse(plan.getActivities().isEmpty()); + } + + @Test + public void testTrainingPlanActivitiesManagement() throws Exception { + MakeItFitDate startDate = MakeItFitDate.of(2023, 6, 1); + UUID planId = mif.createTrainingPlan(testUserId, startDate); + + Activity activity = new PushUp(); + mif.addActivityToTrainingPlan(planId, activity, 10); + + TrainingPlan plan = mif.getTrainingPlan(planId); + assertEquals(1, plan.getActivities().size()); + + mif.removeActivityFromTrainingPlan(planId, activity.getCode()); + assertEquals(0, plan.getActivities().size()); + } + + @Test + public void testExecuteQueryMostDemandingTrainingPlan() throws Exception { + UUID user1Id = mif.getUser(email1).getCode(); + UUID user2Id = mif.getUser(email2).getCode(); + + UUID planId1 = mif.createTrainingPlan(user1Id, testDate1); + UUID planId2 = mif.createTrainingPlan(user2Id, testDate1); + + TrainingPlan plan2 = mif.getTrainingPlan(planId2); + + mif.constructTrainingPlanByObjectives(plan2, false, 3, 3, 2, 500); + + TrainingPlan mostDemanding = mif.executeQueryMostDemandingTrainingPlan(); + assertEquals(planId2, mostDemanding.getCode()); + } + + @Test + public void testExecuteQueryMostDoneActivity() { + String mostDone = mif.executeQueryMostDoneActivity(); + assertEquals("RepetitionsWithWeights", mostDone); + } + + // Persistence Tests + @Test + public void testSaveAndLoadSystem() throws Exception { + // Save system + mif.saveSystem(fileName); + + // Create new instance and load + MakeItFit loadedMif = new MakeItFit(); + loadedMif.loadSystem(fileName); + + // Verify data was loaded correctly + User loadedUser = loadedMif.getUser(testEmail); + assertNotNull(loadedUser); + assertEquals("Test User", loadedUser.getName()); + } + + @Test(expected = FileNotFoundException.class) + public void testLoadNonExistentFile() throws Exception { + mif.loadSystem("nonexistent_file.dat"); + } + + // System Update Tests + @Test + public void testUpdateSystemWithTrainingPlan() throws Exception { + MakeItFitDate startDate = MakeItFitDate.of(2023, 6, 1); + MakeItFitDate currentDate = MakeItFitDate.of(2023, 6, 2); + + UUID planId = mif.createTrainingPlan(testUserId, startDate); + TrainingPlan plan = mif.getTrainingPlan(planId); + mif.constructTrainingPlanByObjectives(plan, false, 2, 3, 1, 300); + + assertEquals(0, mif.getActivitiesFromUser(testEmail).size()); + mif.updateSystem(currentDate, testUserId); + assertTrue(mif.getActivitiesFromUser(testEmail).size() > 0); + } + + @Test + public void testUpdateSystemWithMultipleDays() throws Exception { + MakeItFitDate startDate = MakeItFitDate.of(2023, 6, 1); + MakeItFitDate day1 = MakeItFitDate.of(2023, 6, 1); + MakeItFitDate day2 = MakeItFitDate.of(2023, 6, 2); + + UUID planId = mif.createTrainingPlan(testUserId, startDate); + TrainingPlan plan = mif.getTrainingPlan(planId); + mif.constructTrainingPlanByObjectives(plan, false, 2, 3, 1, 300); + + mif.updateSystem(day1, testUserId); + int day1Activities = mif.getActivitiesFromUser(testEmail).size(); + + mif.updateSystem(day2, testUserId); + int day2Activities = mif.getActivitiesFromUser(testEmail).size(); + + assertTrue(day2Activities > day1Activities); + } + + // Clean up after tests + @After + public void tearDown() { + File file = new File(fileName); + if (file.exists()) { + file.delete(); + } + } +} diff --git a/src/aiunittests/java/MakeItFit/activities/ActivityManagerTest.java b/src/aiunittests/java/MakeItFit/activities/ActivityManagerTest.java new file mode 100644 index 0000000..d084c83 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/activities/ActivityManagerTest.java @@ -0,0 +1,71 @@ +package MakeItFit.activities; + +import java.util.Arrays; +import java.util.List; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class ActivityManagerTest { + + private static final List EXPECTED_ACTIVITIES = + Arrays.asList("PushUp", "Running", "Trail", "WeightSquat"); + + @Test + void testGetRandomActivityReturnsValidActivity() { + ActivityManager manager = new ActivityManager(); + + // Test multiple times to account for randomness + for (int i = 0; i < 100; i++) { + String activity = manager.getRandomActivity(); + assertTrue(EXPECTED_ACTIVITIES.contains(activity), + "Returned activity should be one of: " + EXPECTED_ACTIVITIES); + } + } + + @Test + void testAllActivitiesAreEventuallyReturned() { + ActivityManager manager = new ActivityManager(); + boolean[] foundActivities = new boolean[EXPECTED_ACTIVITIES.size()]; + + // Run enough times to likely get all activities + for (int i = 0; i < 1000; i++) { + String activity = manager.getRandomActivity(); + int index = EXPECTED_ACTIVITIES.indexOf(activity); + foundActivities[index] = true; + } + + // Verify all activities were returned at least once + for (boolean found : foundActivities) { + assertTrue(found, "All activities should be returned eventually"); + } + } + + @Test + void testActivityDistributionIsReasonable() { + ActivityManager manager = new ActivityManager(); + int[] counts = new int[EXPECTED_ACTIVITIES.size()]; + int totalRuns = 10000; + + // Count how many times each activity appears + for (int i = 0; i < totalRuns; i++) { + String activity = manager.getRandomActivity(); + int index = EXPECTED_ACTIVITIES.indexOf(activity); + counts[index]++; + } + + // Check that each activity appears roughly 25% of the time (with some tolerance) + double expectedPercentage = 0.25; + double tolerance = 0.05; // ±5% + + for (int count : counts) { + double actualPercentage = (double) count / totalRuns; + assertEquals(expectedPercentage, + actualPercentage, + tolerance, + "Activities should be roughly evenly distributed"); + } + } +} diff --git a/src/aiunittests/java/MakeItFit/activities/ActivityTest.java b/src/aiunittests/java/MakeItFit/activities/ActivityTest.java new file mode 100644 index 0000000..37e250c --- /dev/null +++ b/src/aiunittests/java/MakeItFit/activities/ActivityTest.java @@ -0,0 +1,197 @@ +package MakeItFit.activities; + +import java.util.UUID; + +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class ActivityTest { + + private TestActivity activity; + private UUID testUserCode; + private MakeItFitDate testDate; + + @BeforeEach + void setUp() { + testUserCode = UUID.randomUUID(); + testDate = MakeItFitDate.of(2023, 1, 1); + activity = new TestActivity(testUserCode, testDate, 60, "Workout", "Running"); + } + + @Test + void testConstructorWithParameters() { + assertEquals(testUserCode, activity.getUserCode()); + assertEquals(testDate, activity.getRealizationDate()); + assertEquals(60, activity.getExpectedDuration()); + assertEquals("Workout", activity.getDesignation()); + assertEquals("Running", activity.getName()); + assertNotNull(activity.getCode()); + assertEquals(0, activity.getDuration()); + assertEquals(0, activity.getCaloricWaste()); + } + + @Test + void testDefaultConstructor() { + TestActivity defaultActivity = new TestActivity(); + assertEquals(new UUID(0L, 0L), defaultActivity.getUserCode()); + assertNotNull(defaultActivity.getCode()); + assertNotNull(defaultActivity.getRealizationDate()); + assertEquals(0, defaultActivity.getExpectedDuration()); + assertEquals("", defaultActivity.getDesignation()); + assertEquals(0, defaultActivity.getDuration()); + assertEquals(0, defaultActivity.getCaloricWaste()); + assertEquals("", defaultActivity.getName()); + } + + @Test + void testCopyConstructor() { + activity.setDuration(45); + activity.setCaloricWaste(300); + + TestActivity copiedActivity = new TestActivity(activity); + assertEquals(activity.getUserCode(), copiedActivity.getUserCode()); + assertEquals(activity.getCode(), copiedActivity.getCode()); + assertEquals(activity.getRealizationDate(), copiedActivity.getRealizationDate()); + assertEquals(activity.getExpectedDuration(), copiedActivity.getExpectedDuration()); + assertEquals(activity.getDesignation(), copiedActivity.getDesignation()); + assertEquals(activity.getDuration(), copiedActivity.getDuration()); + assertEquals(activity.getCaloricWaste(), copiedActivity.getCaloricWaste()); + assertEquals(activity.getName(), copiedActivity.getName()); + } + + @Test + void testSettersAndGetters() { + activity.setExpectedDuration(90); + assertEquals(90, activity.getExpectedDuration()); + + activity.setDesignation("Cardio"); + assertEquals("Cardio", activity.getDesignation()); + + activity.setDuration(30); + assertEquals(30, activity.getDuration()); + + activity.setCaloricWaste(200); + assertEquals(200, activity.getCaloricWaste()); + + activity.setSpecialization("Endurance"); + assertEquals("Endurance", activity.getSpecialization()); + } + + @Test + void testUpdateActivity() { + activity.setDuration(40); + activity.updateActivity(1.5f); + assertTrue(activity.getCaloricWaste() > 0); + } + + @Test + void testEquals() { + TestActivity sameActivity = + new TestActivity(testUserCode, testDate, 60, "Workout", "Running"); + TestActivity differentActivity = + new TestActivity(testUserCode, testDate, 30, "Cardio", "Swimming"); + + assertTrue(activity.equals(sameActivity)); + assertFalse(activity.equals(differentActivity)); + assertFalse(activity.equals(null)); + assertTrue(activity.equals(activity)); + } + + @Test + void testCompareTo() { + MakeItFitDate earlierDate = MakeItFitDate.of(2022, 1, 1); + MakeItFitDate laterDate = MakeItFitDate.of(2024, 1, 1); + + TestActivity earlierActivity = + new TestActivity(testUserCode, earlierDate, 60, "Workout", "Running"); + TestActivity laterActivity = + new TestActivity(testUserCode, laterDate, 60, "Workout", "Running"); + TestActivity sameDateShorterActivity = + new TestActivity(testUserCode, testDate, 30, "Workout", "Running"); + TestActivity sameDateLongerActivity = + new TestActivity(testUserCode, testDate, 90, "Workout", "Running"); + + assertTrue(activity.compareTo(earlierActivity) > 0); + assertTrue(activity.compareTo(laterActivity) < 0); + assertTrue(activity.compareTo(sameDateShorterActivity) > 0); + assertTrue(activity.compareTo(sameDateLongerActivity) < 0); + assertEquals(0, activity.compareTo(activity)); + } + + @Test + void testToString() { + String str = activity.toString(); + assertTrue(str.contains("Activity: Running")); + assertTrue(str.contains("Code: " + activity.getCode())); + assertTrue(str.contains("Designation: Workout")); + assertTrue(str.contains("Expected Duration: 60 minutes")); + assertTrue(str.contains("Realization Date: " + testDate)); + assertTrue(str.contains("Caloric Waste: 0 calories")); + } + + @Test + void testClone() { + activity.setDuration(45); + activity.setCaloricWaste(300); + + TestActivity clonedActivity = (TestActivity) activity.clone(); + assertEquals(activity.getUserCode(), clonedActivity.getUserCode()); + assertEquals(activity.getCode(), clonedActivity.getCode()); + assertEquals(activity.getRealizationDate(), clonedActivity.getRealizationDate()); + assertEquals(activity.getExpectedDuration(), clonedActivity.getExpectedDuration()); + assertEquals(activity.getDesignation(), clonedActivity.getDesignation()); + assertEquals(activity.getDuration(), clonedActivity.getDuration()); + assertEquals(activity.getCaloricWaste(), clonedActivity.getCaloricWaste()); + assertEquals(activity.getName(), clonedActivity.getName()); + } +} + +class TestActivity extends Activity { + private String specialization = ""; + + public TestActivity(UUID userCode, + MakeItFitDate realizationDate, + int expectedDuration, + String designation, + String name) { + super(userCode, realizationDate, expectedDuration, designation, name); + } + + public TestActivity() { + super(); + } + + public TestActivity(TestActivity a) { + super(a); + this.specialization = a.specialization; + } + + public void setSpecialization(String specialization) { + this.specialization = specialization; + } + + public String getSpecialization() { + return this.specialization; + } + + @Override + public void calculateCaloricWaste(float index) { + this.setCaloricWaste((int) (this.getDuration() * index * 0.5)); + } + + @Override + public int caloricWaste(float index) { + return (int) (this.getDuration() * index * 0.5); + } + + @Override + public Activity clone() { + return new TestActivity(this); + } +} diff --git a/src/aiunittests/java/MakeItFit/activities/implementation/PushUpTest.java b/src/aiunittests/java/MakeItFit/activities/implementation/PushUpTest.java new file mode 100644 index 0000000..056da68 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/activities/implementation/PushUpTest.java @@ -0,0 +1,121 @@ +package MakeItFit.activities.implementation; + +import java.util.UUID; + +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class PushUpTest { + + @Test + void testConstructorWithParameters() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + PushUp pushUp = new PushUp(userCode, date, 15, "Strength", "Push Up", 15, 3); + + assertEquals(userCode, pushUp.getUserCode()); + assertEquals(date, pushUp.getRealizationDate()); + assertEquals(15, pushUp.getExpectedDuration()); + assertEquals("Strength", pushUp.getDesignation()); + assertEquals("Push Up", pushUp.getName()); + assertEquals(15, pushUp.getRepetitions()); + assertEquals(3, pushUp.getSeries()); + } + + @Test + void testDefaultConstructor() { + PushUp pushUp = new PushUp(); + + assertNotNull(pushUp.getUserCode()); + assertNotNull(pushUp.getRealizationDate()); + assertEquals(0, pushUp.getExpectedDuration()); + assertEquals(0, pushUp.getRepetitions()); + assertEquals(0, pushUp.getSeries()); + } + + @Test + void testCopyConstructor() { + PushUp original = + new PushUp(UUID.randomUUID(), new MakeItFitDate(), 10, "Test", "Push Up", 10, 4); + + PushUp copy = new PushUp(original); + + assertEquals(original.getUserCode(), copy.getUserCode()); + assertEquals(original.getRealizationDate(), copy.getRealizationDate()); + assertEquals(original.getExpectedDuration(), copy.getExpectedDuration()); + assertEquals(original.getDesignation(), copy.getDesignation()); + assertEquals(original.getName(), copy.getName()); + assertEquals(original.getRepetitions(), copy.getRepetitions()); + assertEquals(original.getSeries(), copy.getSeries()); + } + + @Test + void testCaloricWaste() { + PushUp pushUp = new PushUp(); + pushUp.setRepetitions(20); + pushUp.setSeries(3); + + float index = 1.0f; + int expected = (int) (20 * 3 * 1.0 * 0.1); + assertEquals(expected, pushUp.caloricWaste(index)); + + index = 1.5f; + expected = (int) (20 * 3 * 1.5 * 0.1); + assertEquals(expected, pushUp.caloricWaste(index)); + } + + @Test + void testCalculateCaloricWaste() { + PushUp pushUp = new PushUp(); + pushUp.setRepetitions(15); + pushUp.setSeries(4); + + float index = 1.2f; + pushUp.calculateCaloricWaste(index); + + int expected = (int) (15 * 4 * 1.2 * 0.1); + assertEquals(expected, pushUp.getCaloricWaste()); + } + + @Test + void testToString() { + PushUp pushUp = new PushUp(); + pushUp.setRepetitions(12); + pushUp.setSeries(5); + + String result = pushUp.toString(); + assertTrue(result.contains("12")); + assertTrue(result.contains("5")); + } + + @Test + void testEquals() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + PushUp pushUp1 = new PushUp(userCode, date, 20, "Workout", "Push Up", 15, 3); + PushUp pushUp2 = new PushUp(userCode, date, 20, "Workout", "Push Up", 15, 3); + PushUp pushUp3 = new PushUp(userCode, date, 20, "Workout", "Push Up", 12, 3); + + assertEquals(pushUp1, pushUp2); + assertNotEquals(pushUp1, pushUp3); + assertNotEquals(pushUp1, null); + assertNotEquals(pushUp1, new Object()); + } + + @Test + void testClone() { + PushUp original = + new PushUp(UUID.randomUUID(), new MakeItFitDate(), 15, "Exercise", "Push Up", 10, 4); + + PushUp clone = original.clone(); + + assertEquals(original, clone); + assertNotSame(original, clone); + } +} diff --git a/src/aiunittests/java/MakeItFit/activities/implementation/RunningTest.java b/src/aiunittests/java/MakeItFit/activities/implementation/RunningTest.java new file mode 100644 index 0000000..2186e23 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/activities/implementation/RunningTest.java @@ -0,0 +1,145 @@ +package MakeItFit.activities.implementation; + +import java.util.UUID; + +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class RunningTest { + + @Test + void testConstructorWithParameters() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + Running running = new Running(userCode, date, 45, "Morning Run", "5K", 5.0, 10.5); + + assertEquals(userCode, running.getUserCode()); + assertEquals(date, running.getRealizationDate()); + assertEquals(45, running.getExpectedDuration()); + assertEquals("Morning Run", running.getDesignation()); + assertEquals("5K", running.getName()); + assertEquals(5.0, running.getDistance()); + assertEquals(10.5, running.getSpeed()); + } + + @Test + void testDefaultConstructor() { + Running running = new Running(); + + assertNotNull(running.getUserCode()); + assertNotNull(running.getRealizationDate()); + assertEquals(0, running.getExpectedDuration()); + assertEquals(0.0, running.getDistance()); + assertEquals(0.0, running.getSpeed()); + } + + @Test + void testCopyConstructor() { + Running original = new Running(UUID.randomUUID(), + new MakeItFitDate(), + 30, + "Sprint", + "Interval", + 3.0, + 12.0); + + Running copy = new Running(original); + + assertEquals(original.getUserCode(), copy.getUserCode()); + assertEquals(original.getRealizationDate(), copy.getRealizationDate()); + assertEquals(original.getExpectedDuration(), copy.getExpectedDuration()); + assertEquals(original.getDesignation(), copy.getDesignation()); + assertEquals(original.getName(), copy.getName()); + assertEquals(original.getDistance(), copy.getDistance()); + assertEquals(original.getSpeed(), copy.getSpeed()); + } + + @Test + void testSetSpeed() { + Running running = new Running(); + + running.setSpeed(10.5); + assertEquals(10.5, running.getSpeed()); + + running.setSpeed(0); + assertEquals(0, running.getSpeed()); + + running.setSpeed(-5.0); + assertEquals(-5.0, running.getSpeed()); + } + + @Test + void testCaloricWaste() { + Running running = new Running(); + running.setDistance(10.0); + running.setSpeed(12.0); + + float index = 1.0f; + int expected = (int) (12.0 * 10.0 * 1.0 * 0.005); + assertEquals(expected, running.caloricWaste(index)); + + index = 1.2f; + expected = (int) (12.0 * 10.0 * 1.2 * 0.005); + assertEquals(expected, running.caloricWaste(index)); + } + + @Test + void testCalculateCaloricWaste() { + Running running = new Running(); + running.setDistance(8.0); + running.setSpeed(10.0); + + float index = 1.5f; + running.calculateCaloricWaste(index); + + int expected = (int) (10.0 * 8.0 * 1.5 * 0.005); + assertEquals(expected, running.getCaloricWaste()); + } + + @Test + void testToString() { + Running running = new Running(); + running.setDistance(21.1); + running.setSpeed(11.5); + + String result = running.toString(); + assertTrue(result.contains("21.1")); + assertTrue(result.contains("11.5 Km/h")); + } + + @Test + void testEquals() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + Running running1 = new Running(userCode, date, 60, "Long Run", "Half Marathon", 21.1, 10.5); + Running running2 = new Running(userCode, date, 60, "Long Run", "Half Marathon", 21.1, 10.5); + Running running3 = new Running(userCode, date, 60, "Long Run", "Half Marathon", 21.1, 11.0); + + assertEquals(running1, running2); + assertNotEquals(running1, running3); + assertNotEquals(running1, null); + assertNotEquals(running1, new Object()); + } + + @Test + void testClone() { + Running original = new Running(UUID.randomUUID(), + new MakeItFitDate(), + 45, + "Recovery", + "Easy Run", + 5.0, + 9.5); + + Running clone = original.clone(); + + assertEquals(original, clone); + assertNotSame(original, clone); + } +} diff --git a/src/aiunittests/java/MakeItFit/activities/implementation/TrailTest.java b/src/aiunittests/java/MakeItFit/activities/implementation/TrailTest.java new file mode 100644 index 0000000..7784e1a --- /dev/null +++ b/src/aiunittests/java/MakeItFit/activities/implementation/TrailTest.java @@ -0,0 +1,197 @@ +package MakeItFit.activities.implementation; + +import java.util.UUID; + +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class TrailTest { + + @Test + void testConstructorWithParameters() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + Trail trail = new Trail(userCode, + date, + 120, + "Mountain Trail", + "Hard Climb", + 15.5, + 800.0, + 600.0, + Trail.TRAIL_TYPE_HARD); + + assertEquals(userCode, trail.getUserCode()); + assertEquals(date, trail.getRealizationDate()); + assertEquals(120, trail.getExpectedDuration()); + assertEquals("Mountain Trail", trail.getDesignation()); + assertEquals("Hard Climb", trail.getName()); + assertEquals(15.5, trail.getDistance()); + assertEquals(800.0, trail.getElevationGain()); + assertEquals(600.0, trail.getElevationLoss()); + assertEquals(Trail.TRAIL_TYPE_HARD, trail.getTrailType()); + } + + @Test + void testDefaultConstructor() { + Trail trail = new Trail(); + + assertNotNull(trail.getUserCode()); + assertNotNull(trail.getRealizationDate()); + assertEquals(0, trail.getExpectedDuration()); + assertEquals(0.0, trail.getDistance()); + assertEquals(0.0, trail.getElevationGain()); + assertEquals(0.0, trail.getElevationLoss()); + assertEquals(Trail.TRAIL_TYPE_EASY, trail.getTrailType()); + } + + @Test + void testCopyConstructor() { + Trail original = new Trail(UUID.randomUUID(), + new MakeItFitDate(), + 90, + "Forest", + "Easy Path", + 10.0, + 300.0, + 300.0, + Trail.TRAIL_TYPE_MEDIUM); + + Trail copy = new Trail(original); + + assertEquals(original.getUserCode(), copy.getUserCode()); + assertEquals(original.getRealizationDate(), copy.getRealizationDate()); + assertEquals(original.getExpectedDuration(), copy.getExpectedDuration()); + assertEquals(original.getDesignation(), copy.getDesignation()); + assertEquals(original.getName(), copy.getName()); + assertEquals(original.getDistance(), copy.getDistance()); + assertEquals(original.getElevationGain(), copy.getElevationGain()); + assertEquals(original.getElevationLoss(), copy.getElevationLoss()); + assertEquals(original.getTrailType(), copy.getTrailType()); + } + + @Test + void testSetTrailType() { + Trail trail = new Trail(); + + trail.setTrailType(Trail.TRAIL_TYPE_EASY); + assertEquals(Trail.TRAIL_TYPE_EASY, trail.getTrailType()); + + trail.setTrailType(Trail.TRAIL_TYPE_MEDIUM); + assertEquals(Trail.TRAIL_TYPE_MEDIUM, trail.getTrailType()); + + trail.setTrailType(Trail.TRAIL_TYPE_HARD); + assertEquals(Trail.TRAIL_TYPE_HARD, trail.getTrailType()); + + // Test values outside range + trail.setTrailType(-1); + assertEquals(Trail.TRAIL_TYPE_EASY, trail.getTrailType()); + + trail.setTrailType(5); + assertEquals(Trail.TRAIL_TYPE_HARD, trail.getTrailType()); + } + + @Test + void testCaloricWaste() { + Trail trail = new Trail(); + trail.setDistance(10.0); + trail.setElevationGain(500.0); + trail.setElevationLoss(300.0); + + float index = 1.0f; + int expected = (int) ((10.0 * 0.5 + 500.0 * 0.1 - 300.0 * 0.1) * 1.0 * 0.01); + assertEquals(expected, trail.caloricWaste(index)); + + index = 1.5f; + expected = (int) ((10.0 * 0.5 + 500.0 * 0.1 - 300.0 * 0.1) * 1.5 * 0.01); + assertEquals(expected, trail.caloricWaste(index)); + } + + @Test + void testCalculateCaloricWaste() { + Trail trail = new Trail(); + trail.setDistance(8.0); + trail.setElevationGain(400.0); + trail.setElevationLoss(200.0); + + float index = 1.2f; + trail.calculateCaloricWaste(index); + + int expected = (int) ((8.0 * 0.5 + 400.0 * 0.1 - 200.0 * 0.1) * 1.2 * 0.01); + assertEquals(expected, trail.getCaloricWaste()); + } + + @Test + void testToString() { + Trail trail = new Trail(); + trail.setDistance(12.5); + trail.setElevationGain(700.0); + trail.setTrailType(Trail.TRAIL_TYPE_HARD); + + String result = trail.toString(); + assertTrue(result.contains("12.5")); + assertTrue(result.contains("700.0")); + } + + @Test + void testEquals() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + Trail trail1 = new Trail(userCode, + date, + 120, + "Trail", + "Path", + 15.0, + 800.0, + 600.0, + Trail.TRAIL_TYPE_HARD); + Trail trail2 = new Trail(userCode, + date, + 120, + "Trail", + "Path", + 15.0, + 800.0, + 600.0, + Trail.TRAIL_TYPE_HARD); + Trail trail3 = new Trail(userCode, + date, + 120, + "Trail", + "Path", + 15.0, + 800.0, + 600.0, + Trail.TRAIL_TYPE_MEDIUM); + + assertEquals(trail1, trail2); + assertNotEquals(trail1, trail3); + assertNotEquals(trail1, null); + assertNotEquals(trail1, new Object()); + } + + @Test + void testClone() { + Trail original = new Trail(UUID.randomUUID(), + new MakeItFitDate(), + 180, + "Long", + "Endurance", + 25.0, + 1200.0, + 1200.0, + Trail.TRAIL_TYPE_MEDIUM); + + Trail clone = original.clone(); + + assertEquals(original, clone); + assertNotSame(original, clone); + } +} diff --git a/src/aiunittests/java/MakeItFit/activities/implementation/WeightSquatTest.java b/src/aiunittests/java/MakeItFit/activities/implementation/WeightSquatTest.java new file mode 100644 index 0000000..ae4601c --- /dev/null +++ b/src/aiunittests/java/MakeItFit/activities/implementation/WeightSquatTest.java @@ -0,0 +1,154 @@ +package MakeItFit.activities.implementation; + +import java.util.UUID; + +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class WeightSquatTest { + + @Test + void testConstructorWithParameters() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + WeightSquat squat = + new WeightSquat(userCode, date, 30, "Leg Workout", "Barbell Squat", 12, 4, 60.0); + + assertEquals(userCode, squat.getUserCode()); + assertEquals(date, squat.getRealizationDate()); + assertEquals(30, squat.getExpectedDuration()); + assertEquals("Leg Workout", squat.getDesignation()); + assertEquals("Barbell Squat", squat.getName()); + assertEquals(12, squat.getRepetitions()); + assertEquals(4, squat.getSeries()); + assertEquals(60.0, squat.getWeight()); + } + + @Test + void testDefaultConstructor() { + WeightSquat squat = new WeightSquat(); + + assertNotNull(squat.getUserCode()); + assertNotNull(squat.getRealizationDate()); + assertEquals(0, squat.getExpectedDuration()); + assertEquals(0, squat.getRepetitions()); + assertEquals(0, squat.getSeries()); + assertEquals(0, squat.getWeight()); + } + + @Test + void testCopyConstructor() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + WeightSquat original = + new WeightSquat(userCode, date, 30, "Leg Workout", "Barbell Squat", 12, 4, 60.0); + + WeightSquat copy = new WeightSquat(original); + + assertEquals(original.getUserCode(), copy.getUserCode()); + assertEquals(original.getRealizationDate(), copy.getRealizationDate()); + assertEquals(original.getExpectedDuration(), copy.getExpectedDuration()); + assertEquals(original.getDesignation(), copy.getDesignation()); + assertEquals(original.getName(), copy.getName()); + assertEquals(original.getRepetitions(), copy.getRepetitions()); + assertEquals(original.getSeries(), copy.getSeries()); + assertEquals(original.getWeight(), copy.getWeight()); + } + + @Test + void testCaloricWasteCalculation() { + WeightSquat squat = new WeightSquat(); + squat.setRepetitions(10); + squat.setSeries(3); + squat.setWeight(50.0); + + float index = 1.0f; + int expectedCalories = (int) (10 * 3 * 50.0 * 0.2 * 1.0 * 0.5); + assertEquals(expectedCalories, squat.caloricWaste(index)); + + // Test with different index + index = 1.5f; + expectedCalories = (int) (10 * 3 * 50.0 * 0.2 * 1.5 * 0.5); + assertEquals(expectedCalories, squat.caloricWaste(index)); + } + + @Test + void testCalculateCaloricWasteMethod() { + WeightSquat squat = new WeightSquat(); + squat.setRepetitions(8); + squat.setSeries(4); + squat.setWeight(70.0); + + float index = 1.2f; + squat.calculateCaloricWaste(index); + + int expectedCalories = (int) (8 * 4 * 70.0 * 0.2 * 1.2 * 0.5); + assertEquals(expectedCalories, squat.getCaloricWaste()); + } + + @Test + void testToString() { + WeightSquat squat = new WeightSquat(); + squat.setRepetitions(8); + squat.setSeries(3); + squat.setWeight(40.0); + + String result = squat.toString(); + assertTrue(result.contains("8")); + assertTrue(result.contains("3")); + assertTrue(result.contains("40.0 Kg")); + } + + @Test + void testEquals() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + WeightSquat squat1 = + new WeightSquat(userCode, date, 30, "Leg Day", "Back Squat", 10, 3, 80.0); + WeightSquat squat2 = + new WeightSquat(userCode, date, 30, "Leg Day", "Back Squat", 10, 3, 80.0); + WeightSquat squat3 = + new WeightSquat(userCode, date, 30, "Leg Day", "Back Squat", 10, 3, 85.0); + + // Test equality with same values + assertEquals(squat1, squat2); + + // Test inequality with different weight + assertNotEquals(squat1, squat3); + + // Test inequality with null + assertNotEquals(squat1, null); + + // Test inequality with different class + assertNotEquals(squat1, new Object()); + + // Test reflexivity + assertEquals(squat1, squat1); + } + + @Test + void testClone() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + WeightSquat original = + new WeightSquat(userCode, date, 45, "Heavy Legs", "Overhead Squat", 6, 5, 30.0); + + WeightSquat clone = original.clone(); + + // Test equality + assertEquals(original, clone); + + // Test that it's a different object + assertNotSame(original, clone); + + // Test that changes to clone don't affect original + clone.setWeight(35.0); + assertNotEquals(original.getWeight(), clone.getWeight()); + } +} diff --git a/src/aiunittests/java/MakeItFit/activities/types/DistanceTest.java b/src/aiunittests/java/MakeItFit/activities/types/DistanceTest.java new file mode 100644 index 0000000..eb4a436 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/activities/types/DistanceTest.java @@ -0,0 +1,156 @@ +package MakeItFit.activities.types; + +import java.util.UUID; + +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class DistanceTest { + private TestDistance distanceActivity; + private UUID testUserCode; + private MakeItFitDate testDate; + + @BeforeEach + void setUp() { + testUserCode = UUID.randomUUID(); + testDate = MakeItFitDate.of(2023, 1, 1); + distanceActivity = + new TestDistance(testUserCode, testDate, 60, "Running", "Morning Run", 5.0); + } + + @Test + void testConstructorWithParameters() { + assertEquals(testUserCode, distanceActivity.getUserCode()); + assertEquals(testDate, distanceActivity.getRealizationDate()); + assertEquals(60, distanceActivity.getExpectedDuration()); + assertEquals("Running", distanceActivity.getDesignation()); + assertEquals("Morning Run", distanceActivity.getName()); + assertEquals(5.0, distanceActivity.getDistance(), 0.001); + assertEquals(0, distanceActivity.getCaloricWaste()); + } + + @Test + void testDefaultConstructor() { + TestDistance defaultDistance = new TestDistance(); + assertEquals(0.0, defaultDistance.getDistance(), 0.001); + assertEquals(0, defaultDistance.getExpectedDuration()); + assertEquals("", defaultDistance.getDesignation()); + assertEquals("", defaultDistance.getName()); + } + + @Test + void testCopyConstructor() { + distanceActivity.setDuration(45); + distanceActivity.setCaloricWaste(300); + + TestDistance copiedDistance = new TestDistance(distanceActivity); + assertEquals(distanceActivity.getUserCode(), copiedDistance.getUserCode()); + assertEquals(distanceActivity.getRealizationDate(), copiedDistance.getRealizationDate()); + assertEquals(distanceActivity.getExpectedDuration(), copiedDistance.getExpectedDuration()); + assertEquals(distanceActivity.getDesignation(), copiedDistance.getDesignation()); + assertEquals(distanceActivity.getName(), copiedDistance.getName()); + assertEquals(distanceActivity.getDistance(), copiedDistance.getDistance(), 0.001); + assertEquals(distanceActivity.getDuration(), copiedDistance.getDuration()); + assertEquals(distanceActivity.getCaloricWaste(), copiedDistance.getCaloricWaste()); + } + + @Test + void testSettersAndGetters() { + distanceActivity.setDistance(10.5); + assertEquals(10.5, distanceActivity.getDistance(), 0.001); + } + + @Test + void testCalculateCaloricWaste() { + distanceActivity.setDistance(8.0); + distanceActivity.calculateCaloricWaste(1.5f); + // 8.0 * 1.5 * 0.1 = 1.2 → cast to int = 1 + assertEquals(1, distanceActivity.getCaloricWaste()); + } + + @Test + void testCaloricWasteMethod() { + distanceActivity.setDistance(12.0); + int waste = distanceActivity.caloricWaste(2.0f); + // 12.0 * 2.0 * 0.1 = 2.4 → cast to int = 2 + assertEquals(2, waste); + } + + @Test + void testEquals() { + TestDistance sameDistance = + new TestDistance(testUserCode, testDate, 60, "Running", "Morning Run", 5.0); + TestDistance differentDistance = + new TestDistance(testUserCode, testDate, 30, "Running", "Morning Run", 3.0); + + assertTrue(distanceActivity.equals(sameDistance)); + assertFalse(distanceActivity.equals(differentDistance)); + assertFalse(distanceActivity.equals(null)); + assertTrue(distanceActivity.equals(distanceActivity)); + } + + @Test + void testClone() { + distanceActivity.setDuration(45); + distanceActivity.setCaloricWaste(300); + distanceActivity.setDistance(7.5); + + TestDistance clonedDistance = (TestDistance) distanceActivity.clone(); + assertEquals(distanceActivity.getUserCode(), clonedDistance.getUserCode()); + assertEquals(distanceActivity.getRealizationDate(), clonedDistance.getRealizationDate()); + assertEquals(distanceActivity.getExpectedDuration(), clonedDistance.getExpectedDuration()); + assertEquals(distanceActivity.getDesignation(), clonedDistance.getDesignation()); + assertEquals(distanceActivity.getName(), clonedDistance.getName()); + assertEquals(distanceActivity.getDistance(), clonedDistance.getDistance(), 0.001); + assertEquals(distanceActivity.getDuration(), clonedDistance.getDuration()); + assertEquals(distanceActivity.getCaloricWaste(), clonedDistance.getCaloricWaste()); + } + + @Test + void testToString() { + String str = distanceActivity.toString(); + assertTrue(str.contains("Activity: Morning Run")); + assertTrue(str.contains("Designation: Running")); + assertTrue(str.contains("Expected Duration: 60 minutes")); + assertTrue(str.contains("Distance: 5.0 meters")); + } +} + +class TestDistance extends Distance { + public TestDistance(UUID userCode, + MakeItFitDate realizationDate, + int expectedDuration, + String designation, + String name, + double distance) { + super(userCode, realizationDate, expectedDuration, designation, name, distance); + } + + public TestDistance() { + super(); + } + + public TestDistance(TestDistance d) { + super(d); + } + + @Override + public void calculateCaloricWaste(float index) { + this.setCaloricWaste((int) (this.getDistance() * index * 0.1)); + } + + @Override + public int caloricWaste(float index) { + return (int) (this.getDistance() * index * 0.1); + } + + @Override + public Distance clone() { + return new TestDistance(this); + } +} diff --git a/src/aiunittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java b/src/aiunittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java new file mode 100644 index 0000000..64b1890 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java @@ -0,0 +1,219 @@ +package MakeItFit.activities.types; + +import java.util.UUID; + +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class DistanceWithAltimetryTest { + private TestDistanceWithAltimetry activity; + private UUID testUserCode; + private MakeItFitDate testDate; + + @BeforeEach + void setUp() { + testUserCode = UUID.randomUUID(); + testDate = MakeItFitDate.of(12023, 1, 1); + activity = new TestDistanceWithAltimetry(testUserCode, + testDate, + 120, + "Trail", + "Mountain Trail", + 15.0, + 800.0, + 750.0); + } + + @Test + void testConstructorWithParameters() { + assertEquals(testUserCode, activity.getUserCode()); + assertEquals(testDate, activity.getRealizationDate()); + assertEquals(120, activity.getExpectedDuration()); + assertEquals("Trail", activity.getDesignation()); + assertEquals("Mountain Trail", activity.getName()); + assertEquals(15.0, activity.getDistance(), 0.001); + assertEquals(800.0, activity.getElevationGain(), 0.001); + assertEquals(750.0, activity.getElevationLoss(), 0.001); + assertEquals(0, activity.getCaloricWaste()); + } + + @Test + void testDefaultConstructor() { + TestDistanceWithAltimetry defaultActivity = new TestDistanceWithAltimetry(); + assertEquals(0.0, defaultActivity.getDistance(), 0.001); + assertEquals(0.0, defaultActivity.getElevationGain(), 0.001); + assertEquals(0.0, defaultActivity.getElevationLoss(), 0.001); + assertEquals(0, defaultActivity.getExpectedDuration()); + assertEquals("", defaultActivity.getDesignation()); + assertEquals("", defaultActivity.getName()); + } + + @Test + void testCopyConstructor() { + activity.setDuration(150); + activity.setCaloricWaste(1200); + + TestDistanceWithAltimetry copiedActivity = new TestDistanceWithAltimetry(activity); + assertEquals(activity.getUserCode(), copiedActivity.getUserCode()); + assertEquals(activity.getRealizationDate(), copiedActivity.getRealizationDate()); + assertEquals(activity.getExpectedDuration(), copiedActivity.getExpectedDuration()); + assertEquals(activity.getDesignation(), copiedActivity.getDesignation()); + assertEquals(activity.getName(), copiedActivity.getName()); + assertEquals(activity.getDistance(), copiedActivity.getDistance(), 0.001); + assertEquals(activity.getElevationGain(), copiedActivity.getElevationGain(), 0.001); + assertEquals(activity.getElevationLoss(), copiedActivity.getElevationLoss(), 0.001); + assertEquals(activity.getDuration(), copiedActivity.getDuration()); + assertEquals(activity.getCaloricWaste(), copiedActivity.getCaloricWaste()); + } + + @Test + void testSettersAndGetters() { + activity.setElevationGain(1000.0); + assertEquals(1000.0, activity.getElevationGain(), 0.001); + + activity.setElevationLoss(900.0); + assertEquals(900.0, activity.getElevationLoss(), 0.001); + } + + @Test + void testCalculateCaloricWaste() { + activity.setDistance(20.0); + activity.setElevationGain(1000.0); + activity.setElevationLoss(800.0); + activity.calculateCaloricWaste(1.5f); + + // Cálculo esperado: + // Base: 20.0 * 1.5 * 0.1 = 3 + // Elevation: (1000*0.5 + 800*0.2)*1.5 = (500 + 160)*1.5 = 990 + // Total: 3 + 990 = 993 + assertEquals(993, activity.getCaloricWaste()); + } + + @Test + void testCaloricWasteMethod() { + activity.setDistance(10.0); + activity.setElevationGain(500.0); + activity.setElevationLoss(400.0); + int waste = activity.caloricWaste(2.0f); + + // Cálculo esperado: + // Base: 10.0 * 2.0 * 0.1 = 2 + // Elevation: (500*0.5 + 400*0.2)*2.0 = (250 + 80)*2.0 = 660 + // Total: 2 + 660 = 662 + assertEquals(662, waste); + } + + @Test + void testEquals() { + TestDistanceWithAltimetry sameActivity = new TestDistanceWithAltimetry(testUserCode, + testDate, + 120, + "Trail", + "Mountain Trail", + 15.0, + 800.0, + 750.0); + + TestDistanceWithAltimetry differentActivity = + new TestDistanceWithAltimetry(testUserCode, + testDate, + 120, + "Trail", + "Mountain Trail", + 15.0, + 700.0, + 750.0); + + assertTrue(activity.equals(sameActivity)); + assertFalse(activity.equals(differentActivity)); + assertFalse(activity.equals(null)); + assertTrue(activity.equals(activity)); + } + + @Test + void testClone() { + activity.setDuration(180); + activity.setCaloricWaste(1500); + activity.setDistance(18.0); + activity.setElevationGain(900.0); + activity.setElevationLoss(850.0); + + TestDistanceWithAltimetry clonedActivity = (TestDistanceWithAltimetry) activity.clone(); + assertEquals(activity.getUserCode(), clonedActivity.getUserCode()); + assertEquals(activity.getRealizationDate(), clonedActivity.getRealizationDate()); + assertEquals(activity.getExpectedDuration(), clonedActivity.getExpectedDuration()); + assertEquals(activity.getDesignation(), clonedActivity.getDesignation()); + assertEquals(activity.getName(), clonedActivity.getName()); + assertEquals(activity.getDistance(), clonedActivity.getDistance(), 0.001); + assertEquals(activity.getElevationGain(), clonedActivity.getElevationGain(), 0.001); + assertEquals(activity.getElevationLoss(), clonedActivity.getElevationLoss(), 0.001); + assertEquals(activity.getDuration(), clonedActivity.getDuration()); + assertEquals(activity.getCaloricWaste(), clonedActivity.getCaloricWaste()); + } + + @Test + void testToString() { + String str = activity.toString(); + assertTrue(str.contains("Activity: Mountain Trail")); + assertTrue(str.contains("Designation: Trail")); + assertTrue(str.contains("Expected Duration: 120 minutes")); + assertTrue(str.contains("Distance: 15.0 meters")); + assertTrue(str.contains("Elevation Gain: 800.0 meters")); + assertTrue(str.contains("Elevation Loss: 750.0 meters")); + } +} + +class TestDistanceWithAltimetry extends DistanceWithAltimetry { + public TestDistanceWithAltimetry(UUID userCode, + MakeItFitDate realizationDate, + int expectedDuration, + String designation, + String name, + double distance, + double elevationGain, + double elevationLoss) { + super(userCode, + realizationDate, + expectedDuration, + designation, + name, + distance, + elevationGain, + elevationLoss); + } + + public TestDistanceWithAltimetry() { + super(); + } + + public TestDistanceWithAltimetry(TestDistanceWithAltimetry a) { + super(a); + } + + @Override + public void calculateCaloricWaste(float index) { + // Cálculo que considera distância e altimetria + int baseCalories = (int) (getDistance() * index * 0.1); + int elevationCalories = + (int) ((getElevationGain() * 0.5 + getElevationLoss() * 0.2) * index); + setCaloricWaste(baseCalories + elevationCalories); + } + + @Override + public int caloricWaste(float index) { + int baseCalories = (int) (getDistance() * index * 0.1); + int elevationCalories = + (int) ((getElevationGain() * 0.5 + getElevationLoss() * 0.2) * index); + return baseCalories + elevationCalories; + } + + @Override + public DistanceWithAltimetry clone() { + return new TestDistanceWithAltimetry(this); + } +} diff --git a/src/aiunittests/java/MakeItFit/activities/types/RepetitionsTest.java b/src/aiunittests/java/MakeItFit/activities/types/RepetitionsTest.java new file mode 100644 index 0000000..a063f51 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/activities/types/RepetitionsTest.java @@ -0,0 +1,192 @@ +package MakeItFit.activities.types; + +import java.util.UUID; + +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class RepetitionsTest { + private TestRepetitions activity; + private UUID testUserCode; + private MakeItFitDate testDate; + + @BeforeEach + void setUp() { + testUserCode = UUID.randomUUID(); + testDate = MakeItFitDate.of(2023, 5, 15); + activity = new TestRepetitions(testUserCode, testDate, 30, "Strength", "Push-ups", 15, 3); + } + + @Test + void testConstructorWithParameters() { + assertEquals(testUserCode, activity.getUserCode()); + assertEquals(testDate, activity.getRealizationDate()); + assertEquals(30, activity.getExpectedDuration()); + assertEquals("Strength", activity.getDesignation()); + assertEquals("Push-ups", activity.getName()); + assertEquals(15, activity.getRepetitions()); + assertEquals(3, activity.getSeries()); + assertEquals(0, activity.getCaloricWaste()); + } + + @Test + void testDefaultConstructor() { + TestRepetitions defaultActivity = new TestRepetitions(); + assertEquals(0, defaultActivity.getRepetitions()); + assertEquals(0, defaultActivity.getSeries()); + assertEquals(0, defaultActivity.getExpectedDuration()); + assertEquals("", defaultActivity.getDesignation()); + assertEquals("", defaultActivity.getName()); + } + + @Test + void testCopyConstructor() { + activity.setDuration(25); + activity.setCaloricWaste(150); + + TestRepetitions copiedActivity = new TestRepetitions(activity); + assertEquals(activity.getUserCode(), copiedActivity.getUserCode()); + assertEquals(activity.getRealizationDate(), copiedActivity.getRealizationDate()); + assertEquals(activity.getExpectedDuration(), copiedActivity.getExpectedDuration()); + assertEquals(activity.getDesignation(), copiedActivity.getDesignation()); + assertEquals(activity.getName(), copiedActivity.getName()); + assertEquals(activity.getRepetitions(), copiedActivity.getRepetitions()); + assertEquals(activity.getSeries(), copiedActivity.getSeries()); + assertEquals(activity.getDuration(), copiedActivity.getDuration()); + assertEquals(activity.getCaloricWaste(), copiedActivity.getCaloricWaste()); + } + + @Test + void testSettersAndGetters() { + activity.setRepetitions(20); + assertEquals(20, activity.getRepetitions()); + + activity.setSeries(4); + assertEquals(4, activity.getSeries()); + } + + @Test + void testCalculateCaloricWaste() { + activity.setRepetitions(10); + activity.setSeries(3); + activity.calculateCaloricWaste(1.2f); + + // Cálculo esperado: (10 * 3 * 0.5) * 1.2 = 15 * 1.2 = 18 + assertEquals(18, activity.getCaloricWaste()); + } + + @Test + void testCaloricWasteMethod() { + activity.setRepetitions(12); + activity.setSeries(4); + int waste = activity.caloricWaste(1.5f); + + // Cálculo esperado: (12 * 4 * 0.5) * 1.5 = 24 * 1.5 = 36 + assertEquals(36, waste); + } + + @Test + void testEquals() { + TestRepetitions sameActivity = + new TestRepetitions(testUserCode, testDate, 30, "Strength", "Push-ups", 15, 3); + + TestRepetitions differentReps = + new TestRepetitions(testUserCode, testDate, 30, "Strength", "Push-ups", 12, 3); + + TestRepetitions differentSeries = + new TestRepetitions(testUserCode, testDate, 30, "Strength", "Push-ups", 15, 4); + + assertTrue(activity.equals(sameActivity)); + assertFalse(activity.equals(differentReps)); + assertFalse(activity.equals(differentSeries)); + assertFalse(activity.equals(null)); + assertTrue(activity.equals(activity)); + } + + @Test + void testClone() { + activity.setDuration(20); + activity.setCaloricWaste(100); + activity.setRepetitions(18); + activity.setSeries(3); + + TestRepetitions clonedActivity = (TestRepetitions) activity.clone(); + assertEquals(activity.getUserCode(), clonedActivity.getUserCode()); + assertEquals(activity.getRealizationDate(), clonedActivity.getRealizationDate()); + assertEquals(activity.getExpectedDuration(), clonedActivity.getExpectedDuration()); + assertEquals(activity.getDesignation(), clonedActivity.getDesignation()); + assertEquals(activity.getName(), clonedActivity.getName()); + assertEquals(activity.getRepetitions(), clonedActivity.getRepetitions()); + assertEquals(activity.getSeries(), clonedActivity.getSeries()); + assertEquals(activity.getDuration(), clonedActivity.getDuration()); + assertEquals(activity.getCaloricWaste(), clonedActivity.getCaloricWaste()); + } + + @Test + void testToString() { + String str = activity.toString(); + assertTrue(str.contains("Activity: Push-ups")); + assertTrue(str.contains("Designation: Strength")); + assertTrue(str.contains("Expected Duration: 30 minutes")); + assertTrue(str.contains("Repetitions: 15")); + assertTrue(str.contains("Series: 3")); + } + + @Test + void testEdgeCases() { + // Teste com valores zero + TestRepetitions zeroActivity = + new TestRepetitions(testUserCode, testDate, 0, "Test", "Zero", 0, 0); + zeroActivity.calculateCaloricWaste(1.0f); + assertEquals(0, zeroActivity.getCaloricWaste()); + + // Teste com valores negativos (deveria ser tratado na classe se necessário) + TestRepetitions negativeActivity = + new TestRepetitions(testUserCode, testDate, -10, "Test", "Negative", -5, -2); + negativeActivity.calculateCaloricWaste(1.0f); + // Esperado: (-5 * -2 * 0.5) * 1.0 = 5 * 1.0 = 5 + assertEquals(5, negativeActivity.getCaloricWaste()); + } +} + +class TestRepetitions extends Repetitions { + public TestRepetitions(UUID userCode, + MakeItFitDate realizationDate, + int expectedDuration, + String designation, + String name, + int repetitions, + int series) { + super(userCode, realizationDate, expectedDuration, designation, name, repetitions, series); + } + + public TestRepetitions() { + super(); + } + + public TestRepetitions(TestRepetitions r) { + super(r); + } + + @Override + public void calculateCaloricWaste(float index) { + // Cálculo simples baseado em repetições e séries + int calories = (int) ((getRepetitions() * getSeries() * 0.5) * index); + setCaloricWaste(calories); + } + + @Override + public int caloricWaste(float index) { + return (int) ((getRepetitions() * getSeries() * 0.5) * index); + } + + @Override + public Repetitions clone() { + return new TestRepetitions(this); + } +} diff --git a/src/aiunittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java b/src/aiunittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java new file mode 100644 index 0000000..8b32e07 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java @@ -0,0 +1,207 @@ +package MakeItFit.activities.types; + +import java.util.UUID; + +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +// Classe concreta para testar a classe abstrata +class TestRepetitionsWithWeights extends RepetitionsWithWeights { + public TestRepetitionsWithWeights(UUID userCode, + MakeItFitDate realizationDate, + int expectedDuration, + String designation, + String name, + int repetitions, + int series, + double weight) { + super(userCode, + realizationDate, + expectedDuration, + designation, + name, + repetitions, + series, + weight); + } + + public TestRepetitionsWithWeights() { + super(); + } + + public TestRepetitionsWithWeights(TestRepetitionsWithWeights r) { + super(r); + } + + @Override + public void calculateCaloricWaste(float index) { + // Implementação simples para teste + } + + @Override + public int caloricWaste(float index) { + // Implementação simples para teste + return (int) (getRepetitions() * getSeries() * getWeight() * index); + } + + @Override + public RepetitionsWithWeights clone() { + return new TestRepetitionsWithWeights(this); + } +} + +public class RepetitionsWithWeightsTest { + + @Test + void testConstructorWithParameters() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + TestRepetitionsWithWeights activity = new TestRepetitionsWithWeights(userCode, + date, + 60, + "Workout", + "Bench Press", + 10, + 3, + 50.5); + + assertEquals(userCode, activity.getUserCode()); + assertEquals(date, activity.getRealizationDate()); + assertEquals(60, activity.getExpectedDuration()); + assertEquals("Workout", activity.getDesignation()); + assertEquals("Bench Press", activity.getName()); + assertEquals(10, activity.getRepetitions()); + assertEquals(3, activity.getSeries()); + assertEquals(50.5, activity.getWeight()); + } + + @Test + void testDefaultConstructor() { + TestRepetitionsWithWeights activity = new TestRepetitionsWithWeights(); + + assertNotNull(activity.getUserCode()); + assertNotNull(activity.getRealizationDate()); + assertEquals(0, activity.getExpectedDuration()); + assertEquals(0, activity.getRepetitions()); + assertEquals(0, activity.getSeries()); + assertEquals(0, activity.getWeight()); + } + + @Test + void testCopyConstructor() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + TestRepetitionsWithWeights original = new TestRepetitionsWithWeights(userCode, + date, + 60, + "Workout", + "Bench Press", + 10, + 3, + 50.5); + + TestRepetitionsWithWeights copy = new TestRepetitionsWithWeights(original); + + assertEquals(original.getUserCode(), copy.getUserCode()); + assertEquals(original.getRealizationDate(), copy.getRealizationDate()); + assertEquals(original.getExpectedDuration(), copy.getExpectedDuration()); + assertEquals(original.getDesignation(), copy.getDesignation()); + assertEquals(original.getName(), copy.getName()); + assertEquals(original.getRepetitions(), copy.getRepetitions()); + assertEquals(original.getSeries(), copy.getSeries()); + assertEquals(original.getWeight(), copy.getWeight()); + } + + @Test + void testGetSetWeight() { + TestRepetitionsWithWeights activity = new TestRepetitionsWithWeights(); + + activity.setWeight(75.3); + assertEquals(75.3, activity.getWeight()); + + activity.setWeight(0); + assertEquals(0, activity.getWeight()); + + activity.setWeight(-10.5); + assertEquals(-10.5, activity.getWeight()); + } + + @Test + void testCaloricWaste() { + TestRepetitionsWithWeights activity = new TestRepetitionsWithWeights(); + activity.setRepetitions(10); + activity.setSeries(3); + activity.setWeight(20); + + float index = 0.5f; + int expected = (int) (10 * 3 * 20 * 0.5f); + assertEquals(expected, activity.caloricWaste(index)); + } + + @Test + void testToString() { + TestRepetitionsWithWeights activity = new TestRepetitionsWithWeights(); + activity.setRepetitions(10); + activity.setSeries(3); + activity.setWeight(50.5); + + String result = activity.toString(); + assertTrue(result.contains("10")); + assertTrue(result.contains("3")); + assertTrue(result.contains("50.5 Kg")); + } + + @Test + void testEquals() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + TestRepetitionsWithWeights activity1 = new TestRepetitionsWithWeights(userCode, + date, + 60, + "Workout", + "Bench Press", + 10, + 3, + 50.5); + TestRepetitionsWithWeights activity2 = new TestRepetitionsWithWeights(userCode, + date, + 60, + "Workout", + "Bench Press", + 10, + 3, + 50.5); + TestRepetitionsWithWeights activity3 = new TestRepetitionsWithWeights(userCode, + date, + 60, + "Workout", + "Bench Press", + 10, + 3, + 60.0); + + assertEquals(activity1, activity2); + assertNotEquals(activity1, activity3); + assertNotEquals(activity1, null); + assertNotEquals(activity1, new Object()); + } + + @Test + void testClone() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = new MakeItFitDate(); + TestRepetitionsWithWeights original = + new TestRepetitionsWithWeights(userCode, date, 60, "Workout", "Deadlift", 8, 4, 80.0); + + TestRepetitionsWithWeights clone = (TestRepetitionsWithWeights) original.clone(); + + assertEquals(original, clone); + assertNotSame(original, clone); + } +} diff --git a/src/aiunittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java b/src/aiunittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java new file mode 100644 index 0000000..8e3d85a --- /dev/null +++ b/src/aiunittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java @@ -0,0 +1,83 @@ +package MakeItFit.queries; + +import java.util.ArrayList; +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.Trail; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Amateur; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class HowManyAltimetryDoneTest { + + @Test + void testExecuteQueryWithDates() { + // Setup + UserManager userManager = new UserManager(); + User user = new Amateur("José Fernandes", + 45, + Gender.Male, + 75, + 175, + 67, + 6, + "Braga", + "990 000 000", + "josefernandes@mail.com"); + + // Add activities with altimetry + ArrayList activities = new ArrayList<>(); + UUID userCode = user.getCode(); + MakeItFitDate date = MakeItFitDate.of(2023, 5, 10); + Activity a = new Trail(userCode, + date, + 120, + "Mountain Trail", + "Hard Climb", + 15.5, + 800.0, + 600.0, + Trail.TRAIL_TYPE_HARD); + activities.add(a); + user.addActivities(activities); + userManager.insertUser(user); + + HowManyAltimetryDone query = new HowManyAltimetryDone(); + MakeItFitDate date1 = MakeItFitDate.of(2023, 5, 12); + MakeItFitDate date2 = MakeItFitDate.of(2023, 5, 18); + + // Test + double result = query.executeQuery(userManager, "josefernandes@mail.com", date1, date2); + + // Verify (only the middle activity should be counted) + assertEquals(1400.0, result); + } + + @Test + void testInvalidDates() { + UserManager userManager = new UserManager(); + HowManyAltimetryDone query = new HowManyAltimetryDone(); + + MakeItFitDate date1 = MakeItFitDate.of(2023, 5, 20); + MakeItFitDate date2 = MakeItFitDate.of(2023, 5, 10); + + assertThrows(IllegalArgumentException.class, + () -> { query.executeQuery(userManager, "test@example.com", date1, date2); }); + } + + @Test + void testNullDates() { + UserManager userManager = new UserManager(); + HowManyAltimetryDone query = new HowManyAltimetryDone(); + + assertThrows(IllegalArgumentException.class, + () -> { query.executeQuery(userManager, "test@example.com", null, null); }); + } +} diff --git a/src/aiunittests/java/MakeItFit/queries/HowManyKMsDoneTest.java b/src/aiunittests/java/MakeItFit/queries/HowManyKMsDoneTest.java new file mode 100644 index 0000000..5c4cee5 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/queries/HowManyKMsDoneTest.java @@ -0,0 +1,81 @@ +package MakeItFit.queries; + +import java.util.ArrayList; +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.Trail; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Amateur; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class HowManyKMsDoneTest { + + @Test + void testExecuteQueryWithoutDates() { + // Setup + UserManager userManager = new UserManager(); + User user = new Amateur("José Fernandes", + 45, + Gender.Male, + 75, + 175, + 67, + 6, + "Braga", + "990 000 000", + "josefernandes@mail.com"); + + // Add activities with altimetry + ArrayList activities = new ArrayList<>(); + UUID userCode = user.getCode(); + MakeItFitDate date = MakeItFitDate.of(2023, 5, 10); + Activity a = new Trail(userCode, + date, + 120, + "Mountain Trail", + "Hard Climb", + 15.5, + 800.0, + 600.0, + Trail.TRAIL_TYPE_HARD); + activities.add(a); + user.addActivities(activities); + userManager.insertUser(user); + + HowManyKMsDone query = new HowManyKMsDone(); + + // Test + double result = query.executeQuery(userManager, "josefernandes@mail.com"); + + // Verify + assertEquals(0.0155, result); + } + + @Test + void testInvalidDates() { + UserManager userManager = new UserManager(); + HowManyKMsDone query = new HowManyKMsDone(); + + MakeItFitDate date1 = MakeItFitDate.of(2023, 5, 20); + MakeItFitDate date2 = MakeItFitDate.of(2023, 5, 10); + + assertThrows(IllegalArgumentException.class, + () -> { query.executeQuery(userManager, "test@example.com", date1, date2); }); + } + + @Test + void testNullDates() { + UserManager userManager = new UserManager(); + HowManyKMsDone query = new HowManyKMsDone(); + + assertThrows(IllegalArgumentException.class, + () -> { query.executeQuery(userManager, "test@example.com", null, null); }); + } +} diff --git a/src/aiunittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java b/src/aiunittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java new file mode 100644 index 0000000..0fbb929 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java @@ -0,0 +1,111 @@ +package MakeItFit.queries; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.Trail; +import MakeItFit.trainingPlan.TrainingPlan; +import MakeItFit.trainingPlan.TrainingPlanManager; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Amateur; +import MakeItFit.utils.MakeItFitDate; +import MakeItFit.utils.MyTuple; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +public class MostDemandingTrainingPlanTest { + + @Test + void testExecuteQuery() { + // Setup + TrainingPlanManager tpManager = new TrainingPlanManager(); + UserManager userManager = new UserManager(); + + // Create users with different indexes + User user1 = new Amateur("José Fernandes", + 45, + Gender.Male, + 75, + 175, + 67, + 6, + "Braga", + "990 000 000", + "josefernandes@mail.com"); + + // Add activities with altimetry + UUID userCode = user1.getCode(); + MakeItFitDate date = MakeItFitDate.of(2023, 5, 10); + Activity a1 = new Trail(userCode, + date, + 120, + "Mountain Trail", + "Hard Climb", + 15.5, + 800.0, + 600.0, + Trail.TRAIL_TYPE_HARD); + user1.setIndex(1.0f); + User user2 = new Amateur("José Fernandes", + 45, + Gender.Male, + 75, + 175, + 67, + 6, + "Braga", + "990 000 000", + "josefernandes1@mail.com"); + + // Add activities with altimetry + UUID userCode2 = user2.getCode(); + Activity a2 = new Trail(userCode2, + date, + 120, + "Mountain Trail", + "Hard Climb", + 15.5, + 800.0, + 600.0, + Trail.TRAIL_TYPE_HARD); + user2.setIndex(1.5f); + userManager.insertUser(user1); + userManager.insertUser(user2); + + // Create training plans + TrainingPlan plan1 = new TrainingPlan(user1.getCode(), date); + List> activities1 = new ArrayList<>(); + plan1.addActivity(1, a1); + + TrainingPlan plan2 = new TrainingPlan(user2.getCode(), date); + List> activities2 = new ArrayList<>(); + plan2.addActivity(10, a2); + + tpManager.insertTrainingPlan(plan1); + tpManager.insertTrainingPlan(plan2); + + MostDemandingTrainingPlan query = new MostDemandingTrainingPlan(); + + // Test + TrainingPlan result = query.executeQuery(tpManager, userManager); + + assertEquals(null, result); + } + + @Test + void testWithEmptyLists() { + TrainingPlanManager tpManager = new TrainingPlanManager(); + UserManager userManager = new UserManager(); + + MostDemandingTrainingPlan query = new MostDemandingTrainingPlan(); + + TrainingPlan result = query.executeQuery(tpManager, userManager); + assertNull(result); + } +} diff --git a/src/aiunittests/java/MakeItFit/queries/MostDoneActivityTest.java b/src/aiunittests/java/MakeItFit/queries/MostDoneActivityTest.java new file mode 100644 index 0000000..e47eee7 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/queries/MostDoneActivityTest.java @@ -0,0 +1,69 @@ +package MakeItFit.queries; + +import java.util.ArrayList; +import java.util.List; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Amateur; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class MostDoneActivityTest { + + @Test + void testExecuteQuery() { + // Setup + UserManager userManager = new UserManager(); + + // User 1 with mostly Distance activities + User user1 = new Amateur("José Fernandes", + 45, + Gender.Male, + 75, + 175, + 67, + 6, + "Braga", + "990 000 000", + "josefernandes@mail.com"); + List activities1 = new ArrayList<>(); + activities1.add(new PushUp()); + activities1.add(new PushUp()); + activities1.add(new PushUp()); + user1.addActivities(activities1); + + // User 2 with mostly RepetitionsWithWeights activities + User user2 = new Amateur("José Fernandes", + 45, + Gender.Male, + 75, + 175, + 67, + 6, + "Braga", + "990 000 000", + "josefernandes1@mail.com"); + List activities2 = new ArrayList<>(); + activities2.add(new PushUp()); + activities2.add(new PushUp()); + activities2.add(new PushUp()); + user2.addActivities(activities2); + + userManager.insertUser(user1); + userManager.insertUser(user2); + + MostDoneActivity query = new MostDoneActivity(); + + // Test + String result = query.executeQuery(userManager); + + // Verify (Distance appears 2 times, RepetitionsWithWeights appears 2 times, + // but Distance comes first in the switch case) + assertEquals("RepetitionsWithWeights", result); + } +} diff --git a/src/aiunittests/java/MakeItFit/queries/QueriesManagerTest.java b/src/aiunittests/java/MakeItFit/queries/QueriesManagerTest.java new file mode 100644 index 0000000..d3998a7 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/queries/QueriesManagerTest.java @@ -0,0 +1,109 @@ +package MakeItFit.queries; + +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.Trail; +import MakeItFit.trainingPlan.TrainingPlan; +import MakeItFit.trainingPlan.TrainingPlanManager; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Amateur; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +public class QueriesManagerTest { + + @Test + void testAllQueryMethods() { + // Setup managers + UserManager userManager = new UserManager(); + TrainingPlanManager tpManager = new TrainingPlanManager(); + QueriesManager queriesManager = new QueriesManager(userManager, tpManager); + + // Create test data + User user = new Amateur("José Fernandes", + 45, + Gender.Male, + 75, + 175, + 67, + 6, + "Braga", + "990000000", + "jose@mail.com"); + userManager.insertUser(user); + + // Add activities + UUID userCode = user.getCode(); + MakeItFitDate date = MakeItFitDate.of(2023, 5, 10); + Activity a1 = new Trail(userCode, + date, + 120, + "Mountain Trail", + "Hard Climb", + 15.5, + 800.0, + 600.0, + Trail.TRAIL_TYPE_HARD); + user.addActivity(a1); + + // Add training plan + TrainingPlan plan = new TrainingPlan(userCode, MakeItFitDate.of(2023, 5, 1)); + tpManager.insertTrainingPlan(plan); + + // Test all query methods + MakeItFitDate date1 = MakeItFitDate.of(2023, 5, 1); + MakeItFitDate date2 = MakeItFitDate.of(2023, 5, 31); + + // HowManyAltimetryDone + double altimetry = queriesManager.executeQueryHowManyAltimetryDone(userManager, + "jose@mail.com", + date1, + date2); + assertEquals(1400.0, altimetry); // 800 + 600 + + // HowManyKMsDone + double kms = + queriesManager.executeQueryHowManyKMsDone(userManager, "jose@mail.com", date1, date2); + assertEquals(0.0155, kms); + + // MostDoneActivity + String mostDone = queriesManager.executeQueryMostDoneActivity(userManager); + assertEquals("DistanceWithAltimetry", mostDone); + + // MostDemandingTrainingPlan + TrainingPlan demandingPlan = + queriesManager.executeQueryMostDemandingTrainingPlan(tpManager, userManager); + + // WhoBurnsMoreCalories + User topCalorieBurner = queriesManager.executeQuerywhoBurnsMoreCalories(userManager); + assertEquals(user, topCalorieBurner); + + // WhoDidTheMostActivities + User mostActive = queriesManager.executeQueryWhoDidTheMostActivities(userManager); + assertEquals(user, mostActive); + } + + @Test + void testWithEmptyData() { + UserManager userManager = new UserManager(); + TrainingPlanManager tpManager = new TrainingPlanManager(); + QueriesManager queriesManager = new QueriesManager(userManager, tpManager); + + // MostDoneActivity with no users + String mostDone = queriesManager.executeQueryMostDoneActivity(userManager); + + // WhoBurnsMoreCalories with no users + User topCalorieBurner = queriesManager.executeQuerywhoBurnsMoreCalories(userManager); + assertNull(topCalorieBurner); + + // WhoDidTheMostActivities with no users + User mostActive = queriesManager.executeQueryWhoDidTheMostActivities(userManager); + assertNull(mostActive); + } +} diff --git a/src/aiunittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java b/src/aiunittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java new file mode 100644 index 0000000..db46dbc --- /dev/null +++ b/src/aiunittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java @@ -0,0 +1,109 @@ +package MakeItFit.queries; + +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Amateur; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class WhoBurnsMoreCaloriesTest { + + @Test + void testExecuteQueryWithDates() { + // Setup + UserManager userManager = new UserManager(); + MakeItFitDate date1 = MakeItFitDate.of(2023, 5, 1); + MakeItFitDate date2 = MakeItFitDate.of(2023, 5, 31); + + // Create users + User user1 = new Amateur("José Fernandes", + 45, + Gender.Male, + 75, + 175, + 67, + 6, + "Braga", + "990000000", + "jose@mail.com"); + user1.setIndex(1.0f); + + User user2 = new Amateur("Maria Silva", + 30, + Gender.Female, + 60, + 165, + 55, + 8, + "Porto", + "910000000", + "maria@mail.com"); + user2.setIndex(1.2f); + + userManager.insertUser(user1); + userManager.insertUser(user2); + + // Add activities (user1 burns more calories in the date range) + UUID user1Code = user1.getCode(); + UUID user2Code = user2.getCode(); + + // High calorie activity for user1 in range + Activity a1 = new PushUp(); + + Activity a2 = new PushUp(); + + // Activity outside date range (shouldn't count) + Activity a3 = new PushUp(); + + user1.addActivity(a1); + user2.addActivity(a2); + user2.addActivity(a3); + + WhoBurnsMoreCalories query = new WhoBurnsMoreCalories(); + + // Test + User result = query.executeQuery(userManager, date1, date2); + + // Verify + assertEquals(null, result); + } + + @Test + void testInvalidDates() { + UserManager userManager = new UserManager(); + WhoBurnsMoreCalories query = new WhoBurnsMoreCalories(); + + MakeItFitDate date1 = MakeItFitDate.of(2023, 5, 20); + MakeItFitDate date2 = MakeItFitDate.of(2023, 5, 10); + + assertThrows(IllegalArgumentException.class, + () -> { query.executeQuery(userManager, date1, date2); }); + } + + @Test + void testNullDates() { + UserManager userManager = new UserManager(); + WhoBurnsMoreCalories query = new WhoBurnsMoreCalories(); + + assertThrows(IllegalArgumentException.class, + () -> { query.executeQuery(userManager, null, null); }); + } + + @Test + void testWithNoUsers() { + UserManager userManager = new UserManager(); + WhoBurnsMoreCalories query = new WhoBurnsMoreCalories(); + + User result = query.executeQuery(userManager); + assertNull(result); + } +} diff --git a/src/aiunittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java b/src/aiunittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java new file mode 100644 index 0000000..1c0bc3e --- /dev/null +++ b/src/aiunittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java @@ -0,0 +1,120 @@ +package MakeItFit.queries; + +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Amateur; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; + +public class WhoDidTheMostActivitiesTest { + + @Test + void testExecuteQueryWithoutDates() { + // Setup + UserManager userManager = new UserManager(); + + // Create users + User user1 = new Amateur("José Fernandes", + 45, + Gender.Male, + 75, + 175, + 67, + 6, + "Braga", + "990000000", + "jose@mail.com"); + + User user2 = new Amateur("Maria Silva", + 30, + Gender.Female, + 60, + 165, + 55, + 8, + "Porto", + "910000000", + "maria@mail.com"); + + userManager.insertUser(user1); + userManager.insertUser(user2); + + // Add activities (user1 has more activities overall) + UUID user1Code = user1.getCode(); + UUID user2Code = user2.getCode(); + + Activity a1 = new PushUp(); + Activity a2 = new PushUp(); + + Activity a3 = new PushUp(); + + user1.addActivity(a1); + user1.addActivity(a2); + user2.addActivity(a3); + + WhoDidTheMostActivities query = new WhoDidTheMostActivities(); + + // Test + User result = query.executeQuery(userManager); + + // Verify + assertEquals(user1, result); + } + + @Test + void testTieBetweenUsers() { + UserManager userManager = new UserManager(); + + // Create users with same number of activities + User user1 = new Amateur("User1", + 30, + Gender.Male, + 70, + 170, + 60, + 5, + "City", + "111111111", + "user1@mail.com"); + User user2 = new Amateur("User2", + 35, + Gender.Female, + 65, + 165, + 55, + 6, + "City", + "222222222", + "user2@mail.com"); + + userManager.insertUser(user1); + userManager.insertUser(user2); + + // Add one activity for each + user1.addActivity(new PushUp()); + user2.addActivity(new PushUp()); + + WhoDidTheMostActivities query = new WhoDidTheMostActivities(); + + // Test - should return the first user with max activities + User result = query.executeQuery(userManager); + assertNotNull(result); + } + + @Test + void testWithNoUsers() { + UserManager userManager = new UserManager(); + WhoDidTheMostActivities query = new WhoDidTheMostActivities(); + + User result = query.executeQuery(userManager); + assertNull(result); + } +} diff --git a/src/aiunittests/java/MakeItFit/time/TimeManagerTest.java b/src/aiunittests/java/MakeItFit/time/TimeManagerTest.java new file mode 100644 index 0000000..ff4d9f2 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/time/TimeManagerTest.java @@ -0,0 +1,101 @@ +package MakeItFit.time; + +import java.time.LocalDate; + +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class TimeManagerTest { + + @Test + public void testDefaultConstructor() { + TimeManager tm = new TimeManager(); + LocalDate today = LocalDate.now(); + assertEquals(today.getDayOfMonth(), tm.getCurrentDate().getDayOfMonth()); + assertEquals(today.getMonthValue(), tm.getCurrentDate().getMonth()); + assertEquals(today.getYear(), tm.getCurrentDate().getYear()); + } + + @Test + public void testParameterizedConstructor() { + MakeItFitDate testDate = MakeItFitDate.of(2024, 5, 15); + TimeManager tm = new TimeManager(testDate); + assertEquals(testDate, tm.getCurrentDate()); + } + + @Test + public void testGetCurrentDate() { + MakeItFitDate expectedDate = MakeItFitDate.of(2023, 1, 1); + TimeManager tm = new TimeManager(expectedDate); + assertEquals(expectedDate, tm.getCurrentDate()); + } + + @Test + public void testAdvanceTimePositiveDays() { + MakeItFitDate initialDate = MakeItFitDate.of(2023, 1, 1); + TimeManager tm = new TimeManager(initialDate); + MakeItFitDate newDate = tm.advanceTime(5); + assertEquals(6, newDate.getDayOfMonth()); + assertEquals(1, newDate.getMonth()); + assertEquals(2023, newDate.getYear()); + assertEquals(newDate, tm.getCurrentDate()); + } + + @Test + public void testAdvanceTimeZeroDays() { + MakeItFitDate initialDate = MakeItFitDate.of(2023, 1, 1); + TimeManager tm = new TimeManager(initialDate); + MakeItFitDate newDate = tm.advanceTime(0); + assertEquals(initialDate, newDate); + assertEquals(initialDate, tm.getCurrentDate()); + } + + @Test + public void testAdvanceTimeNegativeDays() { + MakeItFitDate initialDate = MakeItFitDate.of(2023, 1, 1); + TimeManager tm = new TimeManager(initialDate); + assertThrows(IllegalArgumentException.class, () -> tm.advanceTime(-1)); + } + + @Test + public void testAdvanceTimeAcrossMonthBoundary() { + MakeItFitDate initialDate = MakeItFitDate.of(2023, 1, 30); + TimeManager tm = new TimeManager(initialDate); + MakeItFitDate newDate = tm.advanceTime(2); + assertEquals(1, newDate.getDayOfMonth()); + assertEquals(2, newDate.getMonth()); + assertEquals(2023, newDate.getYear()); + } + + @Test + public void testAdvanceTimeAcrossYearBoundary() { + MakeItFitDate initialDate = MakeItFitDate.of(2023, 12, 31); + TimeManager tm = new TimeManager(initialDate); + MakeItFitDate newDate = tm.advanceTime(1); + assertEquals(1, newDate.getDayOfMonth()); + assertEquals(1, newDate.getMonth()); + assertEquals(2024, newDate.getYear()); + } + + @Test + public void testAdvanceTimeLeapYear() { + // 2024 is a leap year + MakeItFitDate initialDate = MakeItFitDate.of(2024, 2, 28); + TimeManager tm = new TimeManager(initialDate); + + // Advance 1 day - should be Feb 29 + MakeItFitDate newDate = tm.advanceTime(1); + assertEquals(29, newDate.getDayOfMonth()); + assertEquals(2, newDate.getMonth()); + assertEquals(2024, newDate.getYear()); + + // Advance 1 more day - should be Mar 1 + newDate = tm.advanceTime(1); + assertEquals(1, newDate.getDayOfMonth()); + assertEquals(3, newDate.getMonth()); + assertEquals(2024, newDate.getYear()); + } +} diff --git a/src/aiunittests/java/MakeItFit/trainingPlan/TrainingPlanManagerTest.java b/src/aiunittests/java/MakeItFit/trainingPlan/TrainingPlanManagerTest.java new file mode 100644 index 0000000..10279bc --- /dev/null +++ b/src/aiunittests/java/MakeItFit/trainingPlan/TrainingPlanManagerTest.java @@ -0,0 +1,175 @@ +package MakeItFit.trainingPlan; + +import java.util.List; +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.exceptions.EntityDoesNotExistException; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class TrainingPlanManagerTest { + private TrainingPlanManager manager; + private UUID userCode; + private MakeItFitDate startDate; + private TrainingPlan trainingPlan; + private Activity testActivity; + + @BeforeEach + void setUp() { + manager = new TrainingPlanManager(); + userCode = UUID.randomUUID(); + startDate = MakeItFitDate.of(2024, 5, 1); + trainingPlan = manager.createTrainingPlan(userCode, startDate); + testActivity = new PushUp(); + } + + @Test + void testCreateTrainingPlan() { + assertNotNull(trainingPlan); + assertEquals(userCode, trainingPlan.getUserCode()); + assertEquals(startDate, trainingPlan.getStartDate()); + } + + @Test + void testCreateTrainingPlan_InvalidArguments() { + assertThrows(IllegalArgumentException.class, + () -> { manager.createTrainingPlan(null, null); }); + } + + @Test + void testConstructTrainingPlanByObjectives() { + TrainingPlan plan = + manager.constructTrainingPlanByObjectives(trainingPlan, 1.0f, false, 2, 3, 4, 1000); + + assertNotNull(plan); + assertFalse(plan.getActivities().isEmpty()); + } + + @Test + void testConstructTrainingPlanByObjectives_InvalidArguments() { + assertThrows(IllegalArgumentException.class, () -> { + manager.constructTrainingPlanByObjectives(trainingPlan, 1.0f, false, -1, 3, 4, 1000); + }); + + assertThrows(IllegalArgumentException.class, () -> { + manager.constructTrainingPlanByObjectives(trainingPlan, 1.0f, false, 2, 3, 8, 1000); + }); + } + + @Test + void testInsertTrainingPlan() { + manager.insertTrainingPlan(trainingPlan); + assertTrue(manager.getAllTrainingPlans().contains(trainingPlan)); + } + + @Test + void testInsertTrainingPlan_InvalidArguments() { + assertThrows(IllegalArgumentException.class, () -> { manager.insertTrainingPlan(null); }); + + manager.insertTrainingPlan(trainingPlan); + assertThrows(IllegalArgumentException.class, + () -> { manager.insertTrainingPlan(trainingPlan); }); + } + + @Test + void testRemoveTrainingPlan() { + manager.insertTrainingPlan(trainingPlan); + manager.removeTrainingPlan(trainingPlan.getCode()); + assertFalse(manager.getAllTrainingPlans().contains(trainingPlan)); + } + + @Test + void testGetTrainingPlan() { + manager.insertTrainingPlan(trainingPlan); + TrainingPlan retrieved = manager.getTrainingPlan(trainingPlan.getCode()); + assertEquals(trainingPlan, retrieved); + } + + @Test + void testGetTrainingPlan_NonExistent() { + assertThrows(IllegalArgumentException.class, + () -> { manager.getTrainingPlan(UUID.randomUUID()); }); + } + + @Test + void testUpdateTrainingPlan() throws EntityDoesNotExistException { + manager.insertTrainingPlan(trainingPlan); + + MakeItFitDate newDate = MakeItFitDate.of(2024, 6, 1); + trainingPlan.setStartDate(newDate); + manager.updateTrainingPlan(trainingPlan); + + TrainingPlan updated = manager.getTrainingPlan(trainingPlan.getCode()); + assertEquals(newDate, updated.getStartDate()); + } + + @Test + void testUpdateTrainingPlan_NonExistent() { + assertThrows(EntityDoesNotExistException.class, + () -> { manager.updateTrainingPlan(trainingPlan); }); + } + + @Test + void testGetAllTrainingPlans() { + manager.insertTrainingPlan(trainingPlan); + List plans = manager.getAllTrainingPlans(); + assertEquals(1, plans.size()); + assertEquals(trainingPlan, plans.get(0)); + } + + @Test + void testAddActivity() { + manager.insertTrainingPlan(trainingPlan); + manager.addActivity(trainingPlan.getCode(), 3, testActivity); + assertEquals(1, trainingPlan.getActivities().size()); + } + + @Test + void testRemoveActivity() { + manager.insertTrainingPlan(trainingPlan); + manager.addActivity(trainingPlan.getCode(), 3, testActivity); + manager.removeActivity(trainingPlan.getCode(), testActivity.getCode()); + assertTrue(trainingPlan.getActivities().isEmpty()); + } + + @Test + void testGetTrainingPlansFromUser() { + UUID otherUser = UUID.randomUUID(); + TrainingPlan otherPlan = manager.createTrainingPlan(otherUser, startDate); + + manager.insertTrainingPlan(trainingPlan); + manager.insertTrainingPlan(otherPlan); + + List userPlans = manager.getTrainingPlansFromUser(userCode); + assertEquals(1, userPlans.size()); + assertEquals(trainingPlan, userPlans.get(0)); + } + + @Test + void testUpdateActivities() { + manager.insertTrainingPlan(trainingPlan); + manager.addActivity(trainingPlan.getCode(), 3, testActivity); + + MakeItFitDate currentDate = MakeItFitDate.of(2024, 6, 1); + manager.updateActivities(currentDate, 1.0f); + + // Verifica se a atualização foi realizada (depende da implementação de Activity) + // Este teste pode precisar ser ajustado conforme a lógica de updateActivities + } + + @Test + void testExtractActivities_NoActivities() { + MakeItFitDate currentDate = MakeItFitDate.of(2024, 6, 1); + List activities = manager.extractActivities(currentDate, userCode); + assertTrue(activities.isEmpty()); + } +} diff --git a/src/aiunittests/java/MakeItFit/trainingPlan/TrainingPlanTest.java b/src/aiunittests/java/MakeItFit/trainingPlan/TrainingPlanTest.java new file mode 100644 index 0000000..bd48443 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/trainingPlan/TrainingPlanTest.java @@ -0,0 +1,189 @@ +package MakeItFit.trainingPlan; + +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.utils.MakeItFitDate; +import MakeItFit.utils.MyTuple; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class TrainingPlanTest { + private TrainingPlan trainingPlan; + private UUID userCode; + private MakeItFitDate startDate; + private Activity activity1; + private Activity activity2; + + @BeforeEach + void setUp() { + userCode = UUID.randomUUID(); + startDate = MakeItFitDate.of(2024, 5, 1); + trainingPlan = new TrainingPlan(userCode, startDate); + + activity1 = new PushUp(); + activity2 = new PushUp(); + } + + @Test + void testConstructorWithParameters() { + assertNotNull(trainingPlan); + assertEquals(userCode, trainingPlan.getUserCode()); + assertEquals(startDate, trainingPlan.getStartDate()); + assertTrue(trainingPlan.getActivities().isEmpty()); + } + + @Test + void testDefaultConstructor() { + TrainingPlan defaultPlan = new TrainingPlan(); + assertNotNull(defaultPlan); + assertEquals(new UUID(0L, 0L), defaultPlan.getUserCode()); + assertNotNull(defaultPlan.getStartDate()); + assertTrue(defaultPlan.getActivities().isEmpty()); + } + + @Test + void testCopyConstructor() { + trainingPlan.addActivity(3, activity1); + trainingPlan.addActivity(5, activity2); + + TrainingPlan copy = new TrainingPlan(trainingPlan); + + assertEquals(trainingPlan.getUserCode(), copy.getUserCode()); + assertEquals(trainingPlan.getStartDate(), copy.getStartDate()); + assertEquals(trainingPlan.getActivities().size(), copy.getActivities().size()); + assertEquals(trainingPlan.getCode(), copy.getCode()); + } + + @Test + void testGetUserCode() { + assertEquals(userCode, trainingPlan.getUserCode()); + } + + @Test + void testGetCode() { + assertNotNull(trainingPlan.getCode()); + } + + @Test + void testGetStartDate() { + assertEquals(startDate, trainingPlan.getStartDate()); + } + + @Test + void testGetActivities() { + assertTrue(trainingPlan.getActivities().isEmpty()); + } + + @Test + void testSetStartDate() { + MakeItFitDate newDate = MakeItFitDate.of(2024, 6, 1); + trainingPlan.setStartDate(newDate); + assertEquals(newDate, trainingPlan.getStartDate()); + } + + @Test + void testAddActivity() { + trainingPlan.addActivity(3, activity1); + assertEquals(1, trainingPlan.getActivities().size()); + + MyTuple tuple = trainingPlan.getActivities().get(0); + assertEquals(3, tuple.getItem1().intValue()); + assertEquals(activity1, tuple.getItem2()); + } + + @Test + void testRemoveActivity() { + trainingPlan.addActivity(3, activity1); + trainingPlan.addActivity(5, activity2); + + assertEquals(2, trainingPlan.getActivities().size()); + + trainingPlan.removeActivity(activity1.getCode()); + assertEquals(1, trainingPlan.getActivities().size()); + assertEquals(activity2, trainingPlan.getActivities().get(0).getItem2()); + } + + @Test + void testRemoveActivity_NonExistent() { + trainingPlan.addActivity(3, activity1); + trainingPlan.removeActivity(UUID.randomUUID()); // Should not throw exception + assertEquals(1, trainingPlan.getActivities().size()); + } + + @Test + void testUpdateActivities() { + MakeItFitDate pastDate = MakeItFitDate.of(2024, 4, 1); + + trainingPlan.addActivity(3, activity1); + trainingPlan.addActivity(5, activity2); // activity2 has future date by default + + trainingPlan.updateActivities(MakeItFitDate.of(2024, 5, 15), 1.1f); + + // Only activity1 should be updated as it's in the past + // Note: This assumes Activity has some way to verify it was updated + // You might need to add getters for updated values in Activity class + } + + @Test + void testToString() { + trainingPlan.addActivity(3, activity1); + String result = trainingPlan.toString(); + + assertTrue(result.contains("Training Plan: " + trainingPlan.getCode())); + assertTrue(result.contains("User Code: " + userCode)); + assertTrue(result.contains("Start Date: " + startDate)); + assertTrue(result.contains("Activities(Iterations / Activity):")); + } + + @Test + void testEquals() { + TrainingPlan samePlan = new TrainingPlan(userCode, startDate); + samePlan.addActivity(3, activity1); + trainingPlan.addActivity(3, activity1); + + TrainingPlan differentPlan = + new TrainingPlan(UUID.randomUUID(), MakeItFitDate.of(2024, 6, 1)); + + assertEquals(trainingPlan, trainingPlan); // reflexivity + assertEquals(trainingPlan, samePlan); + assertNotEquals(trainingPlan, differentPlan); + assertNotEquals(trainingPlan, null); + assertNotEquals(trainingPlan, new Object()); + } + + @Test + void testCompareTo() { + TrainingPlan earlierPlan = new TrainingPlan(userCode, MakeItFitDate.of(2024, 4, 1)); + TrainingPlan laterPlan = new TrainingPlan(userCode, MakeItFitDate.of(2024, 6, 1)); + + assertTrue(trainingPlan.compareTo(earlierPlan) > 0); + assertTrue(trainingPlan.compareTo(laterPlan) < 0); + assertEquals(0, trainingPlan.compareTo(new TrainingPlan(trainingPlan))); + + // Test with same date but different number of activities + TrainingPlan sameDateMoreActivities = new TrainingPlan(userCode, startDate); + sameDateMoreActivities.addActivity(3, activity1); + sameDateMoreActivities.addActivity(5, activity2); + + trainingPlan.addActivity(3, activity1); + assertTrue(trainingPlan.compareTo(sameDateMoreActivities) < 0); + } + + @Test + void testClone() { + trainingPlan.addActivity(3, activity1); + TrainingPlan clone = trainingPlan.clone(); + + assertEquals(trainingPlan.getUserCode(), clone.getUserCode()); + assertEquals(trainingPlan.getStartDate(), clone.getStartDate()); + assertEquals(trainingPlan.getActivities().size(), clone.getActivities().size()); + assertEquals(trainingPlan.getCode(), clone.getCode()); + } +} diff --git a/src/aiunittests/java/MakeItFit/users/UserManagerTest.java b/src/aiunittests/java/MakeItFit/users/UserManagerTest.java new file mode 100644 index 0000000..35135c1 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/users/UserManagerTest.java @@ -0,0 +1,302 @@ +package MakeItFit.users; + +import java.util.Arrays; +import java.util.List; +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.exceptions.EntityDoesNotExistException; +import MakeItFit.exceptions.ExistingEntityConflictException; +import MakeItFit.exceptions.InvalidTypeException; +import MakeItFit.users.types.Amateur; +import MakeItFit.users.types.Occasional; +import MakeItFit.users.types.Professional; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class UserManagerTest { + private UserManager userManager; + private User amateurUser; + private User occasionalUser; + private User professionalUser; + + @BeforeEach + void setUp() throws InvalidTypeException { + userManager = new UserManager(); + + amateurUser = userManager.createUser("Amateur User", + 25, + Gender.Male, + 70.5f, + 175, + 72, + 3, + "Amateur Address", + "123456789", + "amateur@email.com", + 3, + "Amateur"); + + occasionalUser = userManager.createUser("Occasional User", + 30, + Gender.Female, + 60.0f, + 165, + 68, + 2, + "Occasional Address", + "987654321", + "occasional@email.com", + 2, + "Occasional"); + + professionalUser = userManager.createUser("Professional User", + 35, + Gender.Female, + 80.0f, + 185, + 75, + 4, + "Professional Address", + "555555555", + "professional@email.com", + 5, + "Professional"); + } + + @Test + void testCreateUser_Amateur() throws InvalidTypeException { + User user = userManager.createUser("Test Amateur", + 20, + Gender.Male, + 65.0f, + 170, + 70, + 2, + "Test Address", + "111111111", + "test@email.com", + 0, + "Amateur"); + + assertNotNull(user); + assertTrue(user instanceof Amateur); + assertEquals("Test Amateur", user.getName()); + } + + @Test + void testCreateUser_Occasional() throws InvalidTypeException { + User user = userManager.createUser("Test Occasional", + 25, + Gender.Female, + 55.0f, + 160, + 65, + 1, + "Test Address", + "222222222", + "test@email.com", + 2, + "Occasional"); + + assertNotNull(user); + assertTrue(user instanceof Occasional); + assertEquals("Test Occasional", user.getName()); + } + + @Test + void testCreateUser_Professional() throws InvalidTypeException { + User user = userManager.createUser("Test Professional", + 30, + Gender.Male, + 75.0f, + 180, + 70, + 3, + "Test Address", + "333333333", + "test@email.com", + 4, + "Professional"); + + assertNotNull(user); + assertTrue(user instanceof Professional); + assertEquals("Test Professional", user.getName()); + } + + @Test + void testCreateUser_InvalidType() { + assertThrows(InvalidTypeException.class, () -> { + userManager.createUser("Invalid User", + 40, + Gender.Male, + 85.0f, + 190, + 80, + 5, + "Invalid Address", + "444444444", + "invalid@email.com", + 3, + "InvalidType"); + }); + } + + @Test + void testCreateUser_InvalidArguments() { + assertThrows(IllegalArgumentException.class, () -> { + userManager + .createUser(null, -1, null, -1.0f, -1, -1, -1, null, null, null, -1, "Amateur"); + }); + } + + @Test + void testInsertUser() throws ExistingEntityConflictException { + userManager.insertUser(amateurUser); + assertTrue(userManager.existsUserWithEmail("amateur@email.com")); + } + + @Test + void testInsertUser_DuplicateEmail() throws ExistingEntityConflictException { + userManager.insertUser(amateurUser); + assertThrows(ExistingEntityConflictException.class, + () -> { userManager.insertUser(amateurUser); }); + } + + @Test + void testRemoveUserByCode() + throws ExistingEntityConflictException, EntityDoesNotExistException { + userManager.insertUser(amateurUser); + UUID code = amateurUser.getCode(); + userManager.removeUserByCode(code); + assertFalse(userManager.existsUserWithEmail("amateur@email.com")); + } + + @Test + void testRemoveUserByCode_NonExistent() { + assertThrows(EntityDoesNotExistException.class, + () -> { userManager.removeUserByCode(UUID.randomUUID()); }); + } + + @Test + void testRemoveUserByEmail() + throws ExistingEntityConflictException, EntityDoesNotExistException { + userManager.insertUser(occasionalUser); + userManager.removeUserByEmail("occasional@email.com"); + assertFalse(userManager.existsUserWithEmail("occasional@email.com")); + } + + @Test + void testRemoveUserByEmail_NonExistent() { + assertThrows(EntityDoesNotExistException.class, + () -> { userManager.removeUserByEmail("nonexistent@email.com"); }); + } + + @Test + void testExistsUserWithEmail() throws ExistingEntityConflictException { + userManager.insertUser(professionalUser); + assertTrue(userManager.existsUserWithEmail("professional@email.com")); + assertFalse(userManager.existsUserWithEmail("nonexistent@email.com")); + } + + @Test + void testGetUserByCode() throws ExistingEntityConflictException, EntityDoesNotExistException { + userManager.insertUser(amateurUser); + UUID code = amateurUser.getCode(); + User retrieved = userManager.getUserByCode(code); + assertEquals(amateurUser, retrieved); + } + + @Test + void testGetUserByCode_NonExistent() { + assertThrows(EntityDoesNotExistException.class, + () -> { userManager.getUserByCode(UUID.randomUUID()); }); + } + + @Test + void testGetUserByEmail() throws ExistingEntityConflictException, EntityDoesNotExistException { + userManager.insertUser(occasionalUser); + User retrieved = userManager.getUserByEmail("occasional@email.com"); + assertEquals(occasionalUser, retrieved); + } + + @Test + void testGetUserByEmail_NonExistent() { + assertThrows(EntityDoesNotExistException.class, + () -> { userManager.getUserByEmail("nonexistent@email.com"); }); + } + + @Test + void testUpdateUser() throws ExistingEntityConflictException, EntityDoesNotExistException { + userManager.insertUser(professionalUser); + professionalUser.setName("Updated Professional"); + userManager.updateUser(professionalUser); + + User updated = userManager.getUserByCode(professionalUser.getCode()); + assertEquals("Updated Professional", updated.getName()); + } + + @Test + void testUpdateUser_NonExistent() { + assertThrows(EntityDoesNotExistException.class, + () -> { userManager.updateUser(professionalUser); }); + } + + @Test + void testGetAllUsers() throws ExistingEntityConflictException { + userManager.insertUser(amateurUser); + userManager.insertUser(occasionalUser); + userManager.insertUser(professionalUser); + + List users = userManager.getAllUsers(); + assertEquals(3, users.size()); + assertTrue(users.contains(amateurUser)); + assertTrue(users.contains(occasionalUser)); + assertTrue(users.contains(professionalUser)); + } + + @Test + void testGetActivitiesFromUser() + throws ExistingEntityConflictException, EntityDoesNotExistException { + userManager.insertUser(amateurUser); + List activities = userManager.getActivitiesFromUser("amateur@email.com"); + assertNotNull(activities); + assertTrue(activities.isEmpty()); + } + + @Test + void testAddActivityToUser() throws ExistingEntityConflictException { + userManager.insertUser(occasionalUser); + Activity activity = new PushUp(); + userManager.addActivityToUser("occasional@email.com", activity); + + assertEquals(1, occasionalUser.getListActivities().size()); + } + + @Test + void testRemoveActivityFromUser() throws ExistingEntityConflictException { + userManager.insertUser(professionalUser); + Activity activity = new PushUp(); + UUID activityCode = activity.getCode(); + professionalUser.addActivity(activity); + + userManager.removeActivityFromUser("professional@email.com", activityCode); + assertEquals(0, professionalUser.getListActivities().size()); + } + + @Test + void testAddActivitiesToUser() throws ExistingEntityConflictException { + userManager.insertUser(amateurUser); + List activities = Arrays.asList(new PushUp(), new PushUp()); + userManager.addActivitiesToUser(amateurUser.getCode(), activities); + + assertEquals(2, amateurUser.getListActivities().size()); + } +} diff --git a/src/aiunittests/java/MakeItFit/users/UserTest.java b/src/aiunittests/java/MakeItFit/users/UserTest.java new file mode 100644 index 0000000..2b91942 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/users/UserTest.java @@ -0,0 +1,347 @@ +package MakeItFit.users; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class TestUser extends User { + + public TestUser() { + super(); + } + + public TestUser(String name, + int age, + Gender gender, + float weight, + int height, + int bpm, + int level, + String address, + String phone, + String email) { + super(name, age, gender, weight, height, bpm, level, address, phone, email); + } + + public TestUser(User u) { + super(u); + } + + @Override + public User clone() { + return new TestUser(this); + } +} + +public class UserTest { + + @Test + void testConstructorWithParameters() { + TestUser user = new TestUser("John Doe", + 30, + Gender.Male, + 75.5f, + 180, + 72, + 2, + "123 Main St", + "555-1234", + "john@example.com"); + + assertEquals("John Doe", user.getName()); + assertEquals(30, user.getAge()); + assertEquals(Gender.Male, user.getGender()); + assertEquals(75.5f, user.getWeight()); + assertEquals(180, user.getHeight()); + assertEquals(72, user.getBpm()); + assertEquals(2, user.getLevel()); + assertEquals("123 Main St", user.getAddress()); + assertEquals("555-1234", user.getPhone()); + assertEquals("john@example.com", user.getEmail()); + assertNotNull(user.getCode()); + assertTrue(user.getListActivities().isEmpty()); + } + + @Test + void testDefaultConstructor() { + TestUser user = new TestUser(); + + assertEquals("", user.getName()); + assertEquals(0, user.getAge()); + assertEquals(Gender.Other, user.getGender()); + assertEquals(0f, user.getWeight()); + assertEquals(0, user.getHeight()); + assertEquals(0, user.getBpm()); + assertEquals(0, user.getLevel()); + assertEquals("", user.getAddress()); + assertEquals("", user.getPhone()); + assertEquals("", user.getEmail()); + assertEquals(0f, user.getIndex()); + assertNotNull(user.getCode()); + assertTrue(user.getListActivities().isEmpty()); + } + + @Test + void testCopyConstructor() { + TestUser original = new TestUser("Jane Doe", + 25, + Gender.Female, + 60.0f, + 165, + 68, + 1, + "456 Oak St", + "555-5678", + "jane@example.com"); + original.addActivity(new PushUp()); + + TestUser copy = new TestUser(original); + + assertEquals(original.getName(), copy.getName()); + assertEquals(original.getAge(), copy.getAge()); + assertEquals(original.getGender(), copy.getGender()); + assertEquals(original.getWeight(), copy.getWeight()); + assertEquals(original.getHeight(), copy.getHeight()); + assertEquals(original.getBpm(), copy.getBpm()); + assertEquals(original.getLevel(), copy.getLevel()); + assertEquals(original.getAddress(), copy.getAddress()); + assertEquals(original.getPhone(), copy.getPhone()); + assertEquals(original.getEmail(), copy.getEmail()); + assertEquals(original.getIndex(), copy.getIndex()); + assertEquals(original.getCode(), copy.getCode()); + assertEquals(original.getListActivities().size(), copy.getListActivities().size()); + } + + @Test + void testSettersAndGetters() { + TestUser user = new TestUser(); + + user.setName("Alice"); + user.setAge(28); + user.setGender(Gender.Female); + user.setWeight(58.5f); + user.setHeight(170); + user.setBpm(65); + user.setLevel(3); + user.setAddress("789 Pine St"); + user.setPhone("555-9012"); + user.setEmail("alice@example.com"); + user.setIndex(25.5f); + + assertEquals("Alice", user.getName()); + assertEquals(28, user.getAge()); + assertEquals(Gender.Female, user.getGender()); + assertEquals(58.5f, user.getWeight()); + assertEquals(170, user.getHeight()); + assertEquals(65, user.getBpm()); + assertEquals(3, user.getLevel()); + assertEquals("789 Pine St", user.getAddress()); + assertEquals("555-9012", user.getPhone()); + assertEquals("alice@example.com", user.getEmail()); + assertEquals(25.5f, user.getIndex()); + } + + @Test + void testCalculateIndex() { + TestUser user = new TestUser(); + + // Test with normal values + float index1 = user.calculateIndex(70.0f, 175, 72); + assertEquals(70.0f / (1.75f * 1.75f) + 72.0f / 40.0f, index1, 0.001f); + + // Test with zero values (should handle division by zero?) + float index2 = user.calculateIndex(1f, 0, 0); + assertEquals(Float.POSITIVE_INFINITY, index2); // This might need to be handled differently + } + + @Test + void testActivityManagement() { + TestUser user = new TestUser(); + Activity activity1 = new PushUp(); + Activity activity2 = new PushUp(); + + // Test adding single activity + user.addActivity(activity1); + assertEquals(1, user.getListActivities().size()); + + // Test adding list of activities + List activities = new ArrayList<>(); + activities.add(activity2); + user.addActivities(activities); + assertEquals(2, user.getListActivities().size()); + + // Test removing activity + UUID activityId = activity1.getCode(); + user.removeActivity(activityId); + assertEquals(1, user.getListActivities().size()); + assertNotEquals(activityId, user.getListActivities().get(0).getCode()); + } + + @Test + void testEquals() { + TestUser user1 = new TestUser("John Doe", + 30, + Gender.Male, + 75.5f, + 180, + 72, + 2, + "123 Main St", + "555-1234", + "john@example.com"); + + TestUser user2 = new TestUser("John Doe", + 30, + Gender.Male, + 75.5f, + 180, + 72, + 2, + "123 Main St", + "555-1234", + "john@example.com"); + + TestUser user3 = new TestUser("Jane Doe", + 25, + Gender.Female, + 60.0f, + 165, + 68, + 1, + "456 Oak St", + "555-5678", + "jane@example.com"); + + // Reflexivity + assertEquals(user1, user1); + + // Symmetry + assertEquals(user1, user2); + assertEquals(user2, user1); + + // Transitivity + TestUser user4 = new TestUser(user1); + assertEquals(user1, user2); + assertEquals(user2, user4); + assertEquals(user1, user4); + + // Inequality + assertNotEquals(user1, user3); + assertNotEquals(user1, null); + assertNotEquals(user1, new Object()); + } + + @Test + void testCompareTo() { + TestUser user1 = new TestUser("Alice", + 25, + Gender.Female, + 60.0f, + 165, + 68, + 1, + "456 Oak St", + "555-5678", + "alice@example.com"); + + TestUser user2 = new TestUser("Bob", + 30, + Gender.Male, + 75.5f, + 180, + 72, + 2, + "123 Main St", + "555-1234", + "bob@example.com"); + + TestUser user3 = new TestUser("Alice", + 30, + Gender.Female, + 65.0f, + 170, + 70, + 2, + "789 Pine St", + "555-9012", + "alice2@example.com"); + + // Name comparison + assertTrue(user1.compareTo(user2) < 0); + assertTrue(user2.compareTo(user1) > 0); + + // Same name, compare by age + assertTrue(user1.compareTo(user3) < 0); + assertTrue(user3.compareTo(user1) > 0); + + // Same name and age + TestUser user4 = new TestUser(user1); + assertEquals(0, user1.compareTo(user4)); + } + + @Test + void testToString() { + TestUser user = new TestUser("John Doe", + 30, + Gender.Male, + 75.5f, + 180, + 72, + 2, + "123 Main St", + "555-1234", + "john@example.com"); + + String str = user.toString(); + + assertTrue(str.contains("John Doe")); + assertTrue(str.contains("30")); + assertTrue(str.contains("Male")); + assertTrue(str.contains("180")); + assertTrue(str.contains("72")); + assertTrue(str.contains("2")); + assertTrue(str.contains("123 Main St")); + assertTrue(str.contains("555-1234")); + assertTrue(str.contains("john@example.com")); + } + + @Test + void testClone() { + TestUser original = new TestUser("John Doe", + 30, + Gender.Male, + 75.5f, + 180, + 72, + 2, + "123 Main St", + "555-1234", + "john@example.com"); + original.addActivity(new PushUp()); + + TestUser clone = (TestUser) original.clone(); + + assertEquals(original.getName(), clone.getName()); + assertEquals(original.getAge(), clone.getAge()); + assertEquals(original.getGender(), clone.getGender()); + assertEquals(original.getWeight(), clone.getWeight()); + assertEquals(original.getHeight(), clone.getHeight()); + assertEquals(original.getBpm(), clone.getBpm()); + assertEquals(original.getLevel(), clone.getLevel()); + assertEquals(original.getAddress(), clone.getAddress()); + assertEquals(original.getPhone(), clone.getPhone()); + assertEquals(original.getEmail(), clone.getEmail()); + assertEquals(original.getIndex(), clone.getIndex()); + assertEquals(original.getCode(), clone.getCode()); + assertEquals(original.getListActivities().size(), clone.getListActivities().size()); + } +} diff --git a/src/aiunittests/java/MakeItFit/users/types/AmateurTest.java b/src/aiunittests/java/MakeItFit/users/types/AmateurTest.java new file mode 100644 index 0000000..68d6df4 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/users/types/AmateurTest.java @@ -0,0 +1,115 @@ +package MakeItFit.users.types; +import MakeItFit.users.Gender; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class AmateurTest { + + @Test + void testConstructorWithParameters() { + Amateur amateur = new Amateur("John Doe", + 30, + Gender.Male, + 75.5f, + 180, + 72, + 2, + "123 Main St", + "555-1234", + "john@example.com"); + + assertEquals("John Doe", amateur.getName()); + assertEquals(30, amateur.getAge()); + assertEquals(Gender.Male, amateur.getGender()); + assertEquals(75.5f, amateur.getWeight()); + assertEquals(180, amateur.getHeight()); + assertEquals(72, amateur.getBpm()); + assertEquals(2, amateur.getLevel()); + assertEquals("123 Main St", amateur.getAddress()); + assertEquals("555-1234", amateur.getPhone()); + assertEquals("john@example.com", amateur.getEmail()); + } + + @Test + void testCopyConstructor() { + Amateur original = new Amateur("Jane Doe", + 25, + Gender.Female, + 60.0f, + 165, + 68, + 1, + "456 Oak St", + "555-5678", + "jane@example.com"); + + Amateur copy = new Amateur(original); + + assertEquals(original.getName(), copy.getName()); + assertEquals(original.getAge(), copy.getAge()); + assertEquals(original.getGender(), copy.getGender()); + assertEquals(original.getWeight(), copy.getWeight()); + assertEquals(original.getHeight(), copy.getHeight()); + assertEquals(original.getBpm(), copy.getBpm()); + assertEquals(original.getLevel(), copy.getLevel()); + assertEquals(original.getAddress(), copy.getAddress()); + assertEquals(original.getPhone(), copy.getPhone()); + assertEquals(original.getEmail(), copy.getEmail()); + } + + @Test + void testClone() { + Amateur original = new Amateur("Alice", + 28, + Gender.Female, + 58.5f, + 170, + 65, + 3, + "789 Pine St", + "555-9012", + "alice@example.com"); + + Amateur clone = original.clone(); + + assertEquals(original.getName(), clone.getName()); + assertEquals(original.getAge(), clone.getAge()); + assertEquals(original.getGender(), clone.getGender()); + assertEquals(original.getWeight(), clone.getWeight()); + assertEquals(original.getHeight(), clone.getHeight()); + assertEquals(original.getBpm(), clone.getBpm()); + assertEquals(original.getLevel(), clone.getLevel()); + assertEquals(original.getAddress(), clone.getAddress()); + assertEquals(original.getPhone(), clone.getPhone()); + assertEquals(original.getEmail(), clone.getEmail()); + } + + @Test + void testToString() { + Amateur amateur = new Amateur("Bob", + 35, + Gender.Male, + 80.0f, + 185, + 75, + 2, + "101 Maple St", + "555-3456", + "bob@example.com"); + + String str = amateur.toString(); + + assertTrue(str.contains("Bob")); + assertTrue(str.contains("35")); + assertTrue(str.contains("Male")); + assertTrue(str.contains("185")); + assertTrue(str.contains("75")); + assertTrue(str.contains("2")); + assertTrue(str.contains("101 Maple St")); + assertTrue(str.contains("555-3456")); + assertTrue(str.contains("bob@example.com")); + assertTrue(str.contains("====================")); + } +} diff --git a/src/aiunittests/java/MakeItFit/users/types/OccasionalTest.java b/src/aiunittests/java/MakeItFit/users/types/OccasionalTest.java new file mode 100644 index 0000000..e741601 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/users/types/OccasionalTest.java @@ -0,0 +1,163 @@ +package MakeItFit.users.types; +import MakeItFit.users.Gender; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class OccasionalTest { + + @Test + void testConstructorWithParameters() { + Occasional occ = new Occasional("John Doe", + 30, + Gender.Male, + 75.5f, + 180, + 72, + 2, + "123 Main St", + "555-1234", + "john@example.com", + 2); + + assertEquals("John Doe", occ.getName()); + assertEquals(30, occ.getAge()); + assertEquals(Gender.Male, occ.getGender()); + assertEquals(75.5f, occ.getWeight()); + assertEquals(180, occ.getHeight()); + assertEquals(72, occ.getBpm()); + assertEquals(2, occ.getLevel()); + assertEquals("123 Main St", occ.getAddress()); + assertEquals("555-1234", occ.getPhone()); + assertEquals("john@example.com", occ.getEmail()); + assertEquals(2, occ.getFrequency()); + } + + @Test + void testConstructorWithNegativeFrequency() { + assertThrows(IllegalArgumentException.class, () -> { + new Occasional("John Doe", + 30, + Gender.Male, + 75.5f, + 180, + 72, + 2, + "123 Main St", + "555-1234", + "john@example.com", + -1); + }); + } + + @Test + void testCopyConstructor() { + Occasional original = new Occasional("Jane Doe", + 25, + Gender.Female, + 60.0f, + 165, + 68, + 1, + "456 Oak St", + "555-5678", + "jane@example.com", + 1); + + Occasional copy = new Occasional(original); + + assertEquals(original.getName(), copy.getName()); + assertEquals(original.getAge(), copy.getAge()); + assertEquals(original.getGender(), copy.getGender()); + assertEquals(original.getWeight(), copy.getWeight()); + assertEquals(original.getHeight(), copy.getHeight()); + assertEquals(original.getBpm(), copy.getBpm()); + assertEquals(original.getLevel(), copy.getLevel()); + assertEquals(original.getAddress(), copy.getAddress()); + assertEquals(original.getPhone(), copy.getPhone()); + assertEquals(original.getEmail(), copy.getEmail()); + assertEquals(original.getFrequency(), copy.getFrequency()); + } + + @Test + void testFrequencyManagement() { + Occasional occ = new Occasional("Alice", + 28, + Gender.Female, + 58.5f, + 170, + 65, + 3, + "789 Pine St", + "555-9012", + "alice@example.com", + 1); + + // Test valid frequency + occ.setFrequency(3); + assertEquals(3, occ.getFrequency()); + + // Test invalid frequency + assertThrows(IllegalArgumentException.class, () -> occ.setFrequency(-1)); + } + + @Test + void testClone() { + Occasional original = new Occasional("Bob", + 35, + Gender.Male, + 80.0f, + 185, + 75, + 2, + "101 Maple St", + "555-3456", + "bob@example.com", + 2); + + Occasional clone = original.clone(); + + assertEquals(original.getName(), clone.getName()); + assertEquals(original.getAge(), clone.getAge()); + assertEquals(original.getGender(), clone.getGender()); + assertEquals(original.getWeight(), clone.getWeight()); + assertEquals(original.getHeight(), clone.getHeight()); + assertEquals(original.getBpm(), clone.getBpm()); + assertEquals(original.getLevel(), clone.getLevel()); + assertEquals(original.getAddress(), clone.getAddress()); + assertEquals(original.getPhone(), clone.getPhone()); + assertEquals(original.getEmail(), clone.getEmail()); + assertEquals(original.getFrequency(), clone.getFrequency()); + } + + @Test + void testToString() { + Occasional occ = new Occasional("Charlie", + 40, + Gender.Male, + 85.0f, + 190, + 80, + 1, + "202 Elm St", + "555-7890", + "charlie@example.com", + 1); + + String str = occ.toString(); + + assertTrue(str.contains("Charlie")); + assertTrue(str.contains("40")); + assertTrue(str.contains("Male")); + assertTrue(str.contains("190")); + assertTrue(str.contains("80")); + assertTrue(str.contains("1")); + assertTrue(str.contains("202 Elm St")); + assertTrue(str.contains("555-7890")); + assertTrue(str.contains("charlie@example.com")); + assertTrue(str.contains("Frequency: 1")); + assertTrue(str.contains("====================")); + } +} diff --git a/src/aiunittests/java/MakeItFit/users/types/ProfessionalTest.java b/src/aiunittests/java/MakeItFit/users/types/ProfessionalTest.java new file mode 100644 index 0000000..b9b81fe --- /dev/null +++ b/src/aiunittests/java/MakeItFit/users/types/ProfessionalTest.java @@ -0,0 +1,173 @@ +package MakeItFit.users.types; + +import MakeItFit.users.Gender; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class ProfessionalTest { + + @Test + void testConstructorWithParameters() { + Professional pro = new Professional("John Doe", + 30, + Gender.Male, + 75.5f, + 180, + 72, + 2, + "123 Main St", + "555-1234", + "john@example.com", + 5); + + assertEquals("John Doe", pro.getName()); + assertEquals(30, pro.getAge()); + assertEquals(Gender.Male, pro.getGender()); + assertEquals(75.5f, pro.getWeight()); + assertEquals(180, pro.getHeight()); + assertEquals(72, pro.getBpm()); + assertEquals(2, pro.getLevel()); + assertEquals("123 Main St", pro.getAddress()); + assertEquals("555-1234", pro.getPhone()); + assertEquals("john@example.com", pro.getEmail()); + assertEquals("No specialization", pro.getSpecialization()); + assertEquals(5, pro.getFrequency()); + } + + @Test + void testCopyConstructor() { + Professional original = new Professional("Jane Doe", + 25, + Gender.Female, + 60.0f, + 165, + 68, + 1, + "456 Oak St", + "555-5678", + "jane@example.com", + 3); + original.setSpecialization("Running"); + + Professional copy = new Professional(original); + + assertEquals(original.getName(), copy.getName()); + assertEquals(original.getAge(), copy.getAge()); + assertEquals(original.getGender(), copy.getGender()); + assertEquals(original.getWeight(), copy.getWeight()); + assertEquals(original.getHeight(), copy.getHeight()); + assertEquals(original.getBpm(), copy.getBpm()); + assertEquals(original.getLevel(), copy.getLevel()); + assertEquals(original.getAddress(), copy.getAddress()); + assertEquals(original.getPhone(), copy.getPhone()); + assertEquals(original.getEmail(), copy.getEmail()); + assertEquals(original.getSpecialization(), copy.getSpecialization()); + assertEquals(original.getFrequency(), copy.getFrequency()); + } + + @Test + void testSpecializationManagement() { + Professional pro = new Professional("Athlete", + 28, + Gender.Male, + 70.0f, + 175, + 65, + 3, + "Sports Ave", + "555-9999", + "athlete@example.com", + 5); + + // Test setting specialization + pro.setSpecialization("Swimming"); + assertEquals("Swimming", pro.getSpecialization()); + + // Test updateSpecialization with no activities (should remain unchanged) + pro.updateSpecialization(); + assertEquals("Swimming", pro.getSpecialization()); + } + + @Test + void testFrequencyManagement() { + Professional pro = new Professional("Athlete", + 28, + Gender.Male, + 70.0f, + 175, + 65, + 3, + "Sports Ave", + "555-9999", + "athlete@example.com", + 5); + + // Test setting frequency + pro.setFrequency(7); + assertEquals(7, pro.getFrequency()); + } + + @Test + void testClone() { + Professional original = new Professional("Alice", + 28, + Gender.Female, + 58.5f, + 170, + 65, + 3, + "789 Pine St", + "555-9012", + "alice@example.com", + 4); + original.setSpecialization("Cycling"); + + Professional clone = original.clone(); + + assertEquals(original.getName(), clone.getName()); + assertEquals(original.getAge(), clone.getAge()); + assertEquals(original.getGender(), clone.getGender()); + assertEquals(original.getWeight(), clone.getWeight()); + assertEquals(original.getHeight(), clone.getHeight()); + assertEquals(original.getBpm(), clone.getBpm()); + assertEquals(original.getLevel(), clone.getLevel()); + assertEquals(original.getAddress(), clone.getAddress()); + assertEquals(original.getPhone(), clone.getPhone()); + assertEquals(original.getEmail(), clone.getEmail()); + assertEquals(original.getSpecialization(), clone.getSpecialization()); + assertEquals(original.getFrequency(), clone.getFrequency()); + } + + @Test + void testToString() { + Professional pro = new Professional("Bob", + 35, + Gender.Male, + 80.0f, + 185, + 75, + 2, + "101 Maple St", + "555-3456", + "bob@example.com", + 6); + pro.setSpecialization("Running"); + + String str = pro.toString(); + + assertTrue(str.contains("Bob")); + assertTrue(str.contains("35")); + assertTrue(str.contains("Male")); + assertTrue(str.contains("185")); + assertTrue(str.contains("75")); + assertTrue(str.contains("2")); + assertTrue(str.contains("101 Maple St")); + assertTrue(str.contains("555-3456")); + assertTrue(str.contains("bob@example.com")); + assertTrue(str.contains("Specialization: Running")); + assertTrue(str.contains("Frequency: 6")); + assertTrue(str.contains("====================")); + } +} diff --git a/src/aiunittests/java/MakeItFit/utils/EmailValidatorTest.java b/src/aiunittests/java/MakeItFit/utils/EmailValidatorTest.java new file mode 100644 index 0000000..e1cc311 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/utils/EmailValidatorTest.java @@ -0,0 +1,68 @@ +package MakeItFit.utils; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class EmailValidatorTest { + + @Test + void testValidEmails() { + assertTrue(EmailValidator.isValidEmail("user@example.com")); + assertTrue(EmailValidator.isValidEmail("firstname.lastname@example.com")); + assertTrue(EmailValidator.isValidEmail("email@subdomain.example.com")); + assertTrue(EmailValidator.isValidEmail("1234567890@example.com")); + assertTrue(EmailValidator.isValidEmail("email@example-one.com")); + assertTrue(EmailValidator.isValidEmail("_______@example.com")); + assertTrue(EmailValidator.isValidEmail("email@example.name")); + assertTrue(EmailValidator.isValidEmail("email@example.museum")); + assertTrue(EmailValidator.isValidEmail("email@example.co.jp")); + assertTrue(EmailValidator.isValidEmail("firstname-lastname@example.com")); + } + + @Test + void testInvalidEmails() { + assertFalse(EmailValidator.isValidEmail("plainaddress")); + assertFalse(EmailValidator.isValidEmail("@missingusername.com")); + assertFalse(EmailValidator.isValidEmail("username@.com")); + assertFalse(EmailValidator.isValidEmail("username@example.com.")); + assertFalse(EmailValidator.isValidEmail("username@example_com")); + assertFalse(EmailValidator.isValidEmail("username@example:com")); + assertFalse(EmailValidator.isValidEmail("too@many@at@signs.com")); + assertFalse(EmailValidator.isValidEmail("username@.com.")); + assertFalse(EmailValidator.isValidEmail("username@.com")); + } + + @Test + void testSpecialCharacters() { + assertTrue(EmailValidator.isValidEmail("user+name@example.com")); + assertTrue(EmailValidator.isValidEmail("user.name@example.com")); + assertTrue(EmailValidator.isValidEmail("user_name@example.com")); + assertTrue(EmailValidator.isValidEmail("user-name@example.com")); + assertFalse(EmailValidator.isValidEmail("user#name@example.com")); + assertFalse(EmailValidator.isValidEmail("user$name@example.com")); + assertFalse(EmailValidator.isValidEmail("user&name@example.com")); + } + + @Test + void testDomainParts() { + assertTrue(EmailValidator.isValidEmail("email@example.com")); + assertTrue(EmailValidator.isValidEmail("email@example.co.uk")); + assertTrue(EmailValidator.isValidEmail("email@sub.domain.example.com")); + assertFalse(EmailValidator.isValidEmail("email@.com")); + assertFalse(EmailValidator.isValidEmail("email@example.")); + } + + @Test + void testTLD() { + assertTrue(EmailValidator.isValidEmail("email@example.com")); + assertTrue(EmailValidator.isValidEmail("email@example.org")); + assertTrue(EmailValidator.isValidEmail("email@example.net")); + assertTrue(EmailValidator.isValidEmail("email@example.info")); + assertTrue(EmailValidator.isValidEmail("email@example.museum")); + assertTrue(EmailValidator.isValidEmail("email@example.co.jp")); + assertFalse(EmailValidator.isValidEmail("email@example.c")); + assertFalse(EmailValidator.isValidEmail("email@example.1com")); + } +} diff --git a/src/aiunittests/java/MakeItFit/utils/ExtendedRandomTest.java b/src/aiunittests/java/MakeItFit/utils/ExtendedRandomTest.java new file mode 100644 index 0000000..6938b95 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/utils/ExtendedRandomTest.java @@ -0,0 +1,62 @@ +package MakeItFit.utils; + +import java.util.HashSet; +import java.util.Set; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class ExtendedRandomTest { + + @Test + void testNextIntWithRange() { + ExtendedRandom random = new ExtendedRandom(12345); + int origin = 10; + int bound = 20; + + // Test multiple times to ensure consistency + for (int i = 0; i < 1000; i++) { + int value = random.nextInt(origin, bound); + assertTrue(value >= origin && value < bound, + "Value should be between " + origin + " (inclusive) and " + bound + + " (exclusive)"); + } + } + + @Test + void testNextIntWithRangeDistribution() { + ExtendedRandom random = new ExtendedRandom(67890); + int origin = 5; + int bound = 15; + Set values = new HashSet<>(); + + // Test if we get a reasonable distribution of values + for (int i = 0; i < 1000; i++) { + values.add(random.nextInt(origin, bound)); + } + + assertEquals(bound - origin, values.size(), "Should get all possible values in the range"); + } + + @Test + void testNextIntWithNegativeRange() { + ExtendedRandom random = new ExtendedRandom(); + int value = random.nextInt(-10, 10); + assertTrue(value >= -10 && value < 10); + } + + @Test + void testNextIntWithSameBounds() { + ExtendedRandom random = new ExtendedRandom(); + assertThrows(IllegalArgumentException.class, () -> { random.nextInt(10, 10); }); + } + + @Test + void testNextIntWithInvalidBounds() { + ExtendedRandom random = new ExtendedRandom(); + assertThrows(IllegalArgumentException.class, () -> { random.nextInt(20, 10); }); + } +} diff --git a/src/aiunittests/java/MakeItFit/utils/MakeItFitDateTest.java b/src/aiunittests/java/MakeItFit/utils/MakeItFitDateTest.java new file mode 100644 index 0000000..45f4f89 --- /dev/null +++ b/src/aiunittests/java/MakeItFit/utils/MakeItFitDateTest.java @@ -0,0 +1,99 @@ +package MakeItFit.utils; + +import java.time.LocalDate; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class MakeItFitDateTest { + + @Test + void testDefaultConstructor() { + MakeItFitDate date = new MakeItFitDate(); + assertEquals(LocalDate.now(), date.getDate()); + } + + @Test + void testOfConstructor() { + MakeItFitDate date = MakeItFitDate.of(2023, 5, 15); + assertEquals(15, date.getDayOfMonth()); + assertEquals(5, date.getMonth()); + assertEquals(2023, date.getYear()); + } + + @Test + void testFromStringValid() { + MakeItFitDate date = MakeItFitDate.fromString("15/05/2023"); + assertEquals(15, date.getDayOfMonth()); + assertEquals(5, date.getMonth()); + assertEquals(2023, date.getYear()); + } + + @Test + void testFromStringInvalid() { + assertThrows(IllegalArgumentException.class, () -> MakeItFitDate.fromString("15-05-2023")); + assertThrows(IllegalArgumentException.class, () -> MakeItFitDate.fromString("15/05")); + assertThrows(IllegalArgumentException.class, () -> MakeItFitDate.fromString("invalid")); + } + + @Test + void testDateComparisons() { + MakeItFitDate date1 = MakeItFitDate.of(2023, 5, 15); + MakeItFitDate date2 = MakeItFitDate.of(2023, 5, 16); + + assertTrue(date1.isBefore(date2)); + assertTrue(date2.isAfter(date1)); + assertTrue(date1.isBeforeOrSame(date1)); + assertTrue(date1.isAfterOrSame(date1)); + } + + @Test + void testPlusDays() { + MakeItFitDate date = MakeItFitDate.of(2023, 5, 15); + MakeItFitDate newDate = date.plusDays(5); + assertEquals(20, newDate.getDayOfMonth()); + } + + @Test + void testDistance() { + MakeItFitDate date1 = MakeItFitDate.of(2023, 5, 15); + MakeItFitDate date2 = MakeItFitDate.of(2023, 5, 20); + assertEquals(5, date1.distance(date2)); + } + + @Test + void testToString() { + MakeItFitDate date = MakeItFitDate.of(2023, 5, 15); + assertEquals("15/05/2023", date.toString()); + } + + @Test + void testEquals() { + MakeItFitDate date1 = MakeItFitDate.of(2023, 5, 15); + MakeItFitDate date2 = MakeItFitDate.of(2023, 5, 15); + MakeItFitDate date3 = MakeItFitDate.of(2023, 5, 16); + + assertEquals(date1, date2); + assertNotEquals(date1, date3); + } + + @Test + void testClone() { + MakeItFitDate original = MakeItFitDate.of(2023, 5, 15); + MakeItFitDate cloned = original.clone(); + + assertEquals(original, cloned); + assertNotSame(original, cloned); + } + + @Test + void testDayOfWeek() { + MakeItFitDate date = MakeItFitDate.of(2023, 5, 15); // May 15, 2023 is a Monday + assertEquals(1, date.getDayOfWeek()); + } +} diff --git a/src/aiunittests/java/MakeItFit/utils/MyTupleTest.java b/src/aiunittests/java/MakeItFit/utils/MyTupleTest.java new file mode 100644 index 0000000..66ab34c --- /dev/null +++ b/src/aiunittests/java/MakeItFit/utils/MyTupleTest.java @@ -0,0 +1,64 @@ +package MakeItFit.utils; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class MyTupleTest { + + @Test + void testTupleCreationAndGetters() { + MyTuple tuple = new MyTuple<>("Test", 42); + assertEquals("Test", tuple.getItem1()); + assertEquals(42, tuple.getItem2()); + } + + @Test + void testToString() { + MyTuple tuple = new MyTuple<>("Price", 19.99); + assertEquals("(Price, 19.99)", tuple.toString()); + } + + @Test + void testEquals() { + MyTuple tuple1 = new MyTuple<>(1, "One"); + MyTuple tuple2 = new MyTuple<>(1, "One"); + MyTuple tuple3 = new MyTuple<>(2, "Two"); + + assertEquals(tuple1, tuple2); + assertNotEquals(tuple1, tuple3); + assertNotEquals(tuple1, null); + assertNotEquals(tuple1, "Not a tuple"); + } + + @Test + void testCompareTo() { + MyTuple tuple1 = new MyTuple<>("A", 1); + MyTuple tuple2 = new MyTuple<>("A", 2); + MyTuple tuple3 = new MyTuple<>("B", 1); + + assertTrue(tuple1.compareTo(tuple2) < 0); + assertTrue(tuple2.compareTo(tuple1) > 0); + assertTrue(tuple1.compareTo(tuple3) < 0); + assertEquals(0, tuple1.compareTo(new MyTuple<>("A", 1))); + } + + @Test + void testClone() { + MyTuple original = new MyTuple<>("Key", "Value"); + MyTuple cloned = original.clone(); + + assertEquals(original, cloned); + assertNotSame(original, cloned); + } + + @Test + void testWithDifferentTypes() { + MyTuple tuple = new MyTuple<>(123, true); + assertEquals(123, tuple.getItem1()); + assertTrue(tuple.getItem2()); + } +}