import junit.framework.TestCase;

/**
 * A JUnit test case class.
 * Every method starting with the word "test" will be called when running
 * the test with JUnit.
 */
public class OpenListTests extends TestCase {
  
  /**
   * isEmpty test: false case
   */
  public void test_isEmpty_false() {
    OpenList L = new OpenList( "A", OpenList.emptyList );
    assertEquals("test_isEmpty_false", 
                 /* expected */ false,                       
                 /* actual */ L.isEmpty() );
  }
  
  /**
   * isEmpty test: true case
   */
  public void test_isEmpty_true() {
    OpenList L = new OpenList( "A", OpenList.emptyList );
    assertEquals("test_isEmpty_true", 
                 /* expected */ true,                       
                 /* actual */ L.rest().isEmpty() );
  }
  
  /**
   * length test: 42 (static version)
   */
  public void test_length_42() {
    OpenList L = OpenList.emptyList;
    for (int i=0 ; i<42 ; ++i) {
      L = L.cons(i);
    }
    assertEquals("test_length_42", 
                 /* expected */ 42,                       
                 /* actual */ OpenList.length(L) );
  }
  
  /**
   * first test: "A" (nonstatic)
   */
  public void test_first_A() {
    OpenList L = new OpenList( "A", OpenList.emptyList);
    assertEquals("test_first_A", 
                 /* expected */ "A",                       
                 /* actual */ L.first() );
  }
  
  /**
   * rest test: [A] (static)
   */
  public void test_rest_list_A() {
    OpenList R = new OpenList( "A", OpenList.emptyList );
    OpenList L = new OpenList( "B", R );
    assertEquals("test_rest_list_A", 
                 /* expected */ R,                       
                 /* actual */ OpenList.rest(L) );
  }
  
  /**
   * list test: [A, B] (static)
   */
  public void test_list_AB() {
    OpenList R = new OpenList( "B", OpenList.emptyList );
    OpenList solution = new OpenList( "A", R );
    assertEquals("test_list_AB", 
                 /* expected */ solution,                       
                 /* actual */ OpenList.list( "A", "B" ) );
  }
  
  /**
   * append test: [A, B] (nonstatic)
   */
  public void test_append_AB() {
    OpenList B = new OpenList( "B", OpenList.emptyList );
    OpenList A = new OpenList( "A", OpenList.emptyList );
    OpenList solution = new OpenList( "A", 
                   new OpenList( "B", OpenList.emptyList )  );
    assertEquals("test_append_AB", 
                 /* expected */ solution,                       
                 /* actual */ A.append(B) );
  }
  
  /**
   * reverse test: [A, B] (static)
   */
  public void test_reverse_AB() {
    OpenList B = new OpenList( "B", OpenList.emptyList );
    OpenList full = new OpenList( "A", B );
    OpenList solution = new OpenList( "B", 
                   new OpenList( "A", OpenList.emptyList )  );
    assertEquals("test_reverse_AB", 
                 /* expected */ solution,                       
                 /* actual */ OpenList.reverse( full ) );
  }
  
  /**
   * merge test: [A, B, C, D] (static)
   */
  public void test_merge_ABCD() {
    OpenList AC = new OpenList( "A", 
                         new OpenList( "C", OpenList.emptyList ));
    OpenList BD = new OpenList( "B", 
                         new OpenList( "D", OpenList.emptyList ));                                      
    OpenList solution = new OpenList( "A", 
                         new OpenList( "B",
                          new OpenList( "C", 
                           new OpenList( "D", OpenList.emptyList ))));
    assertEquals("test_merge_ABCD", 
                 /* expected */ solution,                       
                 /* actual */ OpenList.merge( AC, BD ) );
  }
  
}