/*
 * Copyright 2007 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.dev.jjs.test;

import com.google.gwt.core.client.JavaScriptException;
import com.google.gwt.junit.client.GWTTestCase;

/**
 * Tests enum functionality.
 */
public class EnumsTest extends GWTTestCase {

  enum Basic {
    A, B, C
  }

  enum Complex {
    A("X"), B("Y"), C("Z");

    String value;

    Complex(String value) {
      this.value = value;
    }

    public String value() {
      return value;
    }
  }

  enum Subclassing {
    A {
      @Override
      public String value() {
        return "X";
      }
    },
    B {
      @Override
      public String value() {
        return "Y";
      }
    },
    C {
      @Override
      public String value() {
        return "Z";
      }
    };

    public abstract String value();
  }

  public String getModuleName() {
    return "com.google.gwt.dev.jjs.CompilerSuite";
  }

  public void testCompareTo() {
    assertTrue(Basic.A.compareTo(Basic.valueOf("A")) == 0);
    assertTrue(Basic.B.compareTo(Basic.A) > 0);
    assertTrue(Basic.A.compareTo(Basic.B) < 0);

    assertTrue(Complex.A.compareTo(Complex.valueOf("A")) == 0);
    assertTrue(Complex.B.compareTo(Complex.A) > 0);
    assertTrue(Complex.A.compareTo(Complex.B) < 0);

    assertTrue(Subclassing.A.compareTo(Subclassing.valueOf("A")) == 0);
    assertTrue(Subclassing.B.compareTo(Subclassing.A) > 0);
    assertTrue(Subclassing.A.compareTo(Subclassing.B) < 0);
  }

  public void testField() {
    assertEquals("X", Complex.A.value);
    assertEquals("Y", Complex.B.value);
    assertEquals("Z", Complex.C.value);
  }

  public void testGetDeclaringClass() {
    assertEquals(Basic.class, Basic.A.getDeclaringClass());
    assertEquals(Complex.class, Complex.A.getDeclaringClass());
    assertEquals(Subclassing.class, Subclassing.A.getDeclaringClass());
  }

  public void testMethod() {
    assertEquals("X", Complex.A.value());
    assertEquals("Y", Complex.B.value());
    assertEquals("Z", Complex.C.value());

    assertEquals("X", Subclassing.A.value());
    assertEquals("Y", Subclassing.B.value());
    assertEquals("Z", Subclassing.C.value());
  }

  public void testName() {
    assertEquals("A", Basic.A.name());
    assertEquals("B", Basic.B.name());
    assertEquals("C", Basic.C.name());

    assertEquals("A", Complex.A.name());
    assertEquals("B", Complex.B.name());
    assertEquals("C", Complex.C.name());

    assertEquals("A", Subclassing.A.name());
    assertEquals("B", Subclassing.B.name());
    assertEquals("C", Subclassing.C.name());
  }

  public void testOrdinals() {
    assertEquals(0, Basic.A.ordinal());
    assertEquals(1, Basic.B.ordinal());
    assertEquals(2, Basic.C.ordinal());

    assertEquals(0, Complex.A.ordinal());
    assertEquals(1, Complex.B.ordinal());
    assertEquals(2, Complex.C.ordinal());

    assertEquals(0, Subclassing.A.ordinal());
    assertEquals(1, Subclassing.B.ordinal());
    assertEquals(2, Subclassing.C.ordinal());
  }

  public void testSwitch() {
    switch (Basic.A) {
      case A:
        break;
      case B:
        fail("Switch failed");
        break;
      case C:
        fail("Switch failed");
        break;
      default:
        fail("Switch failed");
        break;
    }
    switch (Complex.B) {
      case A:
        fail("Switch failed");
        break;
      case B:
        break;
      case C:
        fail("Switch failed");
        break;
      default:
        fail("Switch failed");
        break;
    }
    switch (Subclassing.C) {
      case A:
        fail("Switch failed");
        break;
      case B:
        fail("Switch failed");
        break;
      default:
        break;
    }
  }

  public void testValueOf() {
    assertEquals(Basic.A, Basic.valueOf("A"));
    assertEquals(Basic.B, Basic.valueOf("B"));
    assertEquals(Basic.C, Basic.valueOf("C"));
    try {
      Basic.valueOf("D");
      fail("Basic.valueOf(\"D\") -- expected IllegalArgumentException");
    } catch (IllegalArgumentException e) {
    }

    assertEquals(Complex.A, Complex.valueOf("A"));
    assertEquals(Complex.B, Complex.valueOf("B"));
    assertEquals(Complex.C, Complex.valueOf("C"));
    try {
      Complex.valueOf("D");
      fail("Complex.valueOf(\"D\") -- expected IllegalArgumentException");
    } catch (IllegalArgumentException e) {
    }

    assertEquals(Subclassing.A, Subclassing.valueOf("A"));
    assertEquals(Subclassing.B, Subclassing.valueOf("B"));
    assertEquals(Subclassing.C, Subclassing.valueOf("C"));
    try {
      Subclassing.valueOf("D");
      fail("Subclassing.valueOf(\"D\") -- expected IllegalArgumentException");
    } catch (IllegalArgumentException e) {
    }
    
    enumValuesTest(Basic.class);
    enumValuesTest(Complex.class);
    enumValuesTest(Subclassing.class);
    
    try {
      Enum.valueOf(Basic.class, "foo");
      fail("Passed an invalid enum constant name to Enum.valueOf; expected "
          + "IllegalArgumentException");
    } catch (IllegalArgumentException e) {
    }
    
    try {
      Class fakeEnumClass = String.class;
      Enum.valueOf(fakeEnumClass, "foo");
      fail("Passed a non enum class to Enum.valueOf; expected " 
              + "IllegalArgumentException");
    } catch (IllegalArgumentException e) {       
    }
     
    try {
      Class<Basic> nullEnumClass = null;
      Enum.valueOf(nullEnumClass, "foo");
      fail("Passed a null enum class to Enum.valueOf; expected "
          + "NullPointerException");
    } catch (JavaScriptException e) {
    } catch (NullPointerException e) {
    }
      
    try {
      Enum.valueOf(Basic.class, null);
      fail("Passed a null enum constant to Enum.valueOf; expected "
          + "NullPointerException");
    } catch (NullPointerException e) {
    }
  }

  public void testValues() {
    Basic[] simples = Basic.values();
    assertEquals(3, simples.length);
    assertEquals(Basic.A, simples[0]);
    assertEquals(Basic.B, simples[1]);
    assertEquals(Basic.C, simples[2]);

    Complex[] complexes = Complex.values();
    assertEquals(3, complexes.length);
    assertEquals(Complex.A, complexes[0]);
    assertEquals(Complex.B, complexes[1]);
    assertEquals(Complex.C, complexes[2]);

    Subclassing[] subs = Subclassing.values();
    assertEquals(3, subs.length);
    assertEquals(Subclassing.A, subs[0]);
    assertEquals(Subclassing.B, subs[1]);
    assertEquals(Subclassing.C, subs[2]);
  }
  
  private <T extends Enum<T>> void enumValuesTest(Class<T> enumClass) {
    T[] constants = enumClass.getEnumConstants();
    for (T constant : constants) {
      assertEquals(constant, Enum.valueOf(enumClass, constant.name()));
    }
  }
}