diff --git a/src/main/java/fi/utu/tech/ooj/exercise2/Activation.java b/src/main/java/fi/utu/tech/ooj/exercise2/Activation.java
index 6985b09db5e84cc379fd30ad1f210c1290b1f2df..b8b6859eef0fe6f78dfbcf52735ef3c6f3c83ee7 100644
--- a/src/main/java/fi/utu/tech/ooj/exercise2/Activation.java
+++ b/src/main/java/fi/utu/tech/ooj/exercise2/Activation.java
@@ -9,3 +9,14 @@ public class Activation {
return a*x;
}
}
+
+/*
+ * Testattavat asiat:
+ * Positiivinen syöte: Testaa, että positiivinen syöte palauttaa odotetun tuloksen.
+ Negatiivinen syöte: Testaa, että negatiivinen syöte palauttaa odotetun tuloksen ottaen huomioon a-parametrin.
+ Nolla-syöte: Testaa, että nolla-syöte palauttaa odotetun tuloksen.
+ Suuri syöte: Testaa, että suuri positiivinen syöte palauttaa odotetun tuloksen.
+ Suuri negatiivinen syöte: Testaa, että suuri negatiivinen syöte palauttaa odotetun tuloksen ottaen huomioon a-parametrin.
+ Eri a-parametrit: Testaa eri a-parametrien arvoja ja varmista, että palautetut tulokset vastaavat odotuksia.
+
+ */
\ No newline at end of file
diff --git a/src/main/java/fi/utu/tech/ooj/exercise2/Palindrome.java b/src/main/java/fi/utu/tech/ooj/exercise2/Palindrome.java
index c338723fc971a4349eaacb1fd395afc7ba234699..b65ea2c96e9f3a2afb02065ad3786189bc3926e4 100644
--- a/src/main/java/fi/utu/tech/ooj/exercise2/Palindrome.java
+++ b/src/main/java/fi/utu/tech/ooj/exercise2/Palindrome.java
@@ -6,3 +6,14 @@ public class Palindrome {
return textIn + new StringBuilder(textIn).reverse().toString().substring(2);
}
}
+
+/*
+ * Testattavat asiat:
+ * Parillinen pituus: Testaa, että kun syötteessä on parillinen määrä merkkejä, rutiini palauttaa odotetun palindromin.
+ Pariton pituus: Testaa, että kun syötteessä on pariton määrä merkkejä, rutiini palauttaa odotetun palindromin.
+ Tyhjä syöte: Testaa, että kun syöte on tyhjä, rutiini palauttaa tyhjän merkkijonon.
+ Yksi merkki: Testaa, että kun syötteessä on vain yksi merkki, rutiini palauttaa saman merkin.
+ Erikoismerkit: Testaa, että rutiini käsittelee oikein erikoismerkkejä kuten välilyöntejä, erikoismerkkejä ja isoja/kirjaimia.
+ Suuri syöte: Testaa, että kun syötteessä on suuri määrä merkkejä, rutiini palauttaa odotetun palindromin.
+
+ */
\ No newline at end of file
diff --git a/src/main/java/fi/utu/tech/ooj/exercise2/Sorting.java b/src/main/java/fi/utu/tech/ooj/exercise2/Sorting.java
index 37736f01ead260d9a0af21ee6b38420f7d427158..4682c693f0041d265995bba02f29b991be6b27d9 100644
--- a/src/main/java/fi/utu/tech/ooj/exercise2/Sorting.java
+++ b/src/main/java/fi/utu/tech/ooj/exercise2/Sorting.java
@@ -42,3 +42,15 @@ public class Sorting {
}
}
}
+
+/*
+ * Testattavat asiat:
+ * Tyhjä syöte: Testaa, että tyhjä taulukko ei aiheuta virheitä.
+ Taulukko, jossa on vain yksi elementti: Testaa, että taulukon yhden alkion lajittelu onnistuu.
+ Taulukko, jossa on useita elementtejä: Testaa, että taulukko lajitellaan oikein.
+ Taulukko, jossa on negatiivisia lukuja: Testaa, että algoritmi käsittelee myös negatiiviset luvut oikein.
+ Taulukko, jossa on päällekkäisiä arvoja: Testaa, että algoritmi käsittelee samat arvot oikein ja säilyttää niiden alkuperäisen järjestyksen.
+ Taulukko, joka on jo lajiteltu: Testaa, että algoritmi käsittelee jo lajitellun taulukon oikein.
+ Taulukko, joka on käänteisessä järjestyksessä: Testaa, että algoritmi käsittelee käänteisessä järjestyksessä olevan taulukon oikein.
+ Suuri taulukko: Testaa, että algoritmi käsittelee suuren taulukon oikein ja tehokkaasti.
+ */
\ No newline at end of file
diff --git a/src/test/java/fi/utu/tech/ooj/exercise2/ActivationTest.java b/src/test/java/fi/utu/tech/ooj/exercise2/ActivationTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..7850a49cdb3b7d28c83a856f84b4577de6fff8a1
--- /dev/null
+++ b/src/test/java/fi/utu/tech/ooj/exercise2/ActivationTest.java
@@ -0,0 +1,39 @@
+package fi.utu.tech.ooj.exercise2;
+
+import org.junit.jupiter.api.Test;
+
+public class ActivationTest {
+
+ @Test
+ public void testParametricReLU() {
+ // Test positive input
+ float result = Activation.parametricReLU(5, 0.5f);
+ assert(result == 5);
+
+ // Test negative input
+ result = Activation.parametricReLU(-5, 0.5f);
+ assert(result == -2.5f);
+
+ // Test zero input
+ result = Activation.parametricReLU(0, 0.5f);
+ assert(result == 0);
+
+ // Test large positive input
+ result = Activation.parametricReLU(1000, 0.5f);
+ assert(result == 1000);
+
+ // Test large negative input
+ result = Activation.parametricReLU(-1000, 0.5f);
+ assert(result == -500);
+
+ // Test different values of a
+ result = Activation.parametricReLU(-5, 1);
+ assert(result == -5);
+
+ result = Activation.parametricReLU(-5, 0);
+ assert(result == 0);
+
+ result = Activation.parametricReLU(-5, 2);
+ assert(result == -10);
+ }
+}
diff --git a/src/test/java/fi/utu/tech/ooj/exercise2/CarTest.java b/src/test/java/fi/utu/tech/ooj/exercise2/CarTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bf3de3dcd9a604aa564c14786791d197e24ad5d1
--- /dev/null
+++ b/src/test/java/fi/utu/tech/ooj/exercise2/CarTest.java
@@ -0,0 +1,52 @@
+package fi.utu.tech.ooj.exercise2;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import java.time.Year;
+
+public class CarTest {
+
+ private Car car;
+
+ @BeforeEach
+ public void setUp() {
+ car = new Car("Toyota", "Corolla", 2021, true, "ABC123");
+ }
+
+ @Test
+ public void testManufacturerInvariant() {
+ Assertions.assertThrows(IllegalArgumentException.class, () -> car.setManufacturer(null));
+ Assertions.assertThrows(IllegalArgumentException.class, () -> car.setManufacturer(""));
+ Assertions.assertThrows(IllegalArgumentException.class, () -> car.setManufacturer("A"));
+ }
+
+ @Test
+ public void testModelInvariant() {
+ Assertions.assertThrows(IllegalArgumentException.class, () -> car.setModel(null));
+ Assertions.assertThrows(IllegalArgumentException.class, () -> car.setModel(""));
+ Assertions.assertThrows(IllegalArgumentException.class, () -> car.setModel("A"));
+ }
+
+ @Test
+ public void testModelYearInvariant() {
+ Assertions.assertThrows(IllegalArgumentException.class, () -> car.setModelYear(null));
+ Assertions.assertThrows(IllegalArgumentException.class, () -> car.setModelYear(1800));
+ Assertions.assertThrows(IllegalArgumentException.class, () -> car.setModelYear(Year.now().getValue() + 1));
+ }
+
+ @Test
+ public void testRegistrationInvariant() {
+ Assertions.assertThrows(IllegalArgumentException.class, () -> car.setRegistered(null));
+ Assertions.assertThrows(IllegalArgumentException.class, () -> car.setRegisterNumber("123"));
+ Assertions.assertThrows(IllegalArgumentException.class, () -> {
+ car.setRegistered(true);
+ car.setRegisterNumber("");
+ });
+ Assertions.assertThrows(IllegalArgumentException.class, () -> {
+ car.setRegistered(false);
+ car.setRegisterNumber("ABC");
+ });
+ }
+
+}
\ No newline at end of file
diff --git a/src/test/java/fi/utu/tech/ooj/exercise2/MergeSortTest.java b/src/test/java/fi/utu/tech/ooj/exercise2/MergeSortTest.java
index eb52e35dd16f8d226071e22aa10c700f57000f43..1eee44b0c92ba5f0b36513a090da0b332d1ac384 100644
--- a/src/test/java/fi/utu/tech/ooj/exercise2/MergeSortTest.java
+++ b/src/test/java/fi/utu/tech/ooj/exercise2/MergeSortTest.java
@@ -1,5 +1,69 @@
package fi.utu.tech.ooj.exercise2;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
public class MergeSortTest {
+
+ @Test
+ public void testMergeSort() {
+
+ int[] arr = {};
+ Sorting.mergeSort(arr);
+ assertArrayEquals(new int[]{}, arr);
+
+
+ arr = new int[]{7};
+ Sorting.mergeSort(arr);
+ assertArrayEquals(new int[]{7}, arr);
+
+
+ arr = new int[]{5, 2, 8, 3, 9};
+ Sorting.mergeSort(arr);
+ assertArrayEquals(new int[]{2, 3, 5, 8, 9}, arr);
+
+
+ arr = new int[]{-5, 2, -8, 3, 9};
+ Sorting.mergeSort(arr);
+ assertArrayEquals(new int[]{-8, -5, 2, 3, 9}, arr);
+
+
+ arr = new int[]{5, 2, 8, 3, 5};
+ Sorting.mergeSort(arr);
+ assertArrayEquals(new int[]{2, 3, 5, 5, 8}, arr);
+
+
+ arr = new int[]{2, 4, 6, 8, 10};
+ Sorting.mergeSort(arr);
+ assertArrayEquals(new int[]{2, 4, 6, 8, 10}, arr);
+
+
+ arr = new int[]{10, 8, 6, 4, 2};
+ Sorting.mergeSort(arr);
+ assertArrayEquals(new int[]{2, 4, 6, 8, 10}, arr);
+
+
+ int n = 10000;
+ arr = new int[n];
+ for (int i = 0; i < n; i++) {
+ arr[i] = (int) (Math.random() * n);
+ }
+ Sorting.mergeSort(arr);
+ for (int i = 1; i < n; i++) {
+ assertTrue(arr[i-1] <= arr[i]);
+ }
+ }
+
+
+ @Test
+ public void testMerge() {
+ int[] arr = {2, 4, 6, 1, 3, 5};
+ int[] l = {2, 4, 6};
+ int[] r = {1, 3, 5};
+ Sorting.merge(arr, l, r, l.length, r.length);
+ assertArrayEquals(new int[]{1, 2, 3, 4, 5, 6}, arr);
+ }
}
diff --git a/src/test/java/fi/utu/tech/ooj/exercise2/PalindromeTest.java b/src/test/java/fi/utu/tech/ooj/exercise2/PalindromeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f92a87b222781e25db01d3cfbc11790d031d1fd
--- /dev/null
+++ b/src/test/java/fi/utu/tech/ooj/exercise2/PalindromeTest.java
@@ -0,0 +1,61 @@
+package fi.utu.tech.ooj.exercise2;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class PalindromeTest {
+
+ @Test
+ public void testConvertToPalindrome_evenLength() {
+ String input = "abcd";
+ String expected = "abcddcba";
+ String result = Palindrome.convertToPalindrome(input);
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void testConvertToPalindrome_oddLength() {
+ String input = "abcde";
+ String expected = "abcdeedcba";
+ String result = Palindrome.convertToPalindrome(input);
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void testConvertToPalindrome_emptyInput() {
+ String input = "";
+ String expected = "";
+ String result = Palindrome.convertToPalindrome(input);
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void testConvertToPalindrome_singleCharInput() {
+ String input = "a";
+ String expected = "a";
+ String result = Palindrome.convertToPalindrome(input);
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void testConvertToPalindrome_specialChars() {
+ String input = "A man, a plan, a canal: Panama!";
+ String expected = "A man, a plan, a canal: Panama!amanaP :lanac a ,nalp a ,nam A";
+ String result = Palindrome.convertToPalindrome(input);
+ assertEquals(expected, result);
+ }
+
+ @Test
+ public void testConvertToPalindrome_largeInput() {
+ StringBuilder builder = new StringBuilder();
+ for (int i = 0; i < 10000; i++) {
+ builder.append("a");
+ }
+ String input = builder.toString();
+ String expected = builder.toString() + builder.reverse().toString().substring(2);
+ String result = Palindrome.convertToPalindrome(input);
+ assertEquals(expected, result);
+ }
+}
+