Tehtävä 3

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

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

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

src/test/java/fi/utu/tech/ooj/exercise2/ActivationTest.java

+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);
+    }
+}

src/test/java/fi/utu/tech/ooj/exercise2/CarTest.java

+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

src/test/java/fi/utu/tech/ooj/exercise2/MergeSortTest.java

 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);
+    }
 }

src/test/java/fi/utu/tech/ooj/exercise2/PalindromeTest.java

+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);
+    }
+}
+