/*
 * Copyright 2013 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.junit.client.GWTTestCase;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Tests Java 7 features.
 */
public class Java7Test extends GWTTestCase {

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

  // new style class literals
  int million = 1_000_000;

  int five = 0b101;

  public void testNewStyleLiterals() {
    assertEquals(1000000, million);
    assertEquals(5, five);
  }

  public void testSwitchOnString() {

    String s = "AA";
    int result = -1;
    switch (s) {
      case "BB":
        result = 0;
        break;
      case "CC":
      case "AA":
        result = 1;
        break;
    }
    assertEquals(1, result);
  }

  final List<String> log = new ArrayList<String>();

  enum ThrowsWhen {
    NEVER, ONCONSTRUCTOR, ONCLOSE;
  }

  class Resource implements AutoCloseable {

    final String name;
    final ThrowsWhen throwsWhen;

    public Resource(String name) throws E1 {
      this(name, ThrowsWhen.NEVER);
    }

    public Resource(String name, ThrowsWhen throwsWhen) throws E1 {
      this.name = name;
      this.throwsWhen = throwsWhen;
      log.add("Open " + name);
      if (throwsWhen == ThrowsWhen.ONCONSTRUCTOR) {
        throwException("ExceptionOnConstructor");
      }
    }

    public void doSomething() {
      log.add("doSomething " + name);
    }

    public void throwException(String text) throws E1 {
      throw new E1(text + " in " + name);
    }

    public void close() throws Exception {
      log.add("Close " + name);
      if (throwsWhen == ThrowsWhen.ONCLOSE) {
        throwException("ExceptionOnClose");
      }
    }
  }

  private void logException(Exception e) {
    log.add(e.getMessage());
    for (Throwable t : e.getSuppressed()) {
      log.add("Suppressed: " + t.getMessage());
    }
  }

  public void testTryWithResources_noExceptions() throws Exception {
    log.clear();
    try (
        Resource rA = new Resource("A");
        Resource rB = new Resource("B");
        Resource rC = new Resource("C")) {

      rA.doSomething();
      rB.doSomething();
      rC.doSomething();
    }

    assertContentsInOrder(log,
        "Open A",
        "Open B",
        "Open C",
        "doSomething A",
        "doSomething B",
        "doSomething C",
        "Close C",
        "Close B",
        "Close A"
    );
  }

  public void testTryWithResources_exceptions() throws Exception {
    log.clear();
    try (
        Resource rA = new Resource("A");
        Resource rB = new Resource("B", ThrowsWhen.ONCLOSE);
        Resource rC = new Resource("C")) {

      rA.doSomething();
      rB.doSomething();
      rC.doSomething();
    } catch (Exception e) {
      log.add(e.getMessage());
    } finally {
      log.add("finally");
    }

    assertContentsInOrder(log,
        "Open A",
        "Open B",
        "Open C",
        "doSomething A",
        "doSomething B",
        "doSomething C",
        "Close C",
        "Close B",
        "Close A",
        "ExceptionOnClose in B",
        "finally"
    );
  }

  public void testTryWithResources_suppressedExceptions() throws Exception {
    log.clear();
    try (
        Resource rA = new Resource("A", ThrowsWhen.ONCLOSE);
        Resource rB = new Resource("B");
        Resource rC = new Resource("C", ThrowsWhen.ONCLOSE)) {

      rA.doSomething();
      rB.doSomething();
      rC.doSomething();
    } catch (Exception e) {
      logException(e);
    }

    assertContentsInOrder(log,
        "Open A",
        "Open B",
        "Open C",
        "doSomething A",
        "doSomething B",
        "doSomething C",
        "Close C",
        "Close B",
        "Close A",
        "ExceptionOnClose in C",
        "Suppressed: ExceptionOnClose in A"
    );

    log.clear();
    try (
        Resource rA = new Resource("A");
        Resource rB = new Resource("B", ThrowsWhen.ONCLOSE);
        Resource rC = new Resource("C")) {

      rA.doSomething();
      rB.throwException("E1 here");
      rC.doSomething();
    } catch (Exception e) {
      logException(e);
    } finally {
      log.add("finally");
    }

    assertContentsInOrder(log,
        "Open A",
        "Open B",
        "Open C",
        "doSomething A",
        "Close C",
        "Close B",
        "Close A",
        "E1 here in B",
        "Suppressed: ExceptionOnClose in B",
        "finally"
    );
  }

