diff --git a/DIRECTORY.md b/DIRECTORY.md
index 23f2941a702c..ff6e29806847 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1006,6 +1006,7 @@
             * [HowManyTimesRotatedTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/HowManyTimesRotatedTest.java)
             * [InterpolationSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/InterpolationSearchTest.java)
             * [IterativeBinarySearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/IterativeBinarySearchTest.java)
+            * [IterativeTernarySearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/IterativeTernarySearchTest.java)
             * [KMPSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/KMPSearchTest.java)
             * [OrderAgnosticBinarySearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/OrderAgnosticBinarySearchTest.java)
             * [PerfectBinarySearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/PerfectBinarySearchTest.java)
diff --git a/src/main/java/com/thealgorithms/searches/IterativeTernarySearch.java b/src/main/java/com/thealgorithms/searches/IterativeTernarySearch.java
index e78acd6a7ef8..585d6787d3f8 100644
--- a/src/main/java/com/thealgorithms/searches/IterativeTernarySearch.java
+++ b/src/main/java/com/thealgorithms/searches/IterativeTernarySearch.java
@@ -1,22 +1,26 @@
 package com.thealgorithms.searches;
 
 import com.thealgorithms.devutils.searches.SearchAlgorithm;
-import java.util.Arrays;
-import java.util.Random;
-import java.util.stream.Stream;
 
 /**
- * A iterative version of a ternary search algorithm This is better way to
- * implement the ternary search, because a recursive version adds some overhead
- * to a stack. But in java the compile can transform the recursive version to
- * iterative implicitly, so there are no much differences between these two
- * algorithms
+ * An iterative implementation of the Ternary Search algorithm.
  *
  * <p>
- * Worst-case performance Θ(log3(N)) Best-case performance O(1) Average
- * performance Θ(log3(N)) Worst-case space complexity O(1)
+ * Ternary search is a divide-and-conquer algorithm that splits the array into three parts
+ * instead of two, as in binary search. This implementation is iterative, reducing the overhead
+ * associated with recursive function calls. However, the recursive version can also be optimized
+ * by the Java compiler to resemble the iterative version, resulting in similar performance.
+ *
+ * <p>
+ * Worst-case performance: Θ(log3(N))<br>
+ * Best-case performance: O(1)<br>
+ * Average performance: Θ(log3(N))<br>
+ * Worst-case space complexity: O(1)
+ *
+ * <p>
+ * This class implements the {@link SearchAlgorithm} interface, providing a generic search method
+ * for any comparable type.
  *
- * @author Podshivalov Nikita (https://github.com/nikitap492)
  * @see SearchAlgorithm
  * @see TernarySearch
  * @since 2018-04-13
@@ -25,6 +29,13 @@ public class IterativeTernarySearch implements SearchAlgorithm {
 
     @Override
     public <T extends Comparable<T>> int find(T[] array, T key) {
+        if (array == null || array.length == 0 || key == null) {
+            return -1;
+        }
+        if (array.length == 1) {
+            return array[0].compareTo(key) == 0 ? 0 : -1;
+        }
+
         int left = 0;
         int right = array.length - 1;
 
@@ -50,23 +61,4 @@ public <T extends Comparable<T>> int find(T[] array, T key) {
 
         return -1;
     }
-
-    public static void main(String[] args) {
-        // just generate data
-        Random r = new Random();
-        int size = 100;
-        int maxElement = 100000;
-        Integer[] integers = Stream.generate(() -> r.nextInt(maxElement)).limit(size).sorted().toArray(Integer[] ::new);
-
-        // the element that should be found
-        Integer shouldBeFound = integers[r.nextInt(size - 1)];
-
-        IterativeTernarySearch search = new IterativeTernarySearch();
-        int atIndex = search.find(integers, shouldBeFound);
-
-        System.out.printf("Should be found: %d. Found %d at index %d. An array length %d%n", shouldBeFound, integers[atIndex], atIndex, size);
-
-        int toCheck = Arrays.binarySearch(integers, shouldBeFound);
-        System.out.printf("Found by system method at an index: %d. Is equal: %b%n", toCheck, toCheck == atIndex);
-    }
 }
diff --git a/src/test/java/com/thealgorithms/searches/IterativeTernarySearchTest.java b/src/test/java/com/thealgorithms/searches/IterativeTernarySearchTest.java
new file mode 100644
index 000000000000..c7640e6d0672
--- /dev/null
+++ b/src/test/java/com/thealgorithms/searches/IterativeTernarySearchTest.java
@@ -0,0 +1,117 @@
+package com.thealgorithms.searches;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for the IterativeTernarySearch class.
+ */
+class IterativeTernarySearchTest {
+
+    /**
+     * Test for basic ternary search functionality when the element is found.
+     */
+    @Test
+    void testTernarySearchFound() {
+        IterativeTernarySearch ternarySearch = new IterativeTernarySearch();
+        Integer[] array = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512};
+        Integer key = 128;
+        int expectedIndex = 7; // Index of the key in the array
+        assertEquals(expectedIndex, ternarySearch.find(array, key), "The index of the found element should be 7.");
+    }
+
+    /**
+     * Test for ternary search when the element is not present in the array.
+     */
+    @Test
+    void testTernarySearchNotFound() {
+        IterativeTernarySearch ternarySearch = new IterativeTernarySearch();
+        Integer[] array = {1, 2, 4, 8, 16};
+        Integer key = 6; // Element not present in the array
+        assertEquals(-1, ternarySearch.find(array, key), "The element should not be found in the array.");
+    }
+
+    /**
+     * Test for ternary search with the first element as the key.
+     */
+    @Test
+    void testTernarySearchFirstElement() {
+        IterativeTernarySearch ternarySearch = new IterativeTernarySearch();
+        Integer[] array = {1, 2, 4, 8, 16};
+        Integer key = 1; // First element
+        assertEquals(0, ternarySearch.find(array, key), "The index of the first element should be 0.");
+    }
+
+    /**
+     * Test for ternary search with the last element as the key.
+     */
+    @Test
+    void testTernarySearchLastElement() {
+        IterativeTernarySearch ternarySearch = new IterativeTernarySearch();
+        Integer[] array = {1, 2, 4, 8, 16};
+        Integer key = 16; // Last element
+        assertEquals(4, ternarySearch.find(array, key), "The index of the last element should be 4.");
+    }
+
+    /**
+     * Test for ternary search with a single element present.
+     */
+    @Test
+    void testTernarySearchSingleElementFound() {
+        IterativeTernarySearch ternarySearch = new IterativeTernarySearch();
+        Integer[] array = {1};
+        Integer key = 1; // Only element present
+        assertEquals(0, ternarySearch.find(array, key), "The index of the single element should be 0.");
+    }
+
+    /**
+     * Test for ternary search with a single element not present.
+     */
+    @Test
+    void testTernarySearchSingleElementNotFound() {
+        IterativeTernarySearch ternarySearch = new IterativeTernarySearch();
+        Integer[] array = {1};
+        Integer key = 2; // Key not present
+        assertEquals(-1, ternarySearch.find(array, key), "The element should not be found in the array.");
+    }
+
+    /**
+     * Test for ternary search with an empty array.
+     */
+    @Test
+    void testTernarySearchEmptyArray() {
+        IterativeTernarySearch ternarySearch = new IterativeTernarySearch();
+        Integer[] array = {}; // Empty array
+        Integer key = 1; // Key not present
+        assertEquals(-1, ternarySearch.find(array, key), "The element should not be found in an empty array.");
+    }
+
+    /**
+     * Test for ternary search on a large array.
+     */
+    @Test
+    void testTernarySearchLargeArray() {
+        IterativeTernarySearch ternarySearch = new IterativeTernarySearch();
+        Integer[] array = new Integer[10000];
+        for (int i = 0; i < array.length; i++) {
+            array[i] = i * 2;
+        } // Array from 0 to 19998, step 2
+        Integer key = 9998; // Present in the array
+        assertEquals(4999, ternarySearch.find(array, key), "The index of the found element should be 4999.");
+    }
+
+    /**
+     * Test for ternary search on large array with a non-existent key.
+     */
+    @Test
+    void testTernarySearchLargeArrayNotFound() {
+        IterativeTernarySearch ternarySearch = new IterativeTernarySearch();
+        Integer[] array = new Integer[10000];
+        for (int i = 0; i < array.length; i++) {
+            array[i] = i * 2;
+        } // Array from 0 to 19998, step 2
+        Integer key = 9999; // Key not present
+        assertEquals(-1, ternarySearch.find(array, key), "The element should not be found in the array.");
+    }
+}