Repository: TheAlgorithms/Java
Pull request #2935 (2022-02-05 14:27:51)

Compressed CPU algorithms(FirstFit, BestFit, WorstFit) to one "mother…
CPUalgorithms abstract - "mother" - runnable class

### **Describe your change:**
Compressed CPU algorithms (First Fit, Best Fit, Worst Fit ) into one class. The class CPUalgorithms is abstract so that fitProcess and printMemoryAllocation methods are implemented in each algorithm differently. Use of inheritance among the class CPUalgorithms and the three algorithm's classes. The class CPUalgorithms is runnable in order to test algorithms. 
- [x] Add an algorithm?
- [ ] Fix a bug or typo in an existing algorithm?
- [ ] Documentation change?

#### References

<!-- Add any reference to previous pull-request or issue -->

### **Checklist:**

<!-- Remove items that do not apply. For completed items, change [ ] to [x]. -->

- [x] I have read [CONTRIBUTING.md](https://github.com/TheAlgorithms/Java/blob/master/CONTRIBUTING.md).
- [x] This pull request is all my own work -- I have not plagiarized.
- [x] I know that pull requests will not be merged if they fail the automated tests.
- [x] This PR only changes one algorithm file. To ease review, please open separate PRs for separate algorithms.
- [x] All new Java files are placed inside an existing directory.
- [x] All filenames are in all uppercase characters with no spaces or dashes.
- [x] All functions and variable names follow Java naming conventions.
- [x] All new algorithms have a URL in its comments that points to Wikipedia or other similar explanation.
- [x] If this pull request resolves one or more open issues then the commit message contains `Fixes: #{$ISSUE_NO}`.



Patch:
diff --git a/src/main/java/com/thealgorithms/others/BestFit.java b/src/main/java/com/thealgorithms/others/BestFit.java
deleted file mode 100644
index f5ee41a7..00000000
--- a/src/main/java/com/thealgorithms/others/BestFit.java
+++ /dev/null
@@ -1,106 +0,0 @@
-package com.thealgorithms.others;
-
-import java.util.ArrayList;
-
-/**
- * @author Dekas Dimitrios
- */
-public class BestFit {
-
-    private static final int NO_ALLOCATION
-            = -255; // if a process has been allocated in position -255,
-    // it means that it has not been actually allocated.
-
-    /**
-     * Method to find the maximum valued element of an array filled with
-     * positive integers.
-     *
-     * @param array: an array filled with positive integers.
-     * @return the maximum valued element of the array.
-     */
-    private static int findMaxElement(int[] array) {
-        int max = -1;
-        for (int value : array) {
-            if (value > max) {
-                max = value;
-            }
-        }
-        return max;
-    }
-
-    /**
-     * Method to find the index of the memory block that is going to fit the
-     * given process based on the best fit algorithm.
-     *
-     * @param blocks: the array with the available memory blocks.
-     * @param process: the size of the process.
-     * @return the index of the block that fits, or -255 if no such block
-     * exists.
-     */
-    private static int findBestFit(int[] blockSizes, int processSize) {
-        // Initialize minDiff with an unreachable value by a difference between a blockSize and the
-        // processSize.
-        int minDiff = findMaxElement(blockSizes);
-        int index
-                = NO_ALLOCATION; // If there is no block that can fit the process, return NO_ALLOCATION as the
-        // result.
-        for (int i = 0;
-                i < blockSizes.length;
-                i++) { // Find the most fitting memory block for the given process.
-            if (blockSizes[i] - processSize < minDiff && blockSizes[i] - processSize >= 0) {
-                minDiff = blockSizes[i] - processSize;
-                index = i;
-            }
-        }
-        return index;
-    }
-
-    /**
-     * Method to allocate memory to blocks according to the best fit algorithm.
-     * It should return an ArrayList of Integers, where the index is the process
-     * ID (zero-indexed) and the value is the block number (also zero-indexed).
-     *
-     * @param sizeOfBlocks: an int array that contains the sizes of the memory
-     * blocks available.
-     * @param sizeOfProcesses: an int array that contains the sizes of the
-     * processes we need memory blocks for.
-     * @return the ArrayList filled with Integers repressenting the memory
-     * allocation that took place.
-     */
-    static ArrayList<Integer> bestFit(int[] sizeOfBlocks, int[] sizeOfProcesses) {
-        // The array list responsible for saving the memory allocations done by the best-fit algorithm
-        ArrayList<Integer> memAlloc = new ArrayList<>();
-        // Do this for every process
-        for (int processSize : sizeOfProcesses) {
-            int chosenBlockIdx
-                    = findBestFit(
-                            sizeOfBlocks, processSize); // Find the index of the memory block going to be used
-            memAlloc.add(chosenBlockIdx); // Store the chosen block index in the memAlloc array list
-            if (chosenBlockIdx
-                    != NO_ALLOCATION) { // Only if a block was chosen to store the process in it,
-                sizeOfBlocks[chosenBlockIdx] -= processSize; // resize the block based on the process size
-            }
-        }
-        return memAlloc;
-    }
-
-    /**
-     * Method to print the memory allocated.
-     *
-     * @param memAllocation: an ArrayList of Integer representing the memory
-     * allocation done by the bestFit method.
-     */
-    public static void printMemoryAllocation(ArrayList<Integer> memAllocation) {
-        System.out.println("Process No.\tBlock No.");
-        System.out.println("===========\t=========");
-        for (int i = 0; i < memAllocation.size(); i++) {
-            System.out.print(" " + i + "\t\t");
-            if (memAllocation.get(i) != NO_ALLOCATION) {
-                System.out.print(memAllocation.get(i));
-            } else {
-                System.out.print("Not Allocated");
-            }
-            System.out.println();
-        }
-    }
-}
diff --git a/src/main/java/com/thealgorithms/others/CPUalgorithms.java b/src/main/java/com/thealgorithms/others/CPUalgorithms.java
new file mode 100644
index 00000000..89205f98
--- /dev/null
+++ b/src/main/java/com/thealgorithms/others/CPUalgorithms.java
@@ -0,0 +1,301 @@
+package com.thealgorithms.others;
+/**
+ * @author Alexandros Lemonaris
+ */
+
+import java.util.ArrayList;
+
+public abstract class CPUalgorithms {
+
+    /**
+     * Method to allocate memory to blocks according to CPU algorithms.
+     * Use of inheritance to avoid repeated code.
+     * Abstract method since it is implemented different for each algorithm.
+     * It should return an ArrayList of Integers, where the index is the process
+     * ID (zero-indexed) and the value is the block number (also zero-indexed).
+     * @param sizeOfBlocks an int array that contains the sizes of the memory
+     * blocks available.
+     * @param sizeOfProcesses: an int array that contains the sizes of the
+     * processes we need memory blocks for.
+     * @return the ArrayList filled with Integers repressenting the memory
+     * allocation that took place.
+     */
+    public abstract ArrayList<Integer> fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses);
+
+}
+/**
+ * @author Dekas Dimitrios
+ */
+class BestFitCPU extends CPUalgorithms{
+
+    private static final int NO_ALLOCATION
+            = -255; // if a process has been allocated in position -255,
+    // it means that it has not been actually allocated.
+
+    /**
+     * Method to find the maximum valued element of an array filled with
+     * positive integers.
+     *
+     * @param array: an array filled with positive integers.
+     * @return the maximum valued element of the array.
+     */
+    private static int findMaxElement(int[] array) {
+        int max = -1;
+        for (int value : array) {
+            if (value > max) {
+                max = value;
+            }
+        }
+        return max;
+    }
+
+    /**
+     * Method to find the index of the memory block that is going to fit the
+     * given process based on the best fit algorithm.
+     *
+     * @param blocks: the array with the available memory blocks.
+     * @param process: the size of the process.
+     * @return the index of the block that fits, or -255 if no such block
+     * exists.
+     */
+    private static int findBestFit(int[] blockSizes, int processSize) {
+        // Initialize minDiff with an unreachable value by a difference between a blockSize and the
+        // processSize.
+        int minDiff = findMaxElement(blockSizes);
+        int index
+                = NO_ALLOCATION; // If there is no block that can fit the process, return NO_ALLOCATION as the
+        // result.
+        for (int i = 0;
+             i < blockSizes.length;
+             i++) { // Find the most fitting memory block for the given process.
+            if (blockSizes[i] - processSize < minDiff && blockSizes[i] - processSize >= 0) {
+                minDiff = blockSizes[i] - processSize;
+                index = i;
+            }
+        }
+        return index;
+    }
+
+    /**
+     * Method to allocate memory to blocks according to the best fit algorithm.
+     * It should return an ArrayList of Integers, where the index is the process
+     * ID (zero-indexed) and the value is the block number (also zero-indexed).
+     *
+     * @param sizeOfBlocks: an int array that contains the sizes of the memory
+     * blocks available.
+     * @param sizeOfProcesses: an int array that contains the sizes of the
+     * processes we need memory blocks for.
+     * @return the ArrayList filled with Integers repressenting the memory
+     * allocation that took place.
+     */
+    public ArrayList<Integer> fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) {
+        // The array list responsible for saving the memory allocations done by the best-fit algorithm
+        ArrayList<Integer> memAlloc = new ArrayList<>();
+        // Do this for every process
+        for (int processSize : sizeOfProcesses) {
+            int chosenBlockIdx
+                    = findBestFit(
+                    sizeOfBlocks, processSize); // Find the index of the memory block going to be used
+            memAlloc.add(chosenBlockIdx); // Store the chosen block index in the memAlloc array list
+            if (chosenBlockIdx
+                    != NO_ALLOCATION) { // Only if a block was chosen to store the process in it,
+                sizeOfBlocks[chosenBlockIdx] -= processSize; // resize the block based on the process size
+            }
+        }
+        return memAlloc;
+    }
+
+}
+
+/**
+ * @author Dekas Dimitrios
+ */
+class WorstFitCPU extends CPUalgorithms{
+
+    private static final int NO_ALLOCATION
+            = -255; // if a process has been allocated in position -255,
+    // it means that it has not been actually allocated.
+
+    /**
+     * Method to find the index of the memory block that is going to fit the
+     * given process based on the worst fit algorithm.
+     *
+     * @param blocks: the array with the available memory blocks.
+     * @param process: the size of the process.
+     * @return the index of the block that fits, or -255 if no such block
+     * exists.
+     */
+    private static int findWorstFit(int[] blockSizes, int processSize) {
+        int max = -1;
+        int index = -1;
+        for (int i = 0;
+             i < blockSizes.length;
+             i++) { // Find the index of the biggest memory block available.
+            if (blockSizes[i] > max) {
+                max = blockSizes[i];
+                index = i;
+            }
+        }
+        // If the biggest memory block cannot fit the process, return -255 as the result
+        if (processSize > blockSizes[index]) {
+            return NO_ALLOCATION;
+        }
+        return index;
+    }
+
+    /**
+     * Method to allocate memory to blocks according to the worst fit algorithm.
+     * It should return an ArrayList of Integers, where the index is the process
+     * ID (zero-indexed) and the value is the block number (also zero-indexed).
+     *
+     * @param sizeOfBlocks: an int array that contains the sizes of the memory
+     * blocks available.
+     * @param sizeOfProcesses: an int array that contains the sizes of the
+     * processes we need memory blocks for.
+     * @return the ArrayList filled with Integers repressenting the memory
+     * allocation that took place.
+     */
+    public ArrayList<Integer> fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) {
+        // The array list responsible for saving the memory allocations done by the worst-fit algorithm
+        ArrayList<Integer> memAlloc = new ArrayList<>();
+        // Do this for every process
+        for (int processSize : sizeOfProcesses) {
+            int chosenBlockIdx
+                    = findWorstFit(
+                    sizeOfBlocks, processSize); // Find the index of the memory block going to be used
+            memAlloc.add(chosenBlockIdx); // Store the chosen block index in the memAlloc array list
+            if (chosenBlockIdx
+                    != NO_ALLOCATION) { // Only if a block was chosen to store the process in it,
+                sizeOfBlocks[chosenBlockIdx] -= processSize; // resize the block based on the process size
+            }
+        }
+        return memAlloc;
+    }
+
+}
+
+/**
+ * @author Dekas Dimitrios
+ */
+class FirstFitCPU extends CPUalgorithms{
+
+    private static final int NO_ALLOCATION
+            = -255; // if a process has been allocated in position -255,
+    // it means that it has not been actually allocated.
+
+    /**
+     * Method to find the index of the memory block that is going to fit the
+     * given process based on the first fit algorithm.
+     *
+     * @param blocks: the array with the available memory blocks.
+     * @param process: the size of the process.
+     * @return the index of the block that fits, or -255 if no such block
+     * exists.
+     */
+    private static int findFirstFit(int[] blockSizes, int processSize) {
+        for (int i = 0; i < blockSizes.length; i++) {
+            if (blockSizes[i] >= processSize) {
+                return i;
+            }
+        }
+        // If there is not a block that can fit the process, return -255 as the result
+        return NO_ALLOCATION;
+    }
+
+    /**
+     * Method to allocate memory to blocks according to the first fit algorithm.
+     * It should return an ArrayList of Integers, where the index is the process
+     * ID (zero-indexed) and the value is the block number (also zero-indexed).
+     *
+     * @param sizeOfBlocks: an int array that contains the sizes of the memory
+     * blocks available.
+     * @param sizeOfProcesses: an int array that contains the sizes of the
+     * processes we need memory blocks for.
+     * @return the ArrayList filled with Integers repressenting the memory
+     * allocation that took place.
+     */
+    public ArrayList<Integer> fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) {
+        // The array list responsible for saving the memory allocations done by the first-fit algorithm
+        ArrayList<Integer> memAlloc = new ArrayList<>();
+        // Do this for every process
+        for (int processSize : sizeOfProcesses) {
+            int chosenBlockIdx
+                    = findFirstFit(
+                    sizeOfBlocks, processSize); // Find the index of the memory block going to be used
+            memAlloc.add(chosenBlockIdx); // Store the chosen block index in the memAlloc array list
+            if (chosenBlockIdx
+                    != NO_ALLOCATION) { // Only if a block was chosen to store the process in it,
+                sizeOfBlocks[chosenBlockIdx] -= processSize; // resize the block based on the process size
+            }
+        }
+        return memAlloc;
+    }
+
+}
+
+/**
+ * @author Alexandros Lemonaris
+ */
+class NextFit extends CPUalgorithms{
+
+    private static final int NO_ALLOCATION
+            = -255; // if a process has been allocated in position -255,
+    // it means that it has not been actually allocated.
+    private int counter = 0; // variable that keeps the position of the last registration into the memory
+    /**
+     * Method to find the index of the memory block that is going to fit the
+     * given process based on the next fit algorithm. In the case of next fit,
+     * if the search is interrupted in between, the new search is carried out from the last location.
+     *
+     * @param blocks: the array with the available memory blocks.
+     * @param process: the size of the process.
+     * @return the index of the block that fits, or -255 if no such block
+     * exists.
+     */
+    private int findNextFit(int[] blockSizes, int processSize) {
+
+        for (int i = 0; i < blockSizes.length; i++) {
+            if (counter + i >= blockSizes.length){
+                counter = -i; // starts from the start of the array
+            }
+            if (blockSizes[i + counter] >= processSize) {
+                counter += i;
+                return counter;
+            }
+        }
+        // If there is not a block that can fit the process, return -255 as the result
+        counter += blockSizes.length; // counter keeps its last value
+        return NO_ALLOCATION;
+    }
+
+    /**
+     * Method to allocate memory to blocks according to the first fit algorithm.
+     * It should return an ArrayList of Integers, where the index is the process
+     * ID (zero-indexed) and the value is the block number (also zero-indexed).
+     *
+     * @param sizeOfBlocks: an int array that contains the sizes of the memory
+     * blocks available.
+     * @param sizeOfProcesses: an int array that contains the sizes of the
+     * processes we need memory blocks for.
+     * @return the ArrayList filled with Integers repressenting the memory
+     * allocation that took place.
+     */
+    public ArrayList<Integer> fitProcess(int[] sizeOfBlocks, int[] sizeOfProcesses) {
+        // The array list responsible for saving the memory allocations done by the first-fit algorithm
+        ArrayList<Integer> memAlloc = new ArrayList<>();
+        // Do this for every process
+        for (int processSize : sizeOfProcesses) {
+            int chosenBlockIdx
+                    = findNextFit(
+                    sizeOfBlocks, processSize); // Find the index of the memory block going to be used
+            memAlloc.add(chosenBlockIdx); // Store the chosen block index in the memAlloc array list
+            if (chosenBlockIdx
+                    != NO_ALLOCATION) { // Only if a block was chosen to store the process in it,
+                sizeOfBlocks[chosenBlockIdx] -= processSize; // resize the block based on the process size
+            }
+        }
+        return memAlloc;
+    }
+
+}
+
diff --git a/src/main/java/com/thealgorithms/others/FirstFit.java b/src/main/java/com/thealgorithms/others/FirstFit.java
deleted file mode 100644
index c7035d66..00000000
--- a/src/main/java/com/thealgorithms/others/FirstFit.java
+++ /dev/null
@@ -1,81 +0,0 @@
-package com.thealgorithms.others;
-
-import java.util.ArrayList;
-
-/**
- * @author Dekas Dimitrios
- */
-public class FirstFit {
-
-    private static final int NO_ALLOCATION
-            = -255; // if a process has been allocated in position -255,
-    // it means that it has not been actually allocated.
-
-    /**
-     * Method to find the index of the memory block that is going to fit the
-     * given process based on the first fit algorithm.
-     *
-     * @param blocks: the array with the available memory blocks.
-     * @param process: the size of the process.
-     * @return the index of the block that fits, or -255 if no such block
-     * exists.
-     */
-    private static int findFirstFit(int[] blockSizes, int processSize) {
-        for (int i = 0; i < blockSizes.length; i++) {
-            if (blockSizes[i] >= processSize) {
-                return i;
-            }
-        }
-        // If there is not a block that can fit the process, return -255 as the result
-        return NO_ALLOCATION;
-    }
-
-    /**
-     * Method to allocate memory to blocks according to the first fit algorithm.
-     * It should return an ArrayList of Integers, where the index is the process
-     * ID (zero-indexed) and the value is the block number (also zero-indexed).
-     *
-     * @param sizeOfBlocks: an int array that contains the sizes of the memory
-     * blocks available.
-     * @param sizeOfProcesses: an int array that contains the sizes of the
-     * processes we need memory blocks for.
-     * @return the ArrayList filled with Integers repressenting the memory
-     * allocation that took place.
-     */
-    static ArrayList<Integer> firstFit(int[] sizeOfBlocks, int[] sizeOfProcesses) {
-        // The array list responsible for saving the memory allocations done by the first-fit algorithm
-        ArrayList<Integer> memAlloc = new ArrayList<>();
-        // Do this for every process
-        for (int processSize : sizeOfProcesses) {
-            int chosenBlockIdx
-                    = findFirstFit(
-                            sizeOfBlocks, processSize); // Find the index of the memory block going to be used
-            memAlloc.add(chosenBlockIdx); // Store the chosen block index in the memAlloc array list
-            if (chosenBlockIdx
-                    != NO_ALLOCATION) { // Only if a block was chosen to store the process in it,
-                sizeOfBlocks[chosenBlockIdx] -= processSize; // resize the block based on the process size
-            }
-        }
-        return memAlloc;
-    }
-
-    /**
-     * Method to print the memory allocated.
-     *
-     * @param memAllocation: an ArrayList of Integer representing the memory
-     * allocation done by the firstFit method.
-     */
-    public static void printMemoryAllocation(ArrayList<Integer> memAllocation) {
-        System.out.println("Process No.\tBlock No.");
-        System.out.println("===========\t=========");
-        for (int i = 0; i < memAllocation.size(); i++) {
-            System.out.print(" " + i + "\t\t");
-            if (memAllocation.get(i) != NO_ALLOCATION) {
-                System.out.print(memAllocation.get(i));
-            } else {
-                System.out.print("Not Allocated");
-            }
-            System.out.println();
-        }
-    }
-}
diff --git a/src/main/java/com/thealgorithms/others/WorstFit.java b/src/main/java/com/thealgorithms/others/WorstFit.java
deleted file mode 100644
index 69aedc1e..00000000
--- a/src/main/java/com/thealgorithms/others/WorstFit.java
+++ /dev/null
@@ -1,89 +0,0 @@
-package com.thealgorithms.others;
-
-import java.util.ArrayList;
-
-/**
- * @author Dekas Dimitrios
- */
-public class WorstFit {
-
-    private static final int NO_ALLOCATION
-            = -255; // if a process has been allocated in position -255,
-    // it means that it has not been actually allocated.
-
-    /**
-     * Method to find the index of the memory block that is going to fit the
-     * given process based on the worst fit algorithm.
-     *
-     * @param blocks: the array with the available memory blocks.
-     * @param process: the size of the process.
-     * @return the index of the block that fits, or -255 if no such block
-     * exists.
-     */
-    private static int findWorstFit(int[] blockSizes, int processSize) {
-        int max = -1;
-        int index = -1;
-        for (int i = 0;
-                i < blockSizes.length;
-                i++) { // Find the index of the biggest memory block available.
-            if (blockSizes[i] > max) {
-                max = blockSizes[i];
-                index = i;
-            }
-        }
-        // If the biggest memory block cannot fit the process, return -255 as the result
-        if (processSize > blockSizes[index]) {
-            return NO_ALLOCATION;
-        }
-        return index;
-    }
-
-    /**
-     * Method to allocate memory to blocks according to the worst fit algorithm.
-     * It should return an ArrayList of Integers, where the index is the process
-     * ID (zero-indexed) and the value is the block number (also zero-indexed).
-     *
-     * @param sizeOfBlocks: an int array that contains the sizes of the memory
-     * blocks available.
-     * @param sizeOfProcesses: an int array that contains the sizes of the
-     * processes we need memory blocks for.
-     * @return the ArrayList filled with Integers repressenting the memory
-     * allocation that took place.
-     */
-    static ArrayList<Integer> worstFit(int[] sizeOfBlocks, int[] sizeOfProcesses) {
-        // The array list responsible for saving the memory allocations done by the worst-fit algorithm
-        ArrayList<Integer> memAlloc = new ArrayList<>();
-        // Do this for every process
-        for (int processSize : sizeOfProcesses) {
-            int chosenBlockIdx
-                    = findWorstFit(
-                            sizeOfBlocks, processSize); // Find the index of the memory block going to be used
-            memAlloc.add(chosenBlockIdx); // Store the chosen block index in the memAlloc array list
-            if (chosenBlockIdx
-                    != NO_ALLOCATION) { // Only if a block was chosen to store the process in it,
-                sizeOfBlocks[chosenBlockIdx] -= processSize; // resize the block based on the process size
-            }
-        }
-        return memAlloc;
-    }
-
-    /**
-     * Method to print the memory allocated.
-     *
-     * @param memAllocation: an ArrayList of Integer representing the memory
-     * allocation done by the worstFit method.
-     */
-    public static void printMemoryAllocation(ArrayList<Integer> memAllocation) {
-        System.out.println("Process No.\tBlock No.");
-        System.out.println("===========\t=========");
-        for (int i = 0; i < memAllocation.size(); i++) {
-            System.out.print(" " + i + "\t\t");
-            if (memAllocation.get(i) != NO_ALLOCATION) {
-                System.out.print(memAllocation.get(i));
-            } else {
-                System.out.print("Not Allocated");
-            }
-            System.out.println();
-        }
-    }
-}


Test patch:
diff --git a/src/test/java/com/thealgorithms/others/BestFitCPUTest.java b/src/test/java/com/thealgorithms/others/BestFitCPUTest.java
new file mode 100644
index 00000000..d1ab5916
--- /dev/null
+++ b/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);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/thealgorithms/others/FirstFitCPUTest.java b/src/test/java/com/thealgorithms/others/FirstFitCPUTest.java
new file mode 100644
index 00000000..45a501c2
--- /dev/null
+++ b/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);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/thealgorithms/others/NextFitTest.java b/src/test/java/com/thealgorithms/others/NextFitTest.java
new file mode 100644
index 00000000..27c17eaf
--- /dev/null
+++ b/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);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/thealgorithms/others/WorstFitCPUTest.java b/src/test/java/com/thealgorithms/others/WorstFitCPUTest.java
new file mode 100644
index 00000000..cb3f58a4
--- /dev/null
+++ b/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);
+    }
+}
\ No newline at end of file