/*
 * 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.
 */

/*
 * Portions copyright 2006 Mat Gessel <mat.gessel@gmail.com>; licensed under
 * Apache 2.0
 */
package com.google.gwt.junit.client;

import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.JavaScriptException;
import com.google.gwt.core.shared.SerializableThrowable;
import com.google.gwt.junit.DoNotRunWith;
import com.google.gwt.junit.Platform;

import junit.framework.AssertionFailedError;

import java.util.Collections;

/**
 * This class tests our implementation of the GWTTestCase class which provides the behavior of
 * TestCase that is necessary in GWT.
 */
public class GWTTestCaseTest extends GWTTestCaseTestBase {

  private static void assertNotEquals(double a, double b, double delta) {
    boolean failed = false;
    try {
      assertEquals(a, b, delta);
    } catch (AssertionFailedError e) {
      // EXPECTED
      failed = true;
    }

    if (!failed) {
      fail("Expected failure for assertEquals(" + a + ", " + b + ", " + delta + ")");
    }
  }

  private static void assertNotEquals(float a, float b, float delta) {
    boolean failed = false;
    try {
      assertEquals(a, b, delta);
    } catch (AssertionFailedError e) {
      // EXPECTED
      failed = true;
    }

    if (!failed) {
      fail("Expected failure for assertEquals(" + a + ", " + b + ", " + delta + ")");
    }
  }

  private Object obj1 = Collections.nCopies(1, "data");
  private Object obj2 = Collections.nCopies(2, "data");
  private Object obj1Equal = Collections.nCopies(1, "data");

  @ExpectedFailure(withMessage = "testFail")
  public void testFail() {
    fail("testFail");
  }

  @ExpectedFailure(withType = Exception.class)
  public void testThrowsException() throws Exception {
    throw new Exception();
  }

  @ExpectedFailure(withType = JavaScriptException.class)
  public void testThrowsJavaScriptException() {
    throw new JavaScriptException("name", "desc");
  }

  @ExpectedFailure(withType = NullPointerException.class)
  public void testThrowsNullPointerException() {
    throw new NullPointerException();
  }

  static class SomeNonSerializableException extends RuntimeException {
    public SomeNonSerializableException(String msg) {
      super(msg);
    }
    // no default constructor
    // public SomeNonSerializableException() {}
  }

  // We lose some type information if class meta data is not available, setting expected failure
  // to RuntimeException will ensure this test case passes for no metadata. Also see the next test.
  @ExpectedFailure(withType = RuntimeException.class,
      withMessage = "testThrowsNonSerializableException")
  public void testThrowsNonSerializableException() {
    throw new SomeNonSerializableException("testThrowsNonSerializableException");
  }

  @ExpectedFailure(withType = SomeNonSerializableException.class)
  public void testThrowsNonSerializableException_hasMetaData() throws Throwable {
    if (!Object.class.getName().equals("java.lang.Object")) {
      // If there is no metadata lets make the test case happy
      SerializableThrowable throwable = SerializableThrowable.fromThrowable(new Exception());
      throwable.setDesignatedType(
          "com.google.gwt.junit.client.GWTTestCaseTest$SomeNonSerializableException", true);
      throw throwable;
    }
    testThrowsNonSerializableException();
  }


  public void testAssertEqualsDouble() {
    assertEquals(0.0, 0.0, 0.0);
    assertEquals(1.1, 1.1, 0.0);
    assertEquals(-1.1, -1.1, 0.0);
    assertEquals(Float.MIN_VALUE, Float.MIN_VALUE, 0.0);
    assertEquals(Float.MAX_VALUE, Float.MAX_VALUE, 0.0);
    assertNotEquals(0.0, 0.00000000000000000000000000000000000000001, 0.0);
    assertNotEquals(0.0, 0.0000000000000000001, 0.0);
    assertNotEquals(0.0, 0.000000001, 0.0);
    assertNotEquals(0.0, 0.0001, 0.0);
    assertNotEquals(0.0, 0.1, 0.0);
    assertNotEquals(1.0, 2.0, 0.1);
    assertNotEquals(2.0, 1.0, 0.1);
    assertNotEquals(-1.0, -2.0, 0.1);
    assertNotEquals(-2.0, -1.0, 0.1);
  }

