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