/*
    * Copyright (C) 2007 The Guava Authors
    *
    * 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.common.collect;
  
  import com.google.common.annotations.GwtCompatible;
  import com.google.common.collect.testing.SampleElements;
  import com.google.common.collect.testing.google.TestBiMapGenerator;
  
  import junit.framework.TestCase;
  
  import java.util.Collections;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Set;
  
  /**
   * Tests for {@code EnumHashBiMap}.
   *
   * @author Mike Bostock
   */
  @GwtCompatible(emulated = true)
  public class EnumHashBiMapTest extends TestCase {
    private enum Currency { DOLLAR, FRANC, PESO, POUND, YEN }
    private enum Country { CANADA, CHILE, JAPAN, SWITZERLAND, UK }
  
    public static final class EnumHashBiMapGenerator implements TestBiMapGenerator<Country, String> {
      @SuppressWarnings("unchecked")
      @Override
      public BiMap<Country, String> create(Object... entries) {
        BiMap<Country, String> result = EnumHashBiMap.create(Country.class);
        for (Object o : entries) {
          Entry<Country, String> entry = (Entry<Country, String>) o;
          result.put(entry.getKey(), entry.getValue());
        }
        return result;
      }
  
      @Override
      public SampleElements<Entry<Country, String>> samples() {
        return new SampleElements<Entry<Country, String>>(
            Maps.immutableEntry(Country.CANADA, "DOLLAR"),
            Maps.immutableEntry(Country.CHILE, "PESO"),
            Maps.immutableEntry(Country.UK, "POUND"),
            Maps.immutableEntry(Country.JAPAN, "YEN"),
            Maps.immutableEntry(Country.SWITZERLAND, "FRANC"));
      }
  
      @SuppressWarnings("unchecked")
      @Override
      public Entry<Country, String>[] createArray(int length) {
        return new Entry[length];
      }
  
      @Override
      public Iterable<Entry<Country, String>> order(List<Entry<Country, String>> insertionOrder) {
        return insertionOrder;
      }
  
      @Override
      public Country[] createKeyArray(int length) {
        return new Country[length];
      }
  
      @Override
      public String[] createValueArray(int length) {
        return new String[length];
      }
    }
  
    public void testCreate() {
      EnumHashBiMap<Currency, String> bimap =
          EnumHashBiMap.create(Currency.class);
      assertTrue(bimap.isEmpty());
      assertEquals("{}", bimap.toString());
      assertEquals(HashBiMap.create(), bimap);
      bimap.put(Currency.DOLLAR, "dollar");
      assertEquals("dollar", bimap.get(Currency.DOLLAR));
      assertEquals(Currency.DOLLAR, bimap.inverse().get("dollar"));
    }
  
    public void testCreateFromMap() {
      /* Test with non-empty Map. */
      Map<Currency, String> map = ImmutableMap.of(
          Currency.DOLLAR, "dollar",
         Currency.PESO, "peso",
         Currency.FRANC, "franc");
     EnumHashBiMap<Currency, String> bimap
         = EnumHashBiMap.create(map);
     assertEquals("dollar", bimap.get(Currency.DOLLAR));
     assertEquals(Currency.DOLLAR, bimap.inverse().get("dollar"));
 
     /* Map must have at least one entry if not an EnumHashBiMap. */
     try {
       EnumHashBiMap.create(
           Collections.<Currency, String>emptyMap());
       fail("IllegalArgumentException expected");
     } catch (IllegalArgumentException expected) {}
 
     /* Map can be empty if it's an EnumHashBiMap. */
     Map<Currency, String> emptyBimap = EnumHashBiMap.create(Currency.class);
     bimap = EnumHashBiMap.create(emptyBimap);
     assertTrue(bimap.isEmpty());
 
     /* Map can be empty if it's an EnumBiMap. */
     Map<Currency, Country> emptyBimap2 =
         EnumBiMap.create(Currency.class, Country.class);
     EnumHashBiMap<Currency, Country> bimap2
         = EnumHashBiMap.create(emptyBimap2);
     assertTrue(bimap2.isEmpty());
   }
 
   public void testEnumHashBiMapConstructor() {
     /* Test that it copies existing entries. */
     EnumHashBiMap<Currency, String> bimap1 =
         EnumHashBiMap.create(Currency.class);
     bimap1.put(Currency.DOLLAR, "dollar");
     EnumHashBiMap<Currency, String> bimap2 =
         EnumHashBiMap.create(bimap1);
     assertEquals("dollar", bimap2.get(Currency.DOLLAR));
     assertEquals(bimap1, bimap2);
     bimap2.inverse().put("franc", Currency.FRANC);
     assertEquals("franc", bimap2.get(Currency.FRANC));
     assertNull(bimap1.get(Currency.FRANC));
     assertFalse(bimap2.equals(bimap1));
 
     /* Test that it can be empty. */
     EnumHashBiMap<Currency, String> emptyBimap =
         EnumHashBiMap.create(Currency.class);
     EnumHashBiMap<Currency, String> bimap3 =
         EnumHashBiMap.create(emptyBimap);
     assertEquals(bimap3, emptyBimap);
   }
 
   public void testEnumBiMapConstructor() {
     /* Test that it copies existing entries. */
     EnumBiMap<Currency, Country> bimap1 =
         EnumBiMap.create(Currency.class, Country.class);
     bimap1.put(Currency.DOLLAR, Country.SWITZERLAND);
     EnumHashBiMap<Currency, Object> bimap2 = // use supertype
         EnumHashBiMap.<Currency, Object>create(bimap1);
     assertEquals(Country.SWITZERLAND, bimap2.get(Currency.DOLLAR));
     assertEquals(bimap1, bimap2);
     bimap2.inverse().put("franc", Currency.FRANC);
     assertEquals("franc", bimap2.get(Currency.FRANC));
     assertNull(bimap1.get(Currency.FRANC));
     assertFalse(bimap2.equals(bimap1));
 
     /* Test that it can be empty. */
     EnumBiMap<Currency, Country> emptyBimap =
         EnumBiMap.create(Currency.class, Country.class);
     EnumHashBiMap<Currency, Country> bimap3 = // use exact type
         EnumHashBiMap.create(emptyBimap);
     assertEquals(bimap3, emptyBimap);
   }
 
   public void testKeyType() {
     EnumHashBiMap<Currency, String> bimap =
         EnumHashBiMap.create(Currency.class);
     assertEquals(Currency.class, bimap.keyType());
   }
 
   public void testEntrySet() {
     // Bug 3168290
     Map<Currency, String> map = ImmutableMap.of(
         Currency.DOLLAR, "dollar",
         Currency.PESO, "peso",
         Currency.FRANC, "franc");
     EnumHashBiMap<Currency, String> bimap
         = EnumHashBiMap.create(map);
 
     Set<Object> uniqueEntries = Sets.newIdentityHashSet();
     uniqueEntries.addAll(bimap.entrySet());
     assertEquals(3, uniqueEntries.size());
   }
 }