title: IntelliJ : Class not found: "" Empty test suite
body: <p>I am new to java. I am working on my school project, and I ran into this problem with the error message.</p>
  
  <pre><code>Class not found: ""Empty test suite.
  </code></pre>
  
  <p>I have done tests like this before, and they worked.</p>
  
  <p>I did not write all the methods. I tried to run the file first. I have looked for the solutions but none of them work for my situation.</p>
  
  <p>Here is my test code:</p>
  
  <pre><code>import org.junit.Test;
  
  import static org.junit.Assert.assertEquals;
  
  public class TestLab06 {
  
  @Test
  public void testIntListInsert() {
      int[] arr = {1, 3, 5};
      IntList test1 = new IntList(arr);
      IntList test2 = new IntList();
      test1.insert(2, 1);
      test1.insert(4, 3);
      assertEquals(5, test1.getSize());
      assertEquals(3, test1.get(2));
      assertEquals(4, test1.get(3));
      test2.insert(1, 1);
      assertEquals(1, test2.get(0));
      assertEquals(1, test2.getSize());
      test2.insert(10, 10);
      assertEquals(10, test2.get(1));
  }
  
  @Test
  public void testIntListMerge() {
      int[] arr = {1, 3, 5};
      IntList test1 = new IntList(arr);
      int[] arr2 = {2, 4, 6, 8};
      IntList test2 = new IntList(arr2);
      IntList test = IntList.merge(test1, test2);
      int[] expected ={1, 2, 3, 4, 5, 6, 8};
      for (int i = 0; i &lt; expected.length; i++) {
          assertEquals(expected[i], test.get(i));
      }
  }
  
  @Test
  public void testIntListReverse() {
      int[] arr = {1, 2, 3, 4, 5, 6, 8};
      IntList test1 = new IntList(arr);
      test1.reverse();
      int[] expected = {8, 6, 5, 4, 3, 2, 1};
      for (int i = 0; i &lt; expected.length; i++) {
          assertEquals(expected[i], test1.get(i));
      }
  }
  
  @Test
  public void testDLLInsertRemove() {
      DLList l = new DLList();
      l.insertBack(2);
      l.insertFront(1);
      assertEquals(1, l.get(0));
      l.insert(4, 1);
      assertEquals(4, l.get(1));
      l.insert(1, 10);
      // List is 1, 4, 2, 1
      assertEquals(l.sentinel, l.sentinel.next.next.next.next.prev.prev.prev.prev);
      l.remove(1);
      assertEquals(2, l.size);
      l.remove(l.sentinel.next);
      assertEquals(1, l.size);
      assertEquals(2, l.sentinel.next.item);
  }
  
  @Test
  public void testDLLDoubleReverse() {
      DLList l = new DLList();
      l.insertBack(4);
      l.insertBack(2);
      l.doubleInPlace();
      assertEquals(4, l.size);
      assertEquals(4, l.get(0));
      assertEquals(4, l.get(1));
      assertEquals(2, l.get(2));
      assertEquals(2, l.get(3));
      assertEquals(l.sentinel, l.sentinel.next.next.next.next.prev.prev.prev.prev);
      l.reverse();
      assertEquals(4, l.size);
      assertEquals(4, l.get(3));
      assertEquals(4, l.get(2));
      assertEquals(2, l.get(1));
      assertEquals(2, l.get(0));
      assertEquals(l.sentinel, l.sentinel.next.next.next.next.prev.prev.prev.prev);
  }
  }
  </code></pre>
  
  <p>and this here is my IntList.java</p>
  
  <pre><code>/** A data structure to represent a Linked List of Integers.
   * Each IntList represents one node in the overall Linked List.
   * Encapsulated version.
   */
  public class IntList {
      /** The head of the list is the first node in the list. If the list 
  is empty, head is null **/
  private IntListNode head;
  private int size;
  
  /** IntListNode is a nested class. It can be instantiated when associated with an instance of
   *  IntList.
   *  **/
  public class IntListNode {
      int item;
      IntListNode next;
  
      public IntListNode(int item, IntListNode next) {
          this.item = item;
          this.next = next;
      }
  }
  
  public int getSize() {
      return size;
  }
  
  public IntList() {}
  
  public IntList(int[] initial) {
      for (int i = initial.length - 1; i &gt;= 0; i--) {
          head = new IntListNode(initial[i], head);
      }
      size = initial.length;
  }
  
  /**
   * Get the value at position pos. If the position does not exist, throw an
   * IndexOutOfBoundsException.
   * @param position to get from
   * @return the int at the position in the list.
   */
  public int get(int position) {
      if (position &gt;= size) throw new IndexOutOfBoundsException("Position larger than size of list.");
      IntListNode curr = head;
      while (position &gt; 0) {
          curr = curr.next;
          position--;
      }
      return curr.item;
  }
  
  @java.lang.Override
  public java.lang.String toString() {
      return "IntList{" +
              "head=" + head +
              ", size=" + size +
              '}';
  }
  
  public boolean equals(Object object) {
      if (this == object) return true;
      if (!(object instanceof IntList)) return false;
      if (!super.equals(object)) return false;
      IntList intList = (IntList) object;
      return size == intList.size &amp;&amp;
              java.util.Objects.equals(head, intList.head);
  }
  
  
  
  /* Fill in below! */
  
  /**
   * Insert a new node into the IntList.
   * @param x value to insert
   * @param position position to insert into. If position exceeds the size of the list, insert into
   *            the end of the list.
   */
  public void insert(int x, int position) {
      // Fill me in!
      //insert when the size of the list is 0
      if (this.size == 0) {
          head = new InListNode(x, head);
          size++;
  
      }
      //insert at the beginning of the list
      else if (position == 0) {
          IntListNode new_node = new IntListNode(x, head);
          head = new_node;
          size++;
      }
      else {
          IntListNode point = head;
          while (position &gt; 1 &amp;&amp; point.next != null) {
              point = point.next;
              position--;
          }
          IntListNode newone = new IntListNode(x, point.next);
          point.next = newone;
          size++;
      }
  
  
  }
  
  /**
   * Merge two sorted IntLists a and b into one sorted IntList containing all of their elements.
   * @return a new IntList without modifying either parameter
   */
  public static IntList merge(IntList a, IntList b) {
      // Fill me in!
      return null;
  }
  
  /**
   * Reverse the current list recursively, using a helper method.
   */
  public void reverse() {
      // Fill me in!
  }
  
  /* Optional! */
  
  /**
   * Remove the node at position from this list.
   * @param position int representing the index of the node to remove. If greater than the size
   *                 of this list, throw an IndexOutOfBoundsException.
   */
  public void remove(int position) {
      if (position &gt;= size) throw new IndexOutOfBoundsException();
      // fill me in
  }
  }
  </code></pre>