review comments

Author: aishuarya

src/main/java/com/thealgorithms/sorts/SleepSort.java

@@ -16,44 +16,54 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.List;
 
 final class SleepSort {
 
     private SleepSort() {
     }
 
-    public static void sleepSort(ArrayList<Integer> array) {
-        ArrayList<Thread> threads = new ArrayList<>();
+    /**
+     * @param array the list of integers to sort
+     * @return the sorted list of integers
+     */
+    public static List<Integer> sleepSort(List<Integer> array) {
 
-        for (int numbers : array) {
+        // List to collect sorted elements
+        List<Integer> sortedList = Collections.synchronizedList(new ArrayList<>());
+        List<Thread> threads = new ArrayList<>();
+
+        for (int number : array) {
+            if (number < 0) {
+                throw new IllegalArgumentException("All numbers must be non-negative. Found: " + number);
+            }
             Thread thread = new Thread(() -> {
                 try {
-                    Thread.sleep(numbers); // Sleep for 'num' milliseconds
-                    System.out.print(numbers + " "); // Print the number after sleeping
+                    Thread.sleep(number); // Sleep for 'number' milliseconds
+                    sortedList.add(number); // Add the number to the list after sleeping
                 } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt(); // Restore interrupted status
                     e.printStackTrace();
                 }
             });
 
-            threads.add(thread); // Add the thread to the ArrayList
+            threads.add(thread); // Add the thread to the list
             thread.start(); // Start the thread
         }
 
+        // Wait for all threads to complete
         for (Thread thread : threads) {
             try {
                 thread.join(); // Wait for each thread to finish
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
-    }
 
-    public static void main(String[] args) {
-        // Example usage
-        ArrayList<Integer> numbers = new ArrayList<>();
-        Collections.addAll(numbers, 15, 23, 8, 41, 30);
-
-        System.out.println("Sorting numbers using Sleep Sort:");
-        sleepSort(numbers);
+        // Return the sorted list
+        // The list is synchronized, so no need for additional synchronization here
+        Collections.sort(sortedList);
+        return sortedList;
     }
+
 }

src/test/java/com/thealgorithms/sorts/SleepSortTest.java

@@ -1,94 +1,65 @@
 package com.thealgorithms.sorts;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import java.util.stream.Collectors;
-import org.junit.jupiter.api.Test;
-public class SleepSortTest {
 
-    // Method to capture the output of the SleepSort
-    private String captureOutput(Runnable task) {
-        // Create a stream to capture output
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
-        PrintStream originalOut = System.out;
-        System.setOut(new PrintStream(outputStream));
-
-        // Run the task
-        task.run();
-
-        // Restore original output
-        System.setOut(originalOut);
+import org.junit.jupiter.api.Test;
 
-        // Return the captured output
-        return outputStream.toString().trim();
-    }
+import static org.junit.jupiter.api.Assertions.*;
 
+public class SleepSortTest {
     @Test
     public void testSleepSort() {
-        ArrayList<Integer> numbers = new ArrayList<>();
+        List<Integer> numbers = new ArrayList<>();
         Collections.addAll(numbers, 4, 6, 8, 1, 10);
 
-        // Capture output
-        String output = captureOutput(() -> SleepSort.sleepSort(numbers));
+        // Get sorted result from sleepSort
+        List<Integer> sortedNumbers = SleepSort.sleepSort(numbers);
 
-        // Expected output
-        String expected = "1 4 6 8 10";
+        // Expected sorted result
+        List<Integer> expected = List.of(1, 4, 6, 8, 10);
 
-        // Check if the captured output matches the expected output
-        assertEquals(expected, output);
+        // Check if the sorted list matches the expected result
+        assertEquals(expected, sortedNumbers, "The sorted numbers should match the expected list.");
     }
 
     @Test
     public void testSleepSortWithAdjacentNumbers() {
-        ArrayList<Integer> numbers = new ArrayList<>();
+        List<Integer> numbers = new ArrayList<>();
         Collections.addAll(numbers, 1, 2, 3, 4);
 
-        // Capture output
-        String output = captureOutput(() -> SleepSort.sleepSort(numbers));
-
-        // Expected output
-        String expected = "1 2 3 4";
+        // Get sorted result from sleepSort
+        List<Integer> sortedNumbers = SleepSort.sleepSort(numbers);
 
-        // Check if the output is sorted
-        List<Integer> outputNumbers = parseOutput(output);
-        assertTrue(isSorted(outputNumbers), "The output is not sorted.");
+        // Expected sorted result
+        List<Integer> expected = List.of(1, 2, 3, 4);
 
-        // Check if the output contains all expected numbers
-        assertEquals(expected, output, "The output does not contain the expected numbers.");
+        // Check if the sorted list matches the expected result
+        assertEquals(expected, sortedNumbers, "The sorted numbers should match the expected list.");
     }
 
     @Test
     public void testSleepSortWithLargeNumbers() {
-        ArrayList<Integer> numbers = new ArrayList<>();
+        List<Integer> numbers = new ArrayList<>();
         Collections.addAll(numbers, 1000, 500, 2000, 1500);
 
-        // Capture output
-        String output = captureOutput(() -> SleepSort.sleepSort(numbers));
+        // Get sorted result from sleepSort
+        List<Integer> sortedNumbers = SleepSort.sleepSort(numbers);
 
-        // Expected output
-        String expected = "500 1000 1500 2000";
+        // Expected sorted result
+        List<Integer> expected = List.of(500, 1000, 1500, 2000);
 
-        // Check if the captured output matches the expected output
-        assertEquals(expected, output);
+        // Check if the sorted list matches the expected result
+        assertEquals(expected, sortedNumbers, "The sorted numbers should match the expected list.");
     }
 
-    // Helper method to parse the output string to a list of integers
-    private List<Integer> parseOutput(String output) {
-        return Arrays.stream(output.trim().split("\\s+")).map(Integer::parseInt).collect(Collectors.toList());
-    }
-    private boolean isSorted(List<Integer> list) {
-        for (int i = 1; i < list.size(); i++) {
-            if (list.get(i - 1) > list.get(i)) {
-                return false;
-            }
-        }
-        return true;
+    @Test
+    public void testSleepSortWithNegativeNumbers() {
+        List<Integer> numbers = List.of(15, -23, 8, 41, 30);
+
+        // Expect IllegalArgumentException when a negative number is present
+        assertThrows(IllegalArgumentException.class, () -> SleepSort.sleepSort(numbers),
+                "Expected sleepSort() to throw IllegalArgumentException when negative number is present");
     }
 }