  public void testTryWithResources_exceptionInAcquisition() {
    log.clear();
    try (
        Resource rA = new Resource("A", ThrowsWhen.ONCLOSE);
        Resource rB = new Resource("B", ThrowsWhen.ONCONSTRUCTOR);
        Resource rC = new Resource("C", ThrowsWhen.ONCLOSE)) {

      rA.doSomething();
      rB.doSomething();
      rC.doSomething();
    } catch (Exception e) {
      logException(e);
    }

    assertContentsInOrder(log,
        "Open A",
        "Open B",
        "Close A",
        "ExceptionOnConstructor in B",
        "Suppressed: ExceptionOnClose in A"
    );
  }

  public void testAddSuppressedExceptions() {
    Throwable throwable = new Throwable("primary");
    assertNotNull(throwable.getSuppressed());
    assertEquals(0, throwable.getSuppressed().length);
    Throwable suppressed1 = new Throwable("suppressed1");
    throwable.addSuppressed(suppressed1);
    assertEquals(1, throwable.getSuppressed().length);
    assertEquals(suppressed1, throwable.getSuppressed()[0]);
    Throwable suppressed2 = new Throwable("suppressed2");
    throwable.addSuppressed(suppressed2);
    assertEquals(2, throwable.getSuppressed().length);
    assertEquals(suppressed1, throwable.getSuppressed()[0]);
    assertEquals(suppressed2, throwable.getSuppressed()[1]);
  }

  static class E1 extends Exception {
    String name;
    public E1(String name) {
      this.name = name;
    }

    public int methodE1() {
      return 0;
    }

    @Override
    public String getMessage() {
      return name;
    }
  }

  static class E2 extends E1 {
    public E2(String name) {
      super(name);
    }

    public int methodE2() {
      return 1;
    }
  }

  static class E3 extends E1 {
    public E3(String name) {
      super(name);
    }

    public int methodE3() {
      return 2;
    }
  }

  public void testMultiExceptions() {

    int choose = 0;

    try {
      if (choose == 0) {
        throw new E1("e1");
      } else if (choose == 1) {
        throw new E2("e2");
      }

      fail("Exception was not trown");
    } catch (E2 | E3 x) {
      // The compiler will assign x a common supertype/superinterface of E2 and E3.
      // Here we make sure that this clause is not entered when the supertype is thrown.
      fail("Caught E1 instead of E2|E3");
    } catch (E1 x) {
    }
  }

  private Object unoptimizableId(Object o) {
    if (Math.random() > -10) {
      return o;
    }
    return null;
  }

  public void testPrimitiveCastsFromObject() {
    Object o = unoptimizableId((byte) 2);
    assertEquals((byte) 2, (byte) o);
    o = unoptimizableId((short) 3);
    assertEquals((short) 3, (short) o);
    o = unoptimizableId(1);
    assertEquals(1, (int) o);
    o = unoptimizableId(1L);
    assertEquals(1L, (long) o);
    o = unoptimizableId(0.1f);
    assertEquals(0.1f, (float) o);
    o = unoptimizableId(0.1);
    assertEquals(0.1, (double) o);
    o = unoptimizableId(true);
    assertEquals(true, (boolean) o);
    o = unoptimizableId('a');
    assertEquals('a', (char) o);
    // Test cast from supers.
    Number n = (Number) unoptimizableId(5);
    assertEquals(5, (int) n);
    Serializable s = (Serializable) unoptimizableId(6);
    assertEquals(6, (int) s);
    Comparable<Integer> c = (Comparable<Integer>) unoptimizableId(7);
    assertEquals(7, (int) c);

    // Failing casts.
    try {
      Object boxedChar = unoptimizableId('a');
      boolean b = (boolean) boxedChar;
      fail("Should have thrown a ClassCastException");
    } catch (ClassCastException e) {
      // Expected.
    }

    try {
      Object string = unoptimizableId("string");
      int num = (int) string;
      fail("Should have thrown a ClassCastException");
    } catch (ClassCastException e) {
      // Expected.
    }
  }

  private void assertContentsInOrder(Iterable<String> contents, String... elements) {
    assertEquals(Arrays.asList(elements).toString(), contents.toString());
  }
}