/*
 * Copyright 2008 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.emultest.java.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Set;

/**
 * Test various collections.
 */
public class CollectionsTest extends EmulTestBase {

  private interface ListImplProvider {
    List<Integer> copyOf(Collection<Integer> data);
  }

  public static List<Integer> createRandomList() {
    ArrayList<Integer> l = new ArrayList<Integer>();
    l.add(new Integer(5));
    l.add(new Integer(2));
    l.add(new Integer(3));
    l.add(new Integer(1));
    l.add(new Integer(4));
    return l;
  }

  public static List<String> createSortedList() {
    ArrayList<String> l = new ArrayList<String>();
    l.add("a");
    l.add("b");
    l.add("c");
    return l;
  }

  private static Entry<String, String> dummyEntry() {
    return Collections.singletonMap("foo", "bar").entrySet().iterator().next();
  }

  public void testAsLifoQueue() {
    Object o1 = new Object();
    Object o2 = new Object();
    Object o3 = new Object();
    LinkedList<Object> deque = new LinkedList<Object>();
    Queue<Object> queueView = Collections.asLifoQueue(deque);

    assertTrue(queueView.isEmpty());
    assertEquals(0, queueView.size());

    queueView.add(o1);
    assertEquals(deque.getFirst(), o1);
    assertEquals(deque.element(), o1);
    queueView.add(o2);
    assertEquals(deque.getFirst(), o2);
    assertEquals(deque.element(), o2);
    queueView.offer(o3);
    assertEquals(deque.getFirst(), o3);
    assertEquals(deque.element(), o3);

    assertEquals(3, deque.size());
    assertEquals(deque.size(), queueView.size());

    assertEquals(deque.getFirst(), o3);
    assertEquals(queueView.element(), o3);
    assertEquals(queueView.peek(), o3);
    assertEquals(queueView.poll(), o3);

    assertEquals(deque.getFirst(), o2);
    assertEquals(queueView.element(), o2);
    assertEquals(queueView.peek(), o2);
    assertEquals(queueView.poll(), o2);

    assertEquals(deque.getFirst(), o1);
    assertEquals(queueView.element(), o1);
    assertEquals(queueView.peek(), o1);
    assertEquals(queueView.remove(), o1);

    assertTrue(deque.isEmpty());
    assertEquals(deque.size(), queueView.size());
    assertTrue(queueView.isEmpty());

    queueView.add(o1);
    queueView.add(o2);
    queueView.add(o3);

    Iterator<Object> dequeIterator = deque.iterator();
    Iterator<Object> queueIterator = queueView.iterator();
    while (dequeIterator.hasNext() && queueIterator.hasNext()) {
      assertEquals(dequeIterator.next(), queueIterator.next());
    }
    assertEquals(dequeIterator.hasNext(), queueIterator.hasNext());

    assertEquals(deque.toArray(), queueView.toArray());
    assertEquals(deque.toString(), queueView.toString());

    queueView.clear();
    assertTrue(deque.isEmpty());
    assertTrue(queueView.isEmpty());
  }

  /**
   * Test Collections.binarySearch(List, Object).
   *
   * Verify the following cases: empty List odd numbers of elements even numbers
   * of elements not found value larger than all elements not found value
   * smaller than all elements
   */
  public void testBinarySearchObject() {
    List<String> a1 = new ArrayList<String>();
    int ret = Collections.binarySearch(a1, "");
    assertEquals(-1, ret);
    List<String> a2 = new ArrayList<String>(Arrays.asList(new String[] {
        "a", "g", "y"}));
    ret = Collections.binarySearch(a2, "c");
    assertEquals(-2, ret);
    ret = Collections.binarySearch(a2, "y");
    assertEquals(2, ret);
    List<String> a3 = new ArrayList<String>(Arrays.asList(new String[] {
        "b", "c", "x", "y"}));
    ret = Collections.binarySearch(a3, "z");
    assertEquals(-5, ret);
    ret = Collections.binarySearch(a3, "a");
    assertEquals(-1, ret);
    ret = Collections.binarySearch(a3, "b");
    assertEquals(0, ret);
  }

  /**
   * Test Collections.binarySearch(List, Object, Comparator).
   *
   * Verify the following cases: empty List odd numbers of elements even numbers
   * of elements not found value larger than all elements not found value
   * smaller than all elements null Comparator uses natural ordering
   */
  public void testBinarySearchObjectComparator() {
    Comparator<String> inverseSort = new Comparator<String>() {
      @Override
      public int compare(String o1, String o2) {
        return o2.compareTo(o1);
      }
    };
    List<String> a1 = new ArrayList<String>();
    int ret = Collections.binarySearch(a1, "", inverseSort);
    assertEquals(-1, ret);
    List<String> a2 = new ArrayList<String>(Arrays.asList(new String[] {
        "y", "g", "a"}));
    ret = Collections.binarySearch(a2, "c", inverseSort);
    assertEquals(-3, ret);
    ret = Collections.binarySearch(a2, "a", inverseSort);
    assertEquals(2, ret);
    List<String> a3 = new ArrayList<String>(Arrays.asList(new String[] {
        "y", "x", "c", "b"}));
    ret = Collections.binarySearch(a3, "a", inverseSort);
    assertEquals(-5, ret);
    ret = Collections.binarySearch(a3, "z", inverseSort);
    assertEquals(-1, ret);
    ret = Collections.binarySearch(a3, "y", inverseSort);
    assertEquals(0, ret);

    List<String> a4 = new ArrayList<String>(Arrays.asList(new String[] {
        "a", "b", "c", "d", "e"}));
    ret = Collections.binarySearch(a4, "d", null); // should not NPE
    assertEquals(3, ret);
  }