  public void testAssertEqualsFloat() {
    assertEquals(0.0f, 0.0f, 0.0f);
    assertEquals(1.1f, 1.1f, 0.0f);
    assertEquals(-1.1f, -1.1f, 0.0f);
    assertEquals(Float.MIN_VALUE, Float.MIN_VALUE, 0.0f);
    assertEquals(Float.MAX_VALUE, Float.MAX_VALUE, 0.0f);
    assertNotEquals(0.0f, 0.00000000000000000000000000000000000000001f, 0.0f);
    assertNotEquals(0.0f, 0.0000000000000000001f, 0.0f);
    assertNotEquals(0.0f, 0.000000001f, 0.0f);
    assertNotEquals(0.0f, 0.0001f, 0.0f);
    assertNotEquals(0.0f, 0.1f, 0.0f);
    assertNotEquals(1.0f, 2.0f, 0.1f);
    assertNotEquals(2.0f, 1.0f, 0.1f);
    assertNotEquals(-1.0f, -2.0f, 0.1f);
    assertNotEquals(-2.0f, -1.0f, 0.1f);
  }

  public void testAssertEqualsIntInt() {
    assertEquals(5, 5);
    assertEquals("msg", 5, 5);
  }

  @ExpectedFailure
  public void testAssertEqualsIntIntFail() {
    assertEquals(5, 4);
  }

  @ExpectedFailure(withMessage = "msg")
  public void testAssertEqualsIntIntFailWithMessage() {
    assertEquals("msg", 5, 4);
  }

  public void testAssertEqualsObjectObject() {
    assertEquals(obj1, obj1Equal);
    assertEquals("msg", obj1, obj1);
  }

  @ExpectedFailure
  public void testAssertEqualsObjectObjectFail() {
    assertEquals(obj1, obj2);
  }

  @ExpectedFailure(withMessage = "msg")
  public void testAssertEqualsObjectObjectFailWithMessage() {
    assertEquals("msg", obj1, obj2);
  }

  public void testAssertFalse() {
    assertFalse(false);
    assertFalse("msg", false);
  }

  @ExpectedFailure
  public void testAssertFalseFail() {
    assertFalse(true);
  }

  @ExpectedFailure(withMessage = "msg")
  public void testAssertFalseFailWithMessage() {
    assertFalse("msg", true);
  }

  public void testAssertNotNull() {
    assertNotNull("Hello");
    assertNotNull("msg", "Hello");
  }

  @ExpectedFailure
  public void testAssertNotNullFail() {
    assertNotNull(null);
  }

  @ExpectedFailure(withMessage = "msg")
  public void testAssertNotNullStringFailWithMessage() {
    assertNotNull("msg", null);
  }

  public void testAssertNotSame() {
    assertNotSame(obj1, obj2);
    assertNotSame("msg", obj1, obj2);
    assertNotSame(obj1, obj1Equal);
    assertNotSame("msg", obj1, obj1Equal);
  }

  @ExpectedFailure
  public void testAssertNotSameFail() {
    assertNotSame(obj1, obj1);
  }

  @ExpectedFailure(withMessage = "msg")
  public void testAssertNotSameFailWithMessage() {
    assertNotSame("msg", obj1, obj1);
  }

  public void testAssertNull() {
    assertNull(null);
    assertNull("msg", null);
  }

  @ExpectedFailure
  public void testAssertNullFail() {
    assertNull("Hello");
  }

  @ExpectedFailure(withMessage = "msg")
  public void testAssertNullFailWithMessage() {
    assertNull("msg", "Hello");
  }

  public void testAssertSame() {
    assertSame(obj1, obj1);
    assertSame("msg", obj1, obj1);
  }

  @ExpectedFailure
  public void testAssertSameFail() {
    assertSame(obj1, obj1Equal);
  }

  @ExpectedFailure(withMessage = "msg")
  public void testAssertSameFailWithMessage() {
    assertSame("msg", obj1, obj1Equal);
  }

  public void testAssertTrue() {
    assertTrue(true);
    assertTrue("msg", true);
  }

  @ExpectedFailure
  public void testAssertTrueFail() {
    assertTrue(false);
  }

  @ExpectedFailure(withMessage = "msg")
  public void testAssertTrueFailWithMessage() {
    assertTrue("msg", false);
  }

  /**
   * Test skipping a test for dev mode.
   */
  @DoNotRunWith(Platform.Devel)
  public void testPlatformDevel() {
    assertTrue("Should not run in devel mode", GWT.isScript());
  }

  /**
   * Test skipping a test for prod mode.
   */
  @DoNotRunWith(Platform.Prod)
  public void testPlatformProd() {
    assertTrue("Should not run in prod mode", !GWT.isScript());
  }
}