Unify dynamic memory allocation algorithms (#2935)

src/test/java/com/thealgorithms/others/BestFitCPUTest.java

@@ -0,0 +1,76 @@
+package com.thealgorithms.others;
+
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * author Alexandros Lemonaris
+ */
+class BestFitCPUTest {
+    int [] sizeOfBlocks;
+    int [] sizeOfProcesses;
+    ArrayList<Integer> memAllocation = new ArrayList<>();
+    ArrayList<Integer> testMemAllocation ;
+    CPUalgorithms bestFit = new BestFitCPU();
+
+    @Test
+    void testFitForUseOfOneBlock() {
+        //test1 - 2 processes shall fit to one block instead of using a different block each
+        sizeOfBlocks = new int[]{5, 12, 17, 10};
+        sizeOfProcesses = new int[]{10, 5, 15, 2};
+        memAllocation = bestFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(3, 0, 2, 2)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForEqualProcecesses() {
+        //test2
+        sizeOfBlocks = new int[]{5, 12, 17, 10};
+        sizeOfProcesses = new int[]{10, 10, 10, 10};
+        memAllocation = bestFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(3, 1, 2, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForNoEmptyBlockCell() {
+        //test3 for more processes than blocks - no empty space left to none of the blocks
+        sizeOfBlocks = new int[]{5, 12, 17};
+        sizeOfProcesses = new int[]{5, 12, 10, 7};
+        memAllocation = bestFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(0, 1, 2, 2)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForSameInputDifferentQuery() {
+        //test4 for more processes than blocks - one element does not fit due to input series
+        sizeOfBlocks = new int[]{5, 12, 17};
+        sizeOfProcesses = new int[]{5, 7, 10, 12};
+        memAllocation = bestFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(0, 1, 2, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForMoreBlocksNoFit() {
+        //test5 for more blocks than processes
+        sizeOfBlocks = new int[] {5, 4, -1, 3, 6};
+        sizeOfProcesses = new int [] {10, 11};
+        memAllocation = bestFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList( -255, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+}

src/test/java/com/thealgorithms/others/FirstFitCPUTest.java

@@ -0,0 +1,76 @@
+package com.thealgorithms.others;
+
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * author Alexandros Lemonaris
+ */
+class FirstFitCPUTest {
+    int [] sizeOfBlocks;
+    int [] sizeOfProcesses;
+    ArrayList<Integer> memAllocation = new ArrayList<>();
+    ArrayList<Integer> testMemAllocation ;
+    CPUalgorithms firstFit = new FirstFitCPU();
+
+    @Test
+    void testFitForUseOfOneBlock() {
+        //test1 - no use of one block for two processes
+        sizeOfBlocks = new int[]{5, 12, 17, 10};
+        sizeOfProcesses = new int[]{10, 5, 15, 2};
+        memAllocation = firstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(1, 0, 2, 1)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForEqualProcecesses() {
+        //test2
+        sizeOfBlocks = new int[]{5, 12, 17, 10};
+        sizeOfProcesses = new int[]{10, 10, 10, 10};
+        memAllocation = firstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(1, 2, 3, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForNoEmptyBlockCell() {
+        //test3 for more processes than blocks - no empty space left to none of the blocks
+        sizeOfBlocks = new int[]{5, 12, 17};
+        sizeOfProcesses = new int[]{5, 12, 10, 7};
+        memAllocation = firstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(0, 1, 2, 2)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForSameInputDifferentQuery() {
+        //test4 for more processes than blocks - one element does not fit due to input series
+        sizeOfBlocks = new int[]{5, 12, 17};
+        sizeOfProcesses = new int[]{5, 7, 10, 12};
+        memAllocation = firstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(0, 1, 2, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForMoreBlocksNoFit() {
+        //test5 for more blocks than processes
+        sizeOfBlocks = new int[] {5, 4, -1, 3, 6};
+        sizeOfProcesses = new int [] {10, 11};
+        memAllocation = firstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList( -255, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+}

src/test/java/com/thealgorithms/others/NextFitTest.java

@@ -0,0 +1,76 @@
+package com.thealgorithms.others;
+
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * author Alexandros Lemonaris
+ */
+class NextFitCPUTest {
+    int [] sizeOfBlocks;
+    int [] sizeOfProcesses;
+    ArrayList<Integer> memAllocation = new ArrayList<>();
+    ArrayList<Integer> testMemAllocation ;
+    CPUalgorithms nextFit = new NextFit();
+
+    @Test
+    void testFitForUseOfOneBlock() {
+        //test1 - third process does not fit because of algorithms procedure
+        sizeOfBlocks = new int[]{5, 12, 17, 10};
+        sizeOfProcesses = new int[]{10, 5, 15, 2};
+        memAllocation = nextFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(1, 2, -255, 2)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForEqualProcecesses() {
+        //test2
+        sizeOfBlocks = new int[]{5, 12, 17, 10};
+        sizeOfProcesses = new int[]{10, 10, 10, 10};
+        memAllocation = nextFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(1, 2, 3, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForNoEmptyBlockCell() {
+        //test3 for more processes than blocks - no empty space left to none of the blocks
+        sizeOfBlocks = new int[]{5, 12, 17};
+        sizeOfProcesses = new int[]{5, 12, 10, 7};
+        memAllocation = nextFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(0, 1, 2, 2)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForSameInputDifferentQuery() {
+        //test4 for more processes than blocks - one element does not fit due to input series
+        sizeOfBlocks = new int[]{5, 12, 17};
+        sizeOfProcesses = new int[]{5, 7, 10, 12};
+        memAllocation = nextFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(0, 1, 2, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForMoreBlocksNoFit() {
+        //test5 for more blocks than processes
+        sizeOfBlocks = new int[] {5, 4, -1, 3, 6};
+        sizeOfProcesses = new int [] {10, 11};
+        memAllocation = nextFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList( -255, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+}

src/test/java/com/thealgorithms/others/WorstFitCPUTest.java

@@ -0,0 +1,87 @@
+package com.thealgorithms.others;
+
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * author Alexandros Lemonaris
+ */
+class WorstFitCPUTest {
+    int [] sizeOfBlocks;
+    int [] sizeOfProcesses;
+    ArrayList<Integer> memAllocation = new ArrayList<>();
+    ArrayList<Integer> testMemAllocation ;
+    CPUalgorithms worstFit = new WorstFitCPU();
+
+    @Test
+    void testFitForUseOfOneBlock() {
+        //test1
+        sizeOfBlocks = new int[]{5, 12, 17, 10};
+        sizeOfProcesses = new int[]{10, 5, 15, 2};
+        memAllocation = worstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(2, 1, -255, 3)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForEqualProcecesses() {
+        //test2
+        sizeOfBlocks = new int[]{5, 12, 17, 10};
+        sizeOfProcesses = new int[]{10, 10, 10, 10};
+        memAllocation = worstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(2, 1, 3, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForNoEmptyBlockCell() {
+        //test3 - could suits best, bad use of memory allocation due to worstFit algorithm
+        sizeOfBlocks = new int[]{5, 12, 17};
+        sizeOfProcesses = new int[]{5, 12, 10, 7};
+        memAllocation = worstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(2, 1, 2, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForSameInputDifferentQuery() {
+        //test4 same example different series - same results
+        sizeOfBlocks = new int[]{5, 12, 17};
+        sizeOfProcesses = new int[]{5, 7, 10, 12};
+        memAllocation = worstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList(2, 1, 2, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitForMoreBlocksNoFit() {
+        //test5 for more blocks than processes
+        sizeOfBlocks = new int[] {5, 4, -1, 3, 6};
+        sizeOfProcesses = new int [] {10, 11};
+        memAllocation = worstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList( -255, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+    @Test
+    void testFitBadCase() {
+        //test6 for only two process fit
+        sizeOfBlocks = new int[] {7, 17, 7, 5, 6};
+        sizeOfProcesses = new int [] {8, 10, 10, 8, 8, 8};
+        memAllocation = worstFit.fitProcess(sizeOfBlocks, sizeOfProcesses);
+        testMemAllocation = new ArrayList<>(
+                Arrays.asList( 1, -255, -255, 1, -255, -255)
+        );
+        assertEquals(testMemAllocation, memAllocation);
+    }
+}