  public void testEntrySetToArrayOversized() {
    Map<String, String> delegate = new HashMap<String, String>();
    delegate.put("key", "value");
    Map<String, String> unmodifiable = Collections.unmodifiableMap(delegate);

    @SuppressWarnings("unchecked")
    Entry<String, String>[] oversizedArray = new Entry[3];
    oversizedArray[0] = dummyEntry();
    oversizedArray[1] = dummyEntry();
    oversizedArray[2] = dummyEntry();

    Entry<String, String>[] result = unmodifiable.entrySet().toArray(
        oversizedArray);
    assertSame(result, oversizedArray);
    assertEquals("key", result[0].getKey());
    assertEquals("value", result[0].getValue());
    assertNull("The element after last should be null.", result[1]);
  }

  public void testFill() {
    List<String> a = createSortedList();
    Collections.fill(a, null);
    assertEquals(new Object[a.size()], a);

    List<Integer> b = createRandomList();
    Collections.fill(b, null);
    assertEquals(new Object[b.size()], b);
  }

  public void testListCopy() {
    List<Integer> src = new ArrayList<Integer>(Arrays.asList(1, 2, 3));
    List<Integer> dest = new ArrayList<Integer>(Arrays.asList(1, 2));

    try {
      Collections.copy(dest, src);
      fail();
    } catch (IndexOutOfBoundsException expected) {
    }

    dest = new ArrayList<Integer>(Arrays.asList(5, 6, 7, 8));
    Collections.copy(dest, src);
    assertEquals(new Integer[]{1, 2, 3, 8}, dest);

    dest = new ArrayList<Integer>(Arrays.asList(5, 6, 7));
    Collections.copy(dest, src);
    assertEquals(new Integer[]{1, 2, 3}, dest);
  }

  public void testNewSetFromMap() {
    Object o1 = new Object();
    Object o2 = new Object();
    Object o3 = new Object();

    try {
      HashMap<Object, Boolean> nonEmptyMap = new HashMap<Object, Boolean>();
      nonEmptyMap.put(o1, true);
      Collections.newSetFromMap(nonEmptyMap);
      fail();
    } catch (IllegalArgumentException e) {
    }

    Set<Object> set = Collections.newSetFromMap(new HashMap<Object, Boolean>());

    set.add(o1);
    assertTrue(set.contains(o1));
    assertEquals(1, set.size());

    set.add(o2);
    assertTrue(set.contains(o2));
    assertEquals(2, set.size());

    set.add(o3);
    assertTrue(set.contains(o3));
    assertEquals(3, set.size());

    set.remove(o2);
    assertFalse(set.contains(o2));
    assertEquals(2, set.size());

    set.clear();
    assertEquals(0, set.size());
  }

  public void testReverse() {
    List<String> a = createSortedList();
    Collections.reverse(a);
    Object[] x = {"c", "b", "a"};
    assertEquals(x, a);

    List<Integer> b = createRandomList();
    Collections.reverse(b);
    Collections.reverse(b);
    assertEquals(b, createRandomList());
  }

  /**
   * @tests java.util.Collections#rotate(java.util.List, int)
   */
  public void testRotate() {
    try {
      Collections.rotate(null, 0);
      fail("Collections.rotate(null, distance) should throw NullPointerException");
    } catch (NullPointerException expected) {
      // Expected
    }
    // Test optimized RandomAccess code path
    testRotateImpl(new ListImplProvider() {
      public List<Integer> copyOf(Collection<Integer> data) {
        return new ArrayList<>(data);
      }
    });
    // Test sequential List code path
    testRotateImpl(new ListImplProvider() {
      public List<Integer> copyOf(Collection<Integer> data) {
        return new LinkedList<>(data);
      }
    });
  }

  public void testSort() {
    List<String> a = createSortedList();
    Collections.reverse(a);
    Collections.sort(a);
    assertEquals(createSortedList(), a);
  }

  public void testSortWithComparator() {
    Comparator<String> x = new Comparator<String>() {
      @Override
      public int compare(String s1, String s2) {
        // sort into reverse order
        return s2.compareTo(s1);
      }
    };
    List<String> a = createSortedList();
    Collections.sort(a, x);
    Object[] expected = {"c", "b", "a"};
    assertEquals(expected, a);
  }

  public void testToArray() {
    List<Integer> testList = createRandomList();
    Integer[] testArray = new Integer[testList.size()];
    testList.toArray(testArray);
    for (int i = 0; i < testList.size(); ++i) {
      Integer val = testList.get(i);
      assertEquals(val, testArray[i]);
    }
  }

  private void testRotateImpl(ListImplProvider listImpl) {
    // rotating empty list should not throw exception
    List<Integer> list = listImpl.copyOf(Collections.<Integer> emptyList());
    Collections.rotate(list, 2);

    List<Integer> original = Arrays.asList(0, 1, 2, 3, 4);
    list = listImpl.copyOf(original);

    Collections.rotate(list, 0);
    assertEquals(original, list);

    Collections.rotate(list, 3);
    assertEquals(Arrays.asList(2, 3, 4, 0, 1), list);

    Collections.rotate(list, list.size());
    assertEquals(Arrays.asList(2, 3, 4, 0, 1), list);

    Collections.rotate(list, list.size() + 3);
    assertEquals(Arrays.asList(4, 0, 1, 2, 3), list);

    Collections.rotate(list, -(list.size() + 3));
    assertEquals(Arrays.asList(2, 3, 4, 0, 1), list);

    Collections.rotate(list, -list.size());
    assertEquals(Arrays.asList(2, 3, 4, 0, 1), list);

    Collections.rotate(list, -3);
    assertEquals(original, list);
  }

}