From 306257f42b81458264b66f2f4e765864feb378bb Mon Sep 17 00:00:00 2001 From: Mariana Date: Thu, 1 May 2025 13:34:11 +0100 Subject: [PATCH 1/6] created files --- src/unittests/java/MakeItFit/MakeItFitTest.java | 5 +++++ .../java/MakeItFit/activities/ActivityManagerTest.java | 5 +++++ src/unittests/java/MakeItFit/activities/ActivityTest.java | 5 +++++ .../java/MakeItFit/activities/implementation/PushUpTest.java | 5 +++++ .../MakeItFit/activities/implementation/RunningTest.java | 5 +++++ .../java/MakeItFit/activities/implementation/TrailTest.java | 5 +++++ .../MakeItFit/activities/implementation/WeightSquatTest.java | 5 +++++ .../java/MakeItFit/activities/types/DistanceTest.java | 5 +++++ .../activities/types/DistanceWithAltimetryTest.java | 5 +++++ .../java/MakeItFit/activities/types/RepetitionsTest.java | 5 +++++ .../activities/types/RepetitionsWithWeightsTest.java | 5 +++++ 11 files changed, 55 insertions(+) create mode 100644 src/unittests/java/MakeItFit/MakeItFitTest.java create mode 100644 src/unittests/java/MakeItFit/activities/ActivityManagerTest.java create mode 100644 src/unittests/java/MakeItFit/activities/ActivityTest.java create mode 100644 src/unittests/java/MakeItFit/activities/implementation/PushUpTest.java create mode 100644 src/unittests/java/MakeItFit/activities/implementation/RunningTest.java create mode 100644 src/unittests/java/MakeItFit/activities/implementation/TrailTest.java create mode 100644 src/unittests/java/MakeItFit/activities/implementation/WeightSquatTest.java create mode 100644 src/unittests/java/MakeItFit/activities/types/DistanceTest.java create mode 100644 src/unittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java create mode 100644 src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java create mode 100644 src/unittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java diff --git a/src/unittests/java/MakeItFit/MakeItFitTest.java b/src/unittests/java/MakeItFit/MakeItFitTest.java new file mode 100644 index 0000000..5b8335b --- /dev/null +++ b/src/unittests/java/MakeItFit/MakeItFitTest.java @@ -0,0 +1,5 @@ +package MakeItFit; + +public class MakeItFitTest { + +} diff --git a/src/unittests/java/MakeItFit/activities/ActivityManagerTest.java b/src/unittests/java/MakeItFit/activities/ActivityManagerTest.java new file mode 100644 index 0000000..5f9e779 --- /dev/null +++ b/src/unittests/java/MakeItFit/activities/ActivityManagerTest.java @@ -0,0 +1,5 @@ +package MakeItFit.activities; + +public class ActivityManagerTest { + +} diff --git a/src/unittests/java/MakeItFit/activities/ActivityTest.java b/src/unittests/java/MakeItFit/activities/ActivityTest.java new file mode 100644 index 0000000..54284f3 --- /dev/null +++ b/src/unittests/java/MakeItFit/activities/ActivityTest.java @@ -0,0 +1,5 @@ +package MakeItFit.activities; + +public class ActivityTest { + +} diff --git a/src/unittests/java/MakeItFit/activities/implementation/PushUpTest.java b/src/unittests/java/MakeItFit/activities/implementation/PushUpTest.java new file mode 100644 index 0000000..6fb2d35 --- /dev/null +++ b/src/unittests/java/MakeItFit/activities/implementation/PushUpTest.java @@ -0,0 +1,5 @@ +package MakeItFit.activities.implementation; + +public class PushUpTest { + +} diff --git a/src/unittests/java/MakeItFit/activities/implementation/RunningTest.java b/src/unittests/java/MakeItFit/activities/implementation/RunningTest.java new file mode 100644 index 0000000..e0ab337 --- /dev/null +++ b/src/unittests/java/MakeItFit/activities/implementation/RunningTest.java @@ -0,0 +1,5 @@ +package MakeItFit.activities.implementation; + +public class RunningTest { + +} diff --git a/src/unittests/java/MakeItFit/activities/implementation/TrailTest.java b/src/unittests/java/MakeItFit/activities/implementation/TrailTest.java new file mode 100644 index 0000000..e9fe69d --- /dev/null +++ b/src/unittests/java/MakeItFit/activities/implementation/TrailTest.java @@ -0,0 +1,5 @@ +package MakeItFit.activities.implementation; + +public class TrailTest { + +} diff --git a/src/unittests/java/MakeItFit/activities/implementation/WeightSquatTest.java b/src/unittests/java/MakeItFit/activities/implementation/WeightSquatTest.java new file mode 100644 index 0000000..af1576f --- /dev/null +++ b/src/unittests/java/MakeItFit/activities/implementation/WeightSquatTest.java @@ -0,0 +1,5 @@ +package MakeItFit.activities.implementation; + +public class WeightSquatTest { + +} diff --git a/src/unittests/java/MakeItFit/activities/types/DistanceTest.java b/src/unittests/java/MakeItFit/activities/types/DistanceTest.java new file mode 100644 index 0000000..d20f9c9 --- /dev/null +++ b/src/unittests/java/MakeItFit/activities/types/DistanceTest.java @@ -0,0 +1,5 @@ +package MakeItFit.activities.types; + +public class DistanceTest { + +} diff --git a/src/unittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java b/src/unittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java new file mode 100644 index 0000000..fe82aff --- /dev/null +++ b/src/unittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java @@ -0,0 +1,5 @@ +package MakeItFit.activities.types; + +public class DistanceWithAltimetryTest { + +} diff --git a/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java b/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java new file mode 100644 index 0000000..4dc176e --- /dev/null +++ b/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java @@ -0,0 +1,5 @@ +package MakeItFit.activities.types; + +public class RepetitionsTest { + +} diff --git a/src/unittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java b/src/unittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java new file mode 100644 index 0000000..ceb3493 --- /dev/null +++ b/src/unittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java @@ -0,0 +1,5 @@ +package MakeItFit.activities.types; + +public class RepetitionsWithWeightsTest { + +} From 93526c157a2d0ad71c2ee4b86c681fad2a0f0171 Mon Sep 17 00:00:00 2001 From: Mariana Date: Thu, 1 May 2025 14:07:26 +0100 Subject: [PATCH 2/6] feat: ActivityTest --- .../java/MakeItFit/activities/Activity.java | 9 + .../MakeItFit/activities/ActivityTest.java | 192 +++++++++++++++++- 2 files changed, 200 insertions(+), 1 deletion(-) diff --git a/src/main/java/MakeItFit/activities/Activity.java b/src/main/java/MakeItFit/activities/Activity.java index 6fdb6ee..db52d78 100644 --- a/src/main/java/MakeItFit/activities/Activity.java +++ b/src/main/java/MakeItFit/activities/Activity.java @@ -215,6 +215,15 @@ public void setSpecialization(String specialization) { this.specialization = specialization; } + /** + * Gets the specialization of the activity. + * + * @return the specialization of the activity + */ + public String getSpecialization() { + return this.specialization; + } + /** * Gets the specialization of the activity. * diff --git a/src/unittests/java/MakeItFit/activities/ActivityTest.java b/src/unittests/java/MakeItFit/activities/ActivityTest.java index 54284f3..a432115 100644 --- a/src/unittests/java/MakeItFit/activities/ActivityTest.java +++ b/src/unittests/java/MakeItFit/activities/ActivityTest.java @@ -1,5 +1,195 @@ package MakeItFit.activities; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; + +import MakeItFit.utils.MakeItFitDate; + +import java.util.UUID; + public class ActivityTest { - + + private MakeItFitDate createDate(int year, int month, int day) { + return MakeItFitDate.of(year, month, day); + } + + @Test + void testDefaultConstructor() { + TestActivity activity = new TestActivity(); + + assertEquals(new UUID(0L, 0L), activity.getUserCode()); + assertNotNull(activity.getCode()); + assertNotNull(activity.getRealizationDate()); + assertEquals(0, activity.getExpectedDuration()); + assertEquals("", activity.getDesignation()); + assertEquals("", activity.getName()); + assertEquals(0, activity.getDuration()); + assertEquals(0, activity.getCaloricWaste()); + } + + @Test + void testParameterizedConstructor() { + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = createDate(2024, 5, 15); + TestActivity activity = new TestActivity(userCode, date, 60, "Class", "Dancing"); + + assertEquals(userCode, activity.getUserCode()); + assertEquals(date, activity.getRealizationDate()); + assertEquals(60, activity.getExpectedDuration()); + assertEquals("Class", activity.getDesignation()); + assertEquals("Dancing", activity.getName()); + assertNotNull(activity.getCode()); + assertEquals(0, activity.getDuration()); + assertEquals(0, activity.getCaloricWaste()); + } + + @Test + void testCopyConstructor() { + TestActivity original = new TestActivity(UUID.randomUUID(), createDate(2024, 5, 15), 60, "Class", "Body Pump"); + original.setDuration(30); + original.setCaloricWaste(200); + + TestActivity copy = new TestActivity(original); + + assertEquals(original.getUserCode(), copy.getUserCode()); + assertEquals(original.getCode(), copy.getCode()); + assertEquals(original.getRealizationDate(), copy.getRealizationDate()); + assertEquals(original.getExpectedDuration(), copy.getExpectedDuration()); + assertEquals(original.getDesignation(), copy.getDesignation()); + assertEquals(original.getName(), copy.getName()); + assertEquals(original.getDuration(), copy.getDuration()); + assertEquals(original.getCaloricWaste(), copy.getCaloricWaste()); + } + + @Test + void testSettersAndGetters() { + TestActivity activity = new TestActivity(); + + activity.setExpectedDuration(90); + assertEquals(90, activity.getExpectedDuration()); + + activity.setDesignation("Pilates"); + assertEquals("Pilates", activity.getDesignation()); + + activity.setDuration(45); + assertEquals(45, activity.getDuration()); + + activity.setCaloricWaste(300); + assertEquals(300, activity.getCaloricWaste()); + } + + @Test + void testEquals() { + MakeItFitDate date = createDate(2024, 5, 15); + TestActivity activity1 = new TestActivity(UUID.randomUUID(), date, 60, "Workout", "Pilates"); + TestActivity activity2 = new TestActivity(UUID.randomUUID(), date, 60, "Workout", "Pilates"); + + assertTrue(activity1.equals(activity1)); + assertTrue(activity1.equals(activity2)); + + TestActivity activity3 = new TestActivity(UUID.randomUUID(), date, 30, "Workout", "Pilates"); + assertFalse(activity1.equals(activity3)); + + TestActivity activity4 = new TestActivity(UUID.randomUUID(), date, 60, "Exercise", "Pilates"); + assertFalse(activity1.equals(activity4)); + + assertFalse(activity1.equals(new Object())); + } + + @Test + void testCompareTo() { + MakeItFitDate date1 = createDate(2024, 5, 15); + MakeItFitDate date2 = createDate(2024, 5, 16); + TestActivity activity1 = new TestActivity(UUID.randomUUID(), date1, 60, "Workout", "Pilates"); + TestActivity activity2 = new TestActivity(UUID.randomUUID(), date2, 60, "Workout", "Body Pump"); + TestActivity activity3 = new TestActivity(UUID.randomUUID(), date1, 30, "Workout", "Pilates"); + TestActivity activity4 = new TestActivity(UUID.randomUUID(), date1, 60, "Workout", "Body Pump"); + + assertTrue(activity1.compareTo(activity2) < 0); + assertTrue(activity2.compareTo(activity1) > 0); + assertTrue(activity1.compareTo(activity3) > 0); + assertEquals(0, activity1.compareTo(activity4)); + } + + @Test + void testToString() { + TestActivity activity = new TestActivity(UUID.randomUUID(), createDate(2024, 5, 15), 60, "Workout", "Biking"); + activity.setCaloricWaste(300); + + String result = activity.toString(); + assertTrue(result.contains("Biking")); + assertTrue(result.contains("Workout")); + assertTrue(result.contains("60")); + assertTrue(result.contains("15/05/2024")); + assertTrue(result.contains("300")); + } + + @Test + void testUpdateActivity() { + TestActivity activity = new TestActivity(); + activity.updateActivity(5.0f); + assertEquals(500, activity.getCaloricWaste()); + } + + @Test + void testSpecialization() { + TestActivity activity = new TestActivity(); + activity.setSpecialization("Pilates"); + assertEquals("Pilates", activity.getSpecialization()); + } + + @Test + void testClone() { + TestActivity original = new TestActivity(UUID.randomUUID(), + createDate(2024, 5, 15), 60, "Class", "Body Combat"); + TestActivity clone = original.clone(); + + assertNotSame(original, clone); + assertEquals(original.getUserCode(), clone.getUserCode()); + assertEquals(original.getCode(), clone.getCode()); + assertEquals(original.getRealizationDate(), clone.getRealizationDate()); + assertEquals(original.getExpectedDuration(), clone.getExpectedDuration()); + assertEquals(original.getDesignation(), clone.getDesignation()); + assertEquals(original.getName(), clone.getName()); + assertEquals(original.getDuration(), clone.getDuration()); + assertEquals(original.getCaloricWaste(), clone.getCaloricWaste()); + } +} + +class TestActivity extends Activity { + + public TestActivity() { + super(); + } + + public String getSpecialization() { + return super.getSpecialization(); + } + + public void setSpecialization(String specialization) { + super.setSpecialization(specialization); + } + + public TestActivity(UUID userCode, MakeItFitDate realizationDate, int expectedDuration, String designation, String name) { + super(userCode, realizationDate, expectedDuration, designation, name); + } + + public TestActivity(TestActivity a) { + super(a); + } + + @Override + public void calculateCaloricWaste(float index) { + setCaloricWaste((int) (index * 100)); + } + + @Override + public TestActivity clone() { + return new TestActivity(this); + } + + @Override + public int caloricWaste(float index) { + throw new UnsupportedOperationException("Abstract method not implemented"); + } } From 7cab3e3af85af96907480e3b18aedf91c5bbe250 Mon Sep 17 00:00:00 2001 From: Mariana Date: Thu, 1 May 2025 14:26:06 +0100 Subject: [PATCH 3/6] feat: ActivityManager --- .../activities/ActivityManagerTest.java | 62 ++++++++++++++++++- .../MakeItFit/activities/ActivityTest.java | 1 + 2 files changed, 62 insertions(+), 1 deletion(-) diff --git a/src/unittests/java/MakeItFit/activities/ActivityManagerTest.java b/src/unittests/java/MakeItFit/activities/ActivityManagerTest.java index 5f9e779..1df5094 100644 --- a/src/unittests/java/MakeItFit/activities/ActivityManagerTest.java +++ b/src/unittests/java/MakeItFit/activities/ActivityManagerTest.java @@ -1,5 +1,65 @@ package MakeItFit.activities; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; +import java.lang.reflect.Field; +import java.util.*; + public class ActivityManagerTest { - + + private static final List EXPECTED_ACTIVITIES = + Arrays.asList("PushUp", "Running", "Trail", "WeightSquat"); + + @Test + void testActivitiesListIsCorrect() throws Exception { + Field activitiesField = ActivityManager.class.getDeclaredField("activities"); + activitiesField.setAccessible(true); + List actualActivities = (List) activitiesField.get(null); + + assertEquals(EXPECTED_ACTIVITIES, actualActivities); + } + + @Test + void testGetRandomActivityReturnsValidActivity() { + ActivityManager manager = new ActivityManager(); + for (int i = 0; i < 100; i++) { + String activity = manager.getRandomActivity(); + assertTrue(EXPECTED_ACTIVITIES.contains(activity)); + } + } + + @Test + void testAllActivitiesAreEventuallyReturned() { + ActivityManager manager = new ActivityManager(); + Set returnedActivities = new HashSet<>(); + + for (int i = 0; i < 100; i++) { + returnedActivities.add(manager.getRandomActivity()); + } + + assertEquals(EXPECTED_ACTIVITIES.size(), returnedActivities.size()); + assertTrue(returnedActivities.containsAll(EXPECTED_ACTIVITIES)); + } + + @Test + void testControlledRandomWithReflection() throws Exception { + ActivityManager manager = new ActivityManager(); + + Random controlledRandom = new Random() { + private int[] values = {1, 2}; + private int index = 0; + + @Override + public int nextInt(int bound) { + return values[index++]; + } + }; + + Field randomField = ActivityManager.class.getDeclaredField("random"); + randomField.setAccessible(true); + randomField.set(manager, controlledRandom); + + assertEquals("Running", manager.getRandomActivity()); + assertEquals("Trail", manager.getRandomActivity()); + } } diff --git a/src/unittests/java/MakeItFit/activities/ActivityTest.java b/src/unittests/java/MakeItFit/activities/ActivityTest.java index a432115..be28afe 100644 --- a/src/unittests/java/MakeItFit/activities/ActivityTest.java +++ b/src/unittests/java/MakeItFit/activities/ActivityTest.java @@ -145,6 +145,7 @@ void testClone() { TestActivity clone = original.clone(); assertNotSame(original, clone); + assertTrue(original.equals(clone)); assertEquals(original.getUserCode(), clone.getUserCode()); assertEquals(original.getCode(), clone.getCode()); assertEquals(original.getRealizationDate(), clone.getRealizationDate()); From b1a3eecb1729470bb87500dbea0fba99cb5f2146 Mon Sep 17 00:00:00 2001 From: Mariana Date: Fri, 9 May 2025 20:39:57 +0100 Subject: [PATCH 4/6] more junit tests (activities implementation and types) --- .../activities/implementation/Trail.java | 5 +- .../java/MakeItFit/MakeItFitTest.java | 2 +- .../activities/implementation/PushUpTest.java | 87 +++++++++++- .../implementation/RunningTest.java | 87 +++++++++++- .../activities/implementation/TrailTest.java | 102 +++++++++++++- .../implementation/WeightSquatTest.java | 104 +++++++++++++- .../activities/types/DistanceTest.java | 117 +++++++++++++++- .../types/DistanceWithAltimetryTest.java | 127 +++++++++++++++++- .../activities/types/RepetitionsTest.java | 122 ++++++++++++++++- .../types/RepetitionsWithWeightsTest.java | 118 +++++++++++++++- 10 files changed, 861 insertions(+), 10 deletions(-) diff --git a/src/main/java/MakeItFit/activities/implementation/Trail.java b/src/main/java/MakeItFit/activities/implementation/Trail.java index 72064fc..1afcfbc 100644 --- a/src/main/java/MakeItFit/activities/implementation/Trail.java +++ b/src/main/java/MakeItFit/activities/implementation/Trail.java @@ -92,13 +92,16 @@ public int getTrailType() { * @param trailType The trail type to set (easy, medium, or hard). */ public void setTrailType(int trailType) { + /* Changed because of the pit mutation if (trailType < TRAIL_TYPE_EASY) { this.trailType = TRAIL_TYPE_EASY; } else if (trailType > TRAIL_TYPE_HARD) { this.trailType = TRAIL_TYPE_HARD; } else { this.trailType = trailType; - } + }*/ + this.trailType = Math.max(TRAIL_TYPE_EASY, Math.min(TRAIL_TYPE_HARD, trailType)); + } /** diff --git a/src/unittests/java/MakeItFit/MakeItFitTest.java b/src/unittests/java/MakeItFit/MakeItFitTest.java index 5b8335b..6836254 100644 --- a/src/unittests/java/MakeItFit/MakeItFitTest.java +++ b/src/unittests/java/MakeItFit/MakeItFitTest.java @@ -1,5 +1,5 @@ package MakeItFit; public class MakeItFitTest { - + } diff --git a/src/unittests/java/MakeItFit/activities/implementation/PushUpTest.java b/src/unittests/java/MakeItFit/activities/implementation/PushUpTest.java index 6fb2d35..b99fe3b 100644 --- a/src/unittests/java/MakeItFit/activities/implementation/PushUpTest.java +++ b/src/unittests/java/MakeItFit/activities/implementation/PushUpTest.java @@ -1,5 +1,90 @@ package MakeItFit.activities.implementation; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + public class PushUpTest { - + private PushUp pushUp; + private UUID userCode; + private MakeItFitDate date; + + private MakeItFitDate createDate(int year, int month, int day) { + return MakeItFitDate.of(year, month, day); + } + + @BeforeEach + void setUp() { + userCode = UUID.randomUUID(); + date = createDate(2025,10,5); + pushUp = new PushUp(userCode, date, 30, "You got this!", "Push-Ups", 5, 4); + } + + @Test + void testGetters() { + assertEquals(5, pushUp.getRepetitions()); + assertEquals(4, pushUp.getSeries()); + assertEquals("PushUp", pushUp.getSpecialization()); + assertEquals("Push-Ups", pushUp.getName()); + assertEquals("You got this!", pushUp.getDesignation()); + assertEquals(30, pushUp.getExpectedDuration()); + assertEquals(date, pushUp.getRealizationDate()); + assertEquals(userCode, pushUp.getUserCode()); + } + + @Test + void testConstructor() { + PushUp defaultP = new PushUp(); + assertEquals(0, defaultP.getRepetitions()); + assertEquals(0, defaultP.getSeries()); + assertEquals("PushUp", defaultP.getSpecialization()); + + PushUp copyP = new PushUp(pushUp); + assertEquals(pushUp, copyP); + assertNotSame(pushUp, copyP); + } + + @Test + void testCalculateCaloricWaste() { + float index = 2f; + int expected = (int) (5 * 4 * 2 * 0.1); + pushUp.calculateCaloricWaste(index); + assertEquals(expected, pushUp.getCaloricWaste()); + } + + @Test + void testCaloricWasteMethod() { + float index = 1.5f; + int expected = (int) (5 * 4 * 1.5 * 0.1); + assertEquals(expected, pushUp.caloricWaste(index)); + } + + @Test + void testToString() { + String output = pushUp.toString(); + assertTrue(output.contains("Repetitions: 5")); + assertTrue(output.contains("Series: 4")); + } + + @Test + void testEquals() { + PushUp same = new PushUp(userCode, date, 30, "You got this!", "Push-Ups", 5, 4); + assertTrue(pushUp.equals(same)); + assertTrue(pushUp.equals(pushUp)); + + PushUp diff = new PushUp(userCode, date, 30, "You got this!", "Push-Ups", 15, 4); + assertFalse(pushUp.equals(diff)); + assertFalse(pushUp.equals(null)); + } + + @Test + void testClone() { + PushUp cloned = pushUp.clone(); + assertNotSame(pushUp, cloned); + assertEquals(pushUp, cloned); + } } diff --git a/src/unittests/java/MakeItFit/activities/implementation/RunningTest.java b/src/unittests/java/MakeItFit/activities/implementation/RunningTest.java index e0ab337..daba4ed 100644 --- a/src/unittests/java/MakeItFit/activities/implementation/RunningTest.java +++ b/src/unittests/java/MakeItFit/activities/implementation/RunningTest.java @@ -1,5 +1,90 @@ package MakeItFit.activities.implementation; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + public class RunningTest { - + private Running running; + private UUID userCode; + private MakeItFitDate date; + + private MakeItFitDate createDate(int year, int month, int day) { + return MakeItFitDate.of(year, month, day); + } + + @BeforeEach + void setUp() { + userCode = UUID.randomUUID(); + date = createDate(2025, 12, 25); + running = new Running(userCode, date, 45, "Warming", "Just for 45 minutes", 5000.0, 10.0); + } + + @Test + void testGetters() { + assertEquals(5000.0, running.getDistance()); + assertEquals(10.0, running.getSpeed()); + assertEquals("Running", running.getSpecialization()); + assertEquals("Just for 45 minutes", running.getName()); + assertEquals("Warming", running.getDesignation()); + assertEquals(45, running.getExpectedDuration()); + assertEquals(date, running.getRealizationDate()); + assertEquals(userCode, running.getUserCode()); + } + + @Test + void testConstructors() { + Running defaultRunning = new Running(); + assertEquals(0.0, defaultRunning.getDistance()); + defaultRunning.setSpeed(0.0); + assertEquals(0.0, defaultRunning.getSpeed()); + assertEquals("Running", defaultRunning.getSpecialization()); + + Running copy = new Running(running); + assertEquals(running, copy); + assertNotSame(running, copy); + } + + @Test + void testCalculateCaloricWaste() { + float index = 1.5f; + int expected = (int) (10.0 * 5000.0 * 1.5 * 0.005); + running.calculateCaloricWaste(index); + assertEquals(expected, running.getCaloricWaste()); + } + + @Test + void testCaloricWasteMethod() { + float index = 2.0f; + int expected = (int) (10.0 * 5000.0 * 2.0 * 0.005); + assertEquals(expected, running.caloricWaste(index)); + } + + @Test + void testToString() { + String output = running.toString(); + assertTrue(output.contains("Speed: 10.0 Km/h")); + } + + @Test + void testEquals() { + Running same = new Running(userCode, date, 45, "Warming", "Just for 45 minutes", 5000.0, 10.0); + assertTrue(running.equals(same)); + assertTrue(running.equals(running)); + + Running diff = new Running(userCode, date, 45, "Warming", "Just for 45 minutes", 5000.0, 12.0); + assertFalse(running.equals(diff)); + assertFalse(running.equals(null)); + } + + @Test + void testClone() { + Running cloned = running.clone(); + assertNotSame(running, cloned); + assertEquals(running, cloned); + } } diff --git a/src/unittests/java/MakeItFit/activities/implementation/TrailTest.java b/src/unittests/java/MakeItFit/activities/implementation/TrailTest.java index e9fe69d..6193539 100644 --- a/src/unittests/java/MakeItFit/activities/implementation/TrailTest.java +++ b/src/unittests/java/MakeItFit/activities/implementation/TrailTest.java @@ -1,5 +1,105 @@ package MakeItFit.activities.implementation; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.UUID; + +import static MakeItFit.activities.implementation.Trail.*; +import static org.junit.jupiter.api.Assertions.*; + public class TrailTest { - + private Trail trail; + private UUID userCode; + private MakeItFitDate date; + + private MakeItFitDate createDate(int year, int month, int day) { + return MakeItFitDate.of(year, month, day); + } + + @BeforeEach + void setUp() { + userCode = UUID.randomUUID(); + date = createDate(2025, 12, 25); + trail = new Trail(userCode, date, 90, "Easy peasy lemon squeezy", "Trail", 10000, 500, 200, TRAIL_TYPE_EASY); + } + + @Test + void testGetters() { + assertEquals(10000, trail.getDistance()); + assertEquals(500, trail.getElevationGain()); + assertEquals(200, trail.getElevationLoss()); + assertEquals(TRAIL_TYPE_EASY, trail.getTrailType()); + assertEquals("Trail", trail.getSpecialization()); + } + + @Test + void testConstructors() { + Trail defaultTrail = new Trail(); + assertEquals(0, defaultTrail.getDistance()); + assertEquals(TRAIL_TYPE_EASY, defaultTrail.getTrailType()); + assertEquals("Trail", defaultTrail.getSpecialization()); + + Trail copy = new Trail(trail); + assertEquals(trail, copy); + assertNotSame(trail, copy); + } + + @Test + void testSetTrailType() { + trail.setTrailType(-10); + assertEquals(TRAIL_TYPE_EASY, trail.getTrailType()); + + trail.setTrailType(99); + assertEquals(TRAIL_TYPE_HARD, trail.getTrailType()); + + trail.setTrailType(TRAIL_TYPE_EASY); + assertEquals(TRAIL_TYPE_EASY, trail.getTrailType()); + + trail.setTrailType(TRAIL_TYPE_MEDIUM); + assertEquals(TRAIL_TYPE_MEDIUM, trail.getTrailType()); + + trail.setTrailType(TRAIL_TYPE_HARD); + assertEquals(TRAIL_TYPE_HARD, trail.getTrailType()); + } + + @Test + void testCalculateCaloricWaste() { + float index = 2.0f; + int expected = (int) ((10000 * 0.5 + 500 * 0.1 - 200 * 0.1) * index * 0.01); + trail.calculateCaloricWaste(index); + assertEquals(expected, trail.getCaloricWaste()); + } + + @Test + void testCaloricWasteMethod() { + float index = 1.5f; + int expected = (int) ((10000 * 0.5 + 500 * 0.1 - 200 * 0.1) * index * 0.01); + assertEquals(expected, trail.caloricWaste(index)); + } + + @Test + void testToStringIncludesTrailType() { + String output = trail.toString(); + assertTrue(output.contains("Trail Type: " + TRAIL_TYPE_EASY)); + } + + @Test + void testEquals() { + Trail same = new Trail(userCode, date, 90, "Easy peasy lemon squeezy", "Trail", 10000, 500, 200, TRAIL_TYPE_EASY); + assertTrue(trail.equals(same)); + assertTrue(trail.equals(trail)); + + Trail diff = new Trail(userCode, date, 90, "Easy peasy lemon squeezy", "Trail", 10000, 500, 200, TRAIL_TYPE_HARD); + assertFalse(trail.equals(diff)); + assertFalse(trail.equals(null)); + } + + @Test + void testClone() { + Trail cloned = trail.clone(); + assertNotSame(trail, cloned); + assertEquals(trail, cloned); + } } diff --git a/src/unittests/java/MakeItFit/activities/implementation/WeightSquatTest.java b/src/unittests/java/MakeItFit/activities/implementation/WeightSquatTest.java index af1576f..6124a57 100644 --- a/src/unittests/java/MakeItFit/activities/implementation/WeightSquatTest.java +++ b/src/unittests/java/MakeItFit/activities/implementation/WeightSquatTest.java @@ -1,5 +1,107 @@ package MakeItFit.activities.implementation; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + public class WeightSquatTest { - + + private UUID userCode; + private MakeItFitDate date; + private WeightSquat squat; + + private MakeItFitDate createDate(int year, int month, int day) { + return MakeItFitDate.of(year, month, day); + } + + @BeforeEach + void setUp() { + userCode = UUID.randomUUID(); + date = createDate(2025, 12, 25); + squat = new WeightSquat(userCode, date, 30, "Get ready for summer!", "Squat", 10, 3, 50); + } + + @Test + void testGetters() { + assertEquals(userCode, squat.getUserCode()); + assertEquals(date, squat.getRealizationDate()); + assertEquals(30, squat.getExpectedDuration()); + assertEquals("Get ready for summer!", squat.getDesignation()); + assertEquals("Squat", squat.getName()); + assertEquals(10, squat.getRepetitions()); + assertEquals(3, squat.getSeries()); + assertEquals(50, squat.getWeight()); + assertEquals("WeightSquat", squat.getSpecialization()); + } + + @Test + void testConstructors() { + WeightSquat defaultSquat = new WeightSquat(); + assertEquals("WeightSquat", defaultSquat.getSpecialization()); + assertEquals(0, defaultSquat.getRepetitions()); + assertEquals(0, defaultSquat.getSeries()); + assertEquals(0, defaultSquat.getWeight()); + + WeightSquat copy = new WeightSquat(squat); + assertEquals(squat, copy); + assertNotSame(squat, copy); + } + + @Test + void testCaloricWasteCalculation() { + float index = 0f; + int expected = 0; + assertEquals(expected, squat.caloricWaste(index)); + + index = 1f; + expected = (int) (10 * 3 * 50 * 0.2 * index * 0.5); + assertEquals(expected, squat.caloricWaste(index)); + + index = -1f; + expected = (int) (10 * 3 * 50 * 0.2 * index * 0.5); + assertEquals(expected, squat.caloricWaste(index)); + + index = Float.MAX_VALUE; + expected = (int) (10 * 3 * 50 * 0.2 * index * 0.5); + assertEquals(expected, squat.caloricWaste(index)); + + index = Float.MIN_VALUE; + expected = (int) (10 * 3 * 50 * 0.2 * index * 0.5); + assertEquals(expected, squat.caloricWaste(index)); + } + + @Test + void testCalculateCaloricWasteSetsValue() { + float index = 1f; + squat.calculateCaloricWaste(index); + assertEquals(squat.caloricWaste(index), squat.getCaloricWaste()); + } + + @Test + void testToString() { + assertNotNull(squat.toString()); + assertNotEquals("", squat.toString()); + } + + @Test + void testEquals() { + WeightSquat equalSquat = new WeightSquat(userCode, date, 31, "Get ready for summer!", "Squat", 10, 3, 50); + assertTrue(squat.equals(squat)); + + assertFalse(squat.equals(equalSquat)); + assertFalse(squat.equals(null)); + assertNotEquals(squat, new Object()); + } + + @Test + void testClone() { + WeightSquat clone = squat.clone(); + assertEquals(squat, clone); + assertNotSame(squat, clone); + } + } diff --git a/src/unittests/java/MakeItFit/activities/types/DistanceTest.java b/src/unittests/java/MakeItFit/activities/types/DistanceTest.java index d20f9c9..67a4b53 100644 --- a/src/unittests/java/MakeItFit/activities/types/DistanceTest.java +++ b/src/unittests/java/MakeItFit/activities/types/DistanceTest.java @@ -1,5 +1,120 @@ package MakeItFit.activities.types; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + public class DistanceTest { - + + private TestDistance distanceActivity; + private UUID userCode; + private MakeItFitDate date; + + private MakeItFitDate createDate(int year, int month, int day) { + return MakeItFitDate.of(year, month, day); + } + + @BeforeEach + void setUp() { + userCode = UUID.randomUUID(); + date = createDate(2024, 5, 15); + distanceActivity = new TestDistance(userCode, date, 45, "Running", "Running 45 minutes", 5000.0); + } + + @Test + void testGetters() { + assertEquals(userCode, distanceActivity.getUserCode()); + assertEquals(date, distanceActivity.getRealizationDate()); + assertEquals(45, distanceActivity.getExpectedDuration()); + assertEquals("Running", distanceActivity.getDesignation()); + assertEquals("Running 45 minutes", distanceActivity.getName()); + assertEquals(5000.0, distanceActivity.getDistance()); + } + + @Test + void testConstructors() { + TestDistance defaultD = new TestDistance(); + assertEquals(0.0, defaultD.getDistance()); + assertEquals(0, defaultD.getExpectedDuration()); + + TestDistance copyD = new TestDistance(distanceActivity); + assertEquals(distanceActivity.getDistance(), copyD.getDistance()); + assertEquals(distanceActivity.getDesignation(), copyD.getDesignation()); + } + + @Test + void testSetDistance() { + distanceActivity.setDistance(10); + assertEquals(10, distanceActivity.getDistance()); + } + + @Test + void testCalculateCaloricWaste() { + distanceActivity.calculateCaloricWaste(0.1f); + assertEquals(500, distanceActivity.getCaloricWaste()); + } + + @Test + void testCaloricWasteReturn() { + int waste = distanceActivity.caloricWaste(0.2f); + assertEquals(1000, waste); + } + + @Test + void testEquals() { + TestDistance other = new TestDistance(userCode, date, 45, "Running", "Running for 45 minutes", 5000.0); + assertTrue(distanceActivity.equals(other)); + assertTrue(distanceActivity.equals(distanceActivity)); + + TestDistance different = new TestDistance(userCode, date, 45, "Running", "Running for 45 minutes", 4000.0); + assertFalse(distanceActivity.equals(different)); + assertFalse(distanceActivity.equals(null)); + } + + @Test + void testToString() { + String output = distanceActivity.toString(); + assertTrue(output.contains("Running")); + assertTrue(output.contains("Distance: 5000.0")); + } + + @Test + void testClone() { + Distance cloned = distanceActivity.clone(); + assertNotSame(distanceActivity, cloned); + assertEquals(distanceActivity.getDistance(), cloned.getDistance()); + } +} + +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(Distance d) { + super(d); + } + + @Override + public void calculateCaloricWaste(float index) { + setCaloricWaste((int) (getDistance() * index)); + } + + @Override + public int caloricWaste(float index) { + return (int) (getDistance() * index); + } + + @Override + public Distance clone() { + return new TestDistance(this); + } } diff --git a/src/unittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java b/src/unittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java index fe82aff..bf11d1d 100644 --- a/src/unittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java +++ b/src/unittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java @@ -1,5 +1,130 @@ package MakeItFit.activities.types; +import MakeItFit.utils.MakeItFitDate; + +import java.util.UUID; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class DistanceWithAltimetryTest { - + private TestDistanceWithAltimetry activity; + private UUID userCode; + private MakeItFitDate date; + + private MakeItFitDate createDate(int year, int month, int day) { + return MakeItFitDate.of(year, month, day); + } + + @BeforeEach + void setUp() { + userCode = UUID.randomUUID(); + date = createDate(2024, 5, 15); + activity = new TestDistanceWithAltimetry(userCode, date, 90, "Biking", "Bom Jesus Biking", + 12345.0, 234.0, 200.0); + } + + @Test + void testGetters() { + assertEquals(12345.0, activity.getDistance()); + assertEquals(234.0, activity.getElevationGain()); + assertEquals(200.0, activity.getElevationLoss()); + assertEquals("Biking", activity.getDesignation()); + } + + @Test + void testSetElevationGainLoss() { + activity.setElevationGain(1000.0); + activity.setElevationLoss(300.0); + assertEquals(1000.0, activity.getElevationGain()); + assertEquals(300.0, activity.getElevationLoss()); + } + + @Test + void testConstructors() { + TestDistanceWithAltimetry defaultDA = new TestDistanceWithAltimetry(); + assertEquals(0.0, defaultDA.getDistance()); + assertEquals(0.0, defaultDA.getElevationGain()); + assertEquals(0.0, defaultDA.getElevationLoss()); + + TestDistanceWithAltimetry copyA = new TestDistanceWithAltimetry(activity); + assertEquals(activity.getElevationGain(), copyA.getElevationGain()); + assertEquals(activity.getElevationLoss(), copyA.getElevationLoss()); + assertEquals(activity.getDesignation(), copyA.getDesignation()); + } + + @Test + void testCalculateCaloricWaste() { + activity.calculateCaloricWaste(0.1f); + int expected = (int) ((12345 + 234 * 2 - 200 * 0.5) * 0.1f); + assertEquals(expected, activity.getCaloricWaste()); + } + + @Test + void testCaloricWasteReturn() { + int expected = (int) ((12345 + 234 * 2 - 200 * 0.5) * 0.2f); + assertEquals(expected, activity.caloricWaste(0.2f)); + } + + @Test + void testEquals() { + TestDistanceWithAltimetry same = new TestDistanceWithAltimetry(userCode, date, 90, "Biking", "Bom Jesus Biking", + 12345.0, 234.0, 200.0); + assertTrue(activity.equals(same)); + assertTrue(activity.equals(activity)); + + TestDistanceWithAltimetry different = new TestDistanceWithAltimetry(userCode, date, 90, "Biking", "Bom Jesus Biking", + 12345.0, 700.0, 200.0); + assertFalse(activity.equals(null)); + assertFalse(activity.equals(different)); + } + + @Test + void testToString() { + String output = activity.toString(); + assertTrue(output.contains("Elevation Gain: 234.0")); + assertTrue(output.contains("Elevation Loss: 200.0")); + } + + @Test + void testClone() { + DistanceWithAltimetry cloned = activity.clone(); + assertNotSame(activity, cloned); + assertEquals(activity.getElevationGain(), cloned.getElevationGain()); + assertEquals(activity.getElevationLoss(), cloned.getElevationLoss()); + } } + +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(DistanceWithAltimetry other) { + super(other); + } + + @Override + public void calculateCaloricWaste(float index) { + int waste = (int) ((getDistance() + getElevationGain() * 2 - getElevationLoss() * 0.5) * index); + setCaloricWaste(waste); + } + + @Override + public int caloricWaste(float index) { + return (int) ((getDistance() + getElevationGain() * 2 - getElevationLoss() * 0.5) * index); + } + + @Override + public DistanceWithAltimetry clone() { + return new TestDistanceWithAltimetry(this); + } +} + diff --git a/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java b/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java index 4dc176e..c21290c 100644 --- a/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java +++ b/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java @@ -1,5 +1,125 @@ package MakeItFit.activities.types; +import MakeItFit.utils.MakeItFitDate; + +import java.util.UUID; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import static org.junit.jupiter.api.Assertions.*; + public class RepetitionsTest { - + private TestRepetitions activity; + private UUID userCode; + private MakeItFitDate date; + + private MakeItFitDate createDate(int year, int month, int day) { + return MakeItFitDate.of(year, month, day); + } + + @BeforeEach + void setUp() { + userCode = UUID.randomUUID(); + date = createDate(2025, 10, 5); + activity = new TestRepetitions(userCode, date, 5, "Abs", "Plank", 15, 4); + } + + @Test + void testGetters() { + assertEquals(15, activity.getRepetitions()); + assertEquals(4, activity.getSeries()); + assertEquals("Abs", activity.getDesignation()); + } + + @Test + void testSetters() { + activity.setRepetitions(20); + activity.setSeries(5); + assertEquals(20, activity.getRepetitions()); + assertEquals(5, activity.getSeries()); + } + + @Test + void testConstructors() { + TestRepetitions defaultR = new TestRepetitions(); + assertEquals(0, defaultR.getRepetitions()); + assertEquals(0, defaultR.getSeries()); + + TestRepetitions copyD = new TestRepetitions(activity); + assertEquals(activity.getName(), copyD.getName()); + assertEquals(activity.getRepetitions(), copyD.getRepetitions()); + assertEquals(activity.getSeries(), copyD.getSeries()); + } + + @Test + void testCalculateCaloricWaste() { + activity.calculateCaloricWaste(1.5f); + int expected = (int) (15 * 4 * 1.5f * 2); + assertEquals(expected, activity.getCaloricWaste()); + } + + @Test + void testCaloricWasteReturn() { + int expected = (int) (15 * 4 * 1.2f * 2); + assertEquals(expected, activity.caloricWaste(1.2f)); + } + + @Test + void testEquals() { + TestRepetitions same = new TestRepetitions(userCode, date, 5, "Abs", "Plank", 15, 4); + assertTrue(activity.equals(same)); + assertTrue(activity.equals(activity)); + + TestRepetitions diff = new TestRepetitions(userCode, date, 5, "Abs", "Plank", 12, 4); + assertFalse(activity.equals(diff)); + assertFalse(activity.equals(null)); + } + + @Test + void testToString() { + String str = activity.toString(); + assertTrue(str.contains("Repetitions: 15")); + assertTrue(str.contains("Series: 4")); + } + + @Test + void testClone() { + Repetitions cloned = activity.clone(); + assertNotSame(activity, cloned); + assertEquals(activity.getRepetitions(), cloned.getRepetitions()); + assertEquals(activity.getSeries(), cloned.getSeries()); + } +} + + +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(Repetitions r) { + super(r); + } + + @Override + public void calculateCaloricWaste(float index) { + int waste = (int) (getRepetitions() * getSeries() * index * 2); + setCaloricWaste(waste); + } + + @Override + public int caloricWaste(float index) { + return (int) (getRepetitions() * getSeries() * index * 2); + } + + @Override + public Repetitions clone() { + return new TestRepetitions(this); + } } + diff --git a/src/unittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java b/src/unittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java index ceb3493..e32b2b1 100644 --- a/src/unittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java +++ b/src/unittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java @@ -1,5 +1,121 @@ package MakeItFit.activities.types; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.*; + public class RepetitionsWithWeightsTest { - + private TestRepetitionsWithWeights activity; + private UUID userCode; + private MakeItFitDate date; + + private MakeItFitDate createDate(int year, int month, int day) { + return MakeItFitDate.of(year, month, day); + } + + @BeforeEach + void setUp() { + userCode = UUID.randomUUID(); + date = createDate(2025, 10, 5); + activity = new TestRepetitionsWithWeights(userCode, date, 45, "BodyPump", "Squats", 10, 3, 20); + } + + @Test + void testGetters() { + assertEquals(10, activity.getRepetitions()); + assertEquals(3, activity.getSeries()); + assertEquals(20, activity.getWeight()); + } + + @Test + void testSetters() { + activity.setWeight(25.5); + assertEquals(25.5, activity.getWeight()); + } + + @Test + void testConstructors() { + TestRepetitionsWithWeights defaultRW = new TestRepetitionsWithWeights(); + assertEquals(0, defaultRW.getWeight()); + assertEquals(0, defaultRW.getSeries()); + + TestRepetitionsWithWeights copyRW = new TestRepetitionsWithWeights(activity); + assertEquals(activity.getWeight(), copyRW.getWeight()); + assertEquals(activity.getRepetitions(), copyRW.getRepetitions()); + } + + @Test + void testCalculateCaloricWaste() { + activity.calculateCaloricWaste(2f); + int expected = (int) (10 * 3 * 20 * 2 * 0.5); + assertEquals(expected, activity.getCaloricWaste()); + } + + @Test + void testCaloricWasteReturn() { + int expected = (int) (10 * 3 * 25 * 1.5 * 0.5); + activity.setWeight(25); + assertEquals(expected, activity.caloricWaste(1.5f)); + } + + @Test + void testEquals() { + TestRepetitionsWithWeights same = new TestRepetitionsWithWeights(userCode, date, 45, "BodyPump", "Squats", 10, 3, 20); + assertTrue(activity.equals(same)); + assertTrue(activity.equals(activity)); + + TestRepetitionsWithWeights diff = new TestRepetitionsWithWeights(userCode, date, 45, "BodyPump", "Squats", 10, 3, 25); + assertFalse(activity.equals(diff)); + assertFalse(activity.equals(null)); + } + + @Test + void testToString() { + String str = activity.toString(); + assertTrue(str.contains("Weight: 20.0 Kg")); + } + + @Test + void testClone() { + RepetitionsWithWeights cloned = activity.clone(); + assertNotSame(activity, cloned); + assertEquals(activity.getWeight(), cloned.getWeight()); + assertEquals(activity.getSeries(), cloned.getSeries()); + } } + +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(RepetitionsWithWeights r) { + super(r); + } + + @Override + public void calculateCaloricWaste(float index) { + int waste = (int) (getRepetitions() * getSeries() * getWeight() * index * 0.5); + setCaloricWaste(waste); + } + + @Override + public int caloricWaste(float index) { + return (int) (getRepetitions() * getSeries() * getWeight() * index * 0.5); + } + + @Override + public RepetitionsWithWeights clone() { + return new TestRepetitionsWithWeights(this); + } +} + From 7a62ac39ff4636ed867275c20b1d89cf4204d3e0 Mon Sep 17 00:00:00 2001 From: Mariana Date: Sat, 31 May 2025 23:24:07 +0100 Subject: [PATCH 5/6] format --- .../activities/implementation/Trail.java | 1 - .../activities/ActivityManagerTest.java | 14 ++-- .../MakeItFit/activities/ActivityTest.java | 55 ++++++++++------ .../activities/implementation/PushUpTest.java | 20 +++--- .../implementation/RunningTest.java | 26 ++++---- .../activities/implementation/TrailTest.java | 48 ++++++++++---- .../implementation/WeightSquatTest.java | 28 ++++---- .../activities/types/DistanceTest.java | 26 +++++--- .../types/DistanceWithAltimetryTest.java | 64 ++++++++++++++----- .../activities/types/RepetitionsTest.java | 21 +++--- .../types/RepetitionsWithWeightsTest.java | 39 +++++++---- 11 files changed, 221 insertions(+), 121 deletions(-) diff --git a/src/main/java/MakeItFit/activities/implementation/Trail.java b/src/main/java/MakeItFit/activities/implementation/Trail.java index 1afcfbc..5336025 100644 --- a/src/main/java/MakeItFit/activities/implementation/Trail.java +++ b/src/main/java/MakeItFit/activities/implementation/Trail.java @@ -101,7 +101,6 @@ public void setTrailType(int trailType) { this.trailType = trailType; }*/ this.trailType = Math.max(TRAIL_TYPE_EASY, Math.min(TRAIL_TYPE_HARD, trailType)); - } /** diff --git a/src/unittests/java/MakeItFit/activities/ActivityManagerTest.java b/src/unittests/java/MakeItFit/activities/ActivityManagerTest.java index 1df5094..c06c77a 100644 --- a/src/unittests/java/MakeItFit/activities/ActivityManagerTest.java +++ b/src/unittests/java/MakeItFit/activities/ActivityManagerTest.java @@ -1,10 +1,12 @@ package MakeItFit.activities; -import static org.junit.jupiter.api.Assertions.*; -import org.junit.jupiter.api.Test; import java.lang.reflect.Field; import java.util.*; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + public class ActivityManagerTest { private static final List EXPECTED_ACTIVITIES = @@ -30,8 +32,8 @@ void testGetRandomActivityReturnsValidActivity() { @Test void testAllActivitiesAreEventuallyReturned() { - ActivityManager manager = new ActivityManager(); - Set returnedActivities = new HashSet<>(); + ActivityManager manager = new ActivityManager(); + Set returnedActivities = new HashSet<>(); for (int i = 0; i < 100; i++) { returnedActivities.add(manager.getRandomActivity()); @@ -46,8 +48,8 @@ void testControlledRandomWithReflection() throws Exception { ActivityManager manager = new ActivityManager(); Random controlledRandom = new Random() { - private int[] values = {1, 2}; - private int index = 0; + private int[] values = { 1, 2 }; + private int index = 0; @Override public int nextInt(int bound) { diff --git a/src/unittests/java/MakeItFit/activities/ActivityTest.java b/src/unittests/java/MakeItFit/activities/ActivityTest.java index be28afe..28496e6 100644 --- a/src/unittests/java/MakeItFit/activities/ActivityTest.java +++ b/src/unittests/java/MakeItFit/activities/ActivityTest.java @@ -1,11 +1,11 @@ package MakeItFit.activities; -import static org.junit.jupiter.api.Assertions.*; -import org.junit.jupiter.api.Test; +import java.util.UUID; import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.Test; -import java.util.UUID; +import static org.junit.jupiter.api.Assertions.*; public class ActivityTest { @@ -29,9 +29,9 @@ void testDefaultConstructor() { @Test void testParameterizedConstructor() { - UUID userCode = UUID.randomUUID(); - MakeItFitDate date = createDate(2024, 5, 15); - TestActivity activity = new TestActivity(userCode, date, 60, "Class", "Dancing"); + UUID userCode = UUID.randomUUID(); + MakeItFitDate date = createDate(2024, 5, 15); + TestActivity activity = new TestActivity(userCode, date, 60, "Class", "Dancing"); assertEquals(userCode, activity.getUserCode()); assertEquals(date, activity.getRealizationDate()); @@ -45,7 +45,8 @@ void testParameterizedConstructor() { @Test void testCopyConstructor() { - TestActivity original = new TestActivity(UUID.randomUUID(), createDate(2024, 5, 15), 60, "Class", "Body Pump"); + TestActivity original = + new TestActivity(UUID.randomUUID(), createDate(2024, 5, 15), 60, "Class", "Body Pump"); original.setDuration(30); original.setCaloricWaste(200); @@ -81,16 +82,20 @@ void testSettersAndGetters() { @Test void testEquals() { MakeItFitDate date = createDate(2024, 5, 15); - TestActivity activity1 = new TestActivity(UUID.randomUUID(), date, 60, "Workout", "Pilates"); - TestActivity activity2 = new TestActivity(UUID.randomUUID(), date, 60, "Workout", "Pilates"); + TestActivity activity1 = + new TestActivity(UUID.randomUUID(), date, 60, "Workout", "Pilates"); + TestActivity activity2 = + new TestActivity(UUID.randomUUID(), date, 60, "Workout", "Pilates"); assertTrue(activity1.equals(activity1)); assertTrue(activity1.equals(activity2)); - TestActivity activity3 = new TestActivity(UUID.randomUUID(), date, 30, "Workout", "Pilates"); + TestActivity activity3 = + new TestActivity(UUID.randomUUID(), date, 30, "Workout", "Pilates"); assertFalse(activity1.equals(activity3)); - TestActivity activity4 = new TestActivity(UUID.randomUUID(), date, 60, "Exercise", "Pilates"); + TestActivity activity4 = + new TestActivity(UUID.randomUUID(), date, 60, "Exercise", "Pilates"); assertFalse(activity1.equals(activity4)); assertFalse(activity1.equals(new Object())); @@ -100,10 +105,14 @@ void testEquals() { void testCompareTo() { MakeItFitDate date1 = createDate(2024, 5, 15); MakeItFitDate date2 = createDate(2024, 5, 16); - TestActivity activity1 = new TestActivity(UUID.randomUUID(), date1, 60, "Workout", "Pilates"); - TestActivity activity2 = new TestActivity(UUID.randomUUID(), date2, 60, "Workout", "Body Pump"); - TestActivity activity3 = new TestActivity(UUID.randomUUID(), date1, 30, "Workout", "Pilates"); - TestActivity activity4 = new TestActivity(UUID.randomUUID(), date1, 60, "Workout", "Body Pump"); + TestActivity activity1 = + new TestActivity(UUID.randomUUID(), date1, 60, "Workout", "Pilates"); + TestActivity activity2 = + new TestActivity(UUID.randomUUID(), date2, 60, "Workout", "Body Pump"); + TestActivity activity3 = + new TestActivity(UUID.randomUUID(), date1, 30, "Workout", "Pilates"); + TestActivity activity4 = + new TestActivity(UUID.randomUUID(), date1, 60, "Workout", "Body Pump"); assertTrue(activity1.compareTo(activity2) < 0); assertTrue(activity2.compareTo(activity1) > 0); @@ -113,7 +122,8 @@ void testCompareTo() { @Test void testToString() { - TestActivity activity = new TestActivity(UUID.randomUUID(), createDate(2024, 5, 15), 60, "Workout", "Biking"); + TestActivity activity = + new TestActivity(UUID.randomUUID(), createDate(2024, 5, 15), 60, "Workout", "Biking"); activity.setCaloricWaste(300); String result = activity.toString(); @@ -141,8 +151,11 @@ void testSpecialization() { @Test void testClone() { TestActivity original = new TestActivity(UUID.randomUUID(), - createDate(2024, 5, 15), 60, "Class", "Body Combat"); - TestActivity clone = original.clone(); + createDate(2024, 5, 15), + 60, + "Class", + "Body Combat"); + TestActivity clone = original.clone(); assertNotSame(original, clone); assertTrue(original.equals(clone)); @@ -171,7 +184,11 @@ public void setSpecialization(String specialization) { super.setSpecialization(specialization); } - public TestActivity(UUID userCode, MakeItFitDate realizationDate, int expectedDuration, String designation, String name) { + public TestActivity(UUID userCode, + MakeItFitDate realizationDate, + int expectedDuration, + String designation, + String name) { super(userCode, realizationDate, expectedDuration, designation, name); } diff --git a/src/unittests/java/MakeItFit/activities/implementation/PushUpTest.java b/src/unittests/java/MakeItFit/activities/implementation/PushUpTest.java index b99fe3b..5dfab5b 100644 --- a/src/unittests/java/MakeItFit/activities/implementation/PushUpTest.java +++ b/src/unittests/java/MakeItFit/activities/implementation/PushUpTest.java @@ -1,16 +1,16 @@ package MakeItFit.activities.implementation; +import java.util.UUID; + import MakeItFit.utils.MakeItFitDate; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import java.util.UUID; - import static org.junit.jupiter.api.Assertions.*; public class PushUpTest { - private PushUp pushUp; - private UUID userCode; + private PushUp pushUp; + private UUID userCode; private MakeItFitDate date; private MakeItFitDate createDate(int year, int month, int day) { @@ -20,8 +20,8 @@ private MakeItFitDate createDate(int year, int month, int day) { @BeforeEach void setUp() { userCode = UUID.randomUUID(); - date = createDate(2025,10,5); - pushUp = new PushUp(userCode, date, 30, "You got this!", "Push-Ups", 5, 4); + date = createDate(2025, 10, 5); + pushUp = new PushUp(userCode, date, 30, "You got this!", "Push-Ups", 5, 4); } @Test @@ -50,16 +50,16 @@ void testConstructor() { @Test void testCalculateCaloricWaste() { - float index = 2f; - int expected = (int) (5 * 4 * 2 * 0.1); + float index = 2f; + int expected = (int) (5 * 4 * 2 * 0.1); pushUp.calculateCaloricWaste(index); assertEquals(expected, pushUp.getCaloricWaste()); } @Test void testCaloricWasteMethod() { - float index = 1.5f; - int expected = (int) (5 * 4 * 1.5 * 0.1); + float index = 1.5f; + int expected = (int) (5 * 4 * 1.5 * 0.1); assertEquals(expected, pushUp.caloricWaste(index)); } diff --git a/src/unittests/java/MakeItFit/activities/implementation/RunningTest.java b/src/unittests/java/MakeItFit/activities/implementation/RunningTest.java index daba4ed..52f2aee 100644 --- a/src/unittests/java/MakeItFit/activities/implementation/RunningTest.java +++ b/src/unittests/java/MakeItFit/activities/implementation/RunningTest.java @@ -1,16 +1,16 @@ package MakeItFit.activities.implementation; +import java.util.UUID; + import MakeItFit.utils.MakeItFitDate; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import java.util.UUID; - import static org.junit.jupiter.api.Assertions.*; public class RunningTest { - private Running running; - private UUID userCode; + private Running running; + private UUID userCode; private MakeItFitDate date; private MakeItFitDate createDate(int year, int month, int day) { @@ -20,8 +20,8 @@ private MakeItFitDate createDate(int year, int month, int day) { @BeforeEach void setUp() { userCode = UUID.randomUUID(); - date = createDate(2025, 12, 25); - running = new Running(userCode, date, 45, "Warming", "Just for 45 minutes", 5000.0, 10.0); + date = createDate(2025, 12, 25); + running = new Running(userCode, date, 45, "Warming", "Just for 45 minutes", 5000.0, 10.0); } @Test @@ -51,16 +51,16 @@ void testConstructors() { @Test void testCalculateCaloricWaste() { - float index = 1.5f; - int expected = (int) (10.0 * 5000.0 * 1.5 * 0.005); + float index = 1.5f; + int expected = (int) (10.0 * 5000.0 * 1.5 * 0.005); running.calculateCaloricWaste(index); assertEquals(expected, running.getCaloricWaste()); } @Test void testCaloricWasteMethod() { - float index = 2.0f; - int expected = (int) (10.0 * 5000.0 * 2.0 * 0.005); + float index = 2.0f; + int expected = (int) (10.0 * 5000.0 * 2.0 * 0.005); assertEquals(expected, running.caloricWaste(index)); } @@ -72,11 +72,13 @@ void testToString() { @Test void testEquals() { - Running same = new Running(userCode, date, 45, "Warming", "Just for 45 minutes", 5000.0, 10.0); + Running same = + new Running(userCode, date, 45, "Warming", "Just for 45 minutes", 5000.0, 10.0); assertTrue(running.equals(same)); assertTrue(running.equals(running)); - Running diff = new Running(userCode, date, 45, "Warming", "Just for 45 minutes", 5000.0, 12.0); + Running diff = + new Running(userCode, date, 45, "Warming", "Just for 45 minutes", 5000.0, 12.0); assertFalse(running.equals(diff)); assertFalse(running.equals(null)); } diff --git a/src/unittests/java/MakeItFit/activities/implementation/TrailTest.java b/src/unittests/java/MakeItFit/activities/implementation/TrailTest.java index 6193539..caa194f 100644 --- a/src/unittests/java/MakeItFit/activities/implementation/TrailTest.java +++ b/src/unittests/java/MakeItFit/activities/implementation/TrailTest.java @@ -1,17 +1,17 @@ package MakeItFit.activities.implementation; +import java.util.UUID; + import MakeItFit.utils.MakeItFitDate; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import java.util.UUID; - import static MakeItFit.activities.implementation.Trail.*; import static org.junit.jupiter.api.Assertions.*; public class TrailTest { - private Trail trail; - private UUID userCode; + private Trail trail; + private UUID userCode; private MakeItFitDate date; private MakeItFitDate createDate(int year, int month, int day) { @@ -21,8 +21,16 @@ private MakeItFitDate createDate(int year, int month, int day) { @BeforeEach void setUp() { userCode = UUID.randomUUID(); - date = createDate(2025, 12, 25); - trail = new Trail(userCode, date, 90, "Easy peasy lemon squeezy", "Trail", 10000, 500, 200, TRAIL_TYPE_EASY); + date = createDate(2025, 12, 25); + trail = new Trail(userCode, + date, + 90, + "Easy peasy lemon squeezy", + "Trail", + 10000, + 500, + 200, + TRAIL_TYPE_EASY); } @Test @@ -66,16 +74,16 @@ void testSetTrailType() { @Test void testCalculateCaloricWaste() { - float index = 2.0f; - int expected = (int) ((10000 * 0.5 + 500 * 0.1 - 200 * 0.1) * index * 0.01); + float index = 2.0f; + int expected = (int) ((10000 * 0.5 + 500 * 0.1 - 200 * 0.1) * index * 0.01); trail.calculateCaloricWaste(index); assertEquals(expected, trail.getCaloricWaste()); } @Test void testCaloricWasteMethod() { - float index = 1.5f; - int expected = (int) ((10000 * 0.5 + 500 * 0.1 - 200 * 0.1) * index * 0.01); + float index = 1.5f; + int expected = (int) ((10000 * 0.5 + 500 * 0.1 - 200 * 0.1) * index * 0.01); assertEquals(expected, trail.caloricWaste(index)); } @@ -87,11 +95,27 @@ void testToStringIncludesTrailType() { @Test void testEquals() { - Trail same = new Trail(userCode, date, 90, "Easy peasy lemon squeezy", "Trail", 10000, 500, 200, TRAIL_TYPE_EASY); + Trail same = new Trail(userCode, + date, + 90, + "Easy peasy lemon squeezy", + "Trail", + 10000, + 500, + 200, + TRAIL_TYPE_EASY); assertTrue(trail.equals(same)); assertTrue(trail.equals(trail)); - Trail diff = new Trail(userCode, date, 90, "Easy peasy lemon squeezy", "Trail", 10000, 500, 200, TRAIL_TYPE_HARD); + Trail diff = new Trail(userCode, + date, + 90, + "Easy peasy lemon squeezy", + "Trail", + 10000, + 500, + 200, + TRAIL_TYPE_HARD); assertFalse(trail.equals(diff)); assertFalse(trail.equals(null)); } diff --git a/src/unittests/java/MakeItFit/activities/implementation/WeightSquatTest.java b/src/unittests/java/MakeItFit/activities/implementation/WeightSquatTest.java index 6124a57..61b34b0 100644 --- a/src/unittests/java/MakeItFit/activities/implementation/WeightSquatTest.java +++ b/src/unittests/java/MakeItFit/activities/implementation/WeightSquatTest.java @@ -1,18 +1,18 @@ package MakeItFit.activities.implementation; +import java.util.UUID; + import MakeItFit.utils.MakeItFitDate; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import java.util.UUID; - import static org.junit.jupiter.api.Assertions.*; public class WeightSquatTest { - private UUID userCode; + private UUID userCode; private MakeItFitDate date; - private WeightSquat squat; + private WeightSquat squat; private MakeItFitDate createDate(int year, int month, int day) { return MakeItFitDate.of(year, month, day); @@ -21,8 +21,8 @@ private MakeItFitDate createDate(int year, int month, int day) { @BeforeEach void setUp() { userCode = UUID.randomUUID(); - date = createDate(2025, 12, 25); - squat = new WeightSquat(userCode, date, 30, "Get ready for summer!", "Squat", 10, 3, 50); + date = createDate(2025, 12, 25); + squat = new WeightSquat(userCode, date, 30, "Get ready for summer!", "Squat", 10, 3, 50); } @Test @@ -53,23 +53,23 @@ void testConstructors() { @Test void testCaloricWasteCalculation() { - float index = 0f; - int expected = 0; + float index = 0f; + int expected = 0; assertEquals(expected, squat.caloricWaste(index)); - index = 1f; + index = 1f; expected = (int) (10 * 3 * 50 * 0.2 * index * 0.5); assertEquals(expected, squat.caloricWaste(index)); - index = -1f; + index = -1f; expected = (int) (10 * 3 * 50 * 0.2 * index * 0.5); assertEquals(expected, squat.caloricWaste(index)); - index = Float.MAX_VALUE; + index = Float.MAX_VALUE; expected = (int) (10 * 3 * 50 * 0.2 * index * 0.5); assertEquals(expected, squat.caloricWaste(index)); - index = Float.MIN_VALUE; + index = Float.MIN_VALUE; expected = (int) (10 * 3 * 50 * 0.2 * index * 0.5); assertEquals(expected, squat.caloricWaste(index)); } @@ -89,7 +89,8 @@ void testToString() { @Test void testEquals() { - WeightSquat equalSquat = new WeightSquat(userCode, date, 31, "Get ready for summer!", "Squat", 10, 3, 50); + WeightSquat equalSquat = + new WeightSquat(userCode, date, 31, "Get ready for summer!", "Squat", 10, 3, 50); assertTrue(squat.equals(squat)); assertFalse(squat.equals(equalSquat)); @@ -103,5 +104,4 @@ void testClone() { assertEquals(squat, clone); assertNotSame(squat, clone); } - } diff --git a/src/unittests/java/MakeItFit/activities/types/DistanceTest.java b/src/unittests/java/MakeItFit/activities/types/DistanceTest.java index 67a4b53..f788f40 100644 --- a/src/unittests/java/MakeItFit/activities/types/DistanceTest.java +++ b/src/unittests/java/MakeItFit/activities/types/DistanceTest.java @@ -1,17 +1,17 @@ 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 java.util.UUID; - import static org.junit.jupiter.api.Assertions.*; public class DistanceTest { - private TestDistance distanceActivity; - private UUID userCode; + private TestDistance distanceActivity; + private UUID userCode; private MakeItFitDate date; private MakeItFitDate createDate(int year, int month, int day) { @@ -21,8 +21,9 @@ private MakeItFitDate createDate(int year, int month, int day) { @BeforeEach void setUp() { userCode = UUID.randomUUID(); - date = createDate(2024, 5, 15); - distanceActivity = new TestDistance(userCode, date, 45, "Running", "Running 45 minutes", 5000.0); + date = createDate(2024, 5, 15); + distanceActivity = + new TestDistance(userCode, date, 45, "Running", "Running 45 minutes", 5000.0); } @Test @@ -66,11 +67,13 @@ void testCaloricWasteReturn() { @Test void testEquals() { - TestDistance other = new TestDistance(userCode, date, 45, "Running", "Running for 45 minutes", 5000.0); + TestDistance other = + new TestDistance(userCode, date, 45, "Running", "Running for 45 minutes", 5000.0); assertTrue(distanceActivity.equals(other)); assertTrue(distanceActivity.equals(distanceActivity)); - TestDistance different = new TestDistance(userCode, date, 45, "Running", "Running for 45 minutes", 4000.0); + TestDistance different = + new TestDistance(userCode, date, 45, "Running", "Running for 45 minutes", 4000.0); assertFalse(distanceActivity.equals(different)); assertFalse(distanceActivity.equals(null)); } @@ -91,7 +94,12 @@ void testClone() { } class TestDistance extends Distance { - public TestDistance(UUID userCode, MakeItFitDate realizationDate, int expectedDuration, String designation, String name, double distance) { + public TestDistance(UUID userCode, + MakeItFitDate realizationDate, + int expectedDuration, + String designation, + String name, + double distance) { super(userCode, realizationDate, expectedDuration, designation, name, distance); } diff --git a/src/unittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java b/src/unittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java index bf11d1d..9069cce 100644 --- a/src/unittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java +++ b/src/unittests/java/MakeItFit/activities/types/DistanceWithAltimetryTest.java @@ -1,8 +1,8 @@ package MakeItFit.activities.types; -import MakeItFit.utils.MakeItFitDate; - import java.util.UUID; + +import MakeItFit.utils.MakeItFitDate; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -10,8 +10,8 @@ public class DistanceWithAltimetryTest { private TestDistanceWithAltimetry activity; - private UUID userCode; - private MakeItFitDate date; + private UUID userCode; + private MakeItFitDate date; private MakeItFitDate createDate(int year, int month, int day) { return MakeItFitDate.of(year, month, day); @@ -20,9 +20,15 @@ private MakeItFitDate createDate(int year, int month, int day) { @BeforeEach void setUp() { userCode = UUID.randomUUID(); - date = createDate(2024, 5, 15); - activity = new TestDistanceWithAltimetry(userCode, date, 90, "Biking", "Bom Jesus Biking", - 12345.0, 234.0, 200.0); + date = createDate(2024, 5, 15); + activity = new TestDistanceWithAltimetry(userCode, + date, + 90, + "Biking", + "Bom Jesus Biking", + 12345.0, + 234.0, + 200.0); } @Test @@ -69,13 +75,25 @@ void testCaloricWasteReturn() { @Test void testEquals() { - TestDistanceWithAltimetry same = new TestDistanceWithAltimetry(userCode, date, 90, "Biking", "Bom Jesus Biking", - 12345.0, 234.0, 200.0); + TestDistanceWithAltimetry same = new TestDistanceWithAltimetry(userCode, + date, + 90, + "Biking", + "Bom Jesus Biking", + 12345.0, + 234.0, + 200.0); assertTrue(activity.equals(same)); assertTrue(activity.equals(activity)); - TestDistanceWithAltimetry different = new TestDistanceWithAltimetry(userCode, date, 90, "Biking", "Bom Jesus Biking", - 12345.0, 700.0, 200.0); + TestDistanceWithAltimetry different = new TestDistanceWithAltimetry(userCode, + date, + 90, + "Biking", + "Bom Jesus Biking", + 12345.0, + 700.0, + 200.0); assertFalse(activity.equals(null)); assertFalse(activity.equals(different)); } @@ -97,10 +115,22 @@ void testClone() { } 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(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() { @@ -113,7 +143,8 @@ public TestDistanceWithAltimetry(DistanceWithAltimetry other) { @Override public void calculateCaloricWaste(float index) { - int waste = (int) ((getDistance() + getElevationGain() * 2 - getElevationLoss() * 0.5) * index); + int waste = + (int) ((getDistance() + getElevationGain() * 2 - getElevationLoss() * 0.5) * index); setCaloricWaste(waste); } @@ -127,4 +158,3 @@ public DistanceWithAltimetry clone() { return new TestDistanceWithAltimetry(this); } } - diff --git a/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java b/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java index c21290c..43160f2 100644 --- a/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java +++ b/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java @@ -1,17 +1,17 @@ package MakeItFit.activities.types; -import MakeItFit.utils.MakeItFitDate; - 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.*; public class RepetitionsTest { private TestRepetitions activity; - private UUID userCode; - private MakeItFitDate date; + private UUID userCode; + private MakeItFitDate date; private MakeItFitDate createDate(int year, int month, int day) { return MakeItFitDate.of(year, month, day); @@ -20,7 +20,7 @@ private MakeItFitDate createDate(int year, int month, int day) { @BeforeEach void setUp() { userCode = UUID.randomUUID(); - date = createDate(2025, 10, 5); + date = createDate(2025, 10, 5); activity = new TestRepetitions(userCode, date, 5, "Abs", "Plank", 15, 4); } @@ -91,10 +91,14 @@ void testClone() { } } - class TestRepetitions extends Repetitions { - public TestRepetitions(UUID userCode, MakeItFitDate realizationDate, int expectedDuration, - String designation, String name, int repetitions, int series) { + public TestRepetitions(UUID userCode, + MakeItFitDate realizationDate, + int expectedDuration, + String designation, + String name, + int repetitions, + int series) { super(userCode, realizationDate, expectedDuration, designation, name, repetitions, series); } @@ -122,4 +126,3 @@ public Repetitions clone() { return new TestRepetitions(this); } } - diff --git a/src/unittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java b/src/unittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java index e32b2b1..2f9887c 100644 --- a/src/unittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java +++ b/src/unittests/java/MakeItFit/activities/types/RepetitionsWithWeightsTest.java @@ -1,17 +1,17 @@ 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 java.util.UUID; - import static org.junit.jupiter.api.Assertions.*; public class RepetitionsWithWeightsTest { private TestRepetitionsWithWeights activity; - private UUID userCode; - private MakeItFitDate date; + private UUID userCode; + private MakeItFitDate date; private MakeItFitDate createDate(int year, int month, int day) { return MakeItFitDate.of(year, month, day); @@ -20,8 +20,9 @@ private MakeItFitDate createDate(int year, int month, int day) { @BeforeEach void setUp() { userCode = UUID.randomUUID(); - date = createDate(2025, 10, 5); - activity = new TestRepetitionsWithWeights(userCode, date, 45, "BodyPump", "Squats", 10, 3, 20); + date = createDate(2025, 10, 5); + activity = + new TestRepetitionsWithWeights(userCode, date, 45, "BodyPump", "Squats", 10, 3, 20); } @Test @@ -64,11 +65,13 @@ void testCaloricWasteReturn() { @Test void testEquals() { - TestRepetitionsWithWeights same = new TestRepetitionsWithWeights(userCode, date, 45, "BodyPump", "Squats", 10, 3, 20); + TestRepetitionsWithWeights same = + new TestRepetitionsWithWeights(userCode, date, 45, "BodyPump", "Squats", 10, 3, 20); assertTrue(activity.equals(same)); assertTrue(activity.equals(activity)); - TestRepetitionsWithWeights diff = new TestRepetitionsWithWeights(userCode, date, 45, "BodyPump", "Squats", 10, 3, 25); + TestRepetitionsWithWeights diff = + new TestRepetitionsWithWeights(userCode, date, 45, "BodyPump", "Squats", 10, 3, 25); assertFalse(activity.equals(diff)); assertFalse(activity.equals(null)); } @@ -89,9 +92,22 @@ void testClone() { } 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(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() { @@ -118,4 +134,3 @@ public RepetitionsWithWeights clone() { return new TestRepetitionsWithWeights(this); } } - From 69493d0a863a26a5cd8ef4654f922b783c68b774 Mon Sep 17 00:00:00 2001 From: Mariana Date: Sat, 31 May 2025 23:29:13 +0100 Subject: [PATCH 6/6] remove MakeIfFitTest --- src/unittests/java/MakeItFit/MakeItFitTest.java | 5 ----- 1 file changed, 5 deletions(-) delete mode 100644 src/unittests/java/MakeItFit/MakeItFitTest.java diff --git a/src/unittests/java/MakeItFit/MakeItFitTest.java b/src/unittests/java/MakeItFit/MakeItFitTest.java deleted file mode 100644 index 6836254..0000000 --- a/src/unittests/java/MakeItFit/MakeItFitTest.java +++ /dev/null @@ -1,5 +0,0 @@ -package MakeItFit; - -public class MakeItFitTest { - -}