/**
 * Copyright 2010 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 org.waveprotocol.wave.model.adt;


import junit.framework.TestCase;

import org.waveprotocol.wave.model.util.CollectionUtils;

import java.util.Set;

/**
 * Tests for the {@link ObservableBasicMapImpl} class.
 *
 */

public abstract class ObservableBasicMapTestBase extends TestCase {
  /** A map listener that exposes the values it hears. */
  static class Listener implements ObservableBasicMap.Listener<String, Integer> {
    int callCount = 0;
    String lastKey = null;
    Integer lastNewValue = null;
    Integer lastOldValue = null;

    Listener() {
    }

    /** Checks just the number of calls to the listener. */
    void check(int callCount) {
      assertEquals(callCount, this.callCount);
    }

    /** Checks all stored values. */
    void check(int callCount, String lastKey, Integer lastOldValue, Integer lastNewValue) {
      check(callCount);
      assertEquals(lastKey, this.lastKey);
      assertEquals(lastOldValue, this.lastOldValue);
      assertEquals(lastNewValue, this.lastNewValue);
    }

    @Override
    public void onEntrySet(String key, Integer oldValue, Integer newValue) {
      callCount++;
      lastKey = key;
      lastOldValue = oldValue;
      lastNewValue = newValue;
    }
  }

  /**
   * Makes a HashSet from the given iterable. Checks that any item is only
   * present once.
   */
  private static Set<String> makeHashSet(Iterable<String> iterable) {
    Set<String> result = CollectionUtils.newHashSet();
    for (String s : iterable) {
      assertTrue(result.add(s));
    }
    return result;
  }

  /** The map under test. */
  protected ObservableBasicMap<String, Integer> map;

  /** Constructor. */
  public ObservableBasicMapTestBase() {
  }

  @Override
  protected void setUp() throws Exception {
    super.setUp();
    createMap();
  }


  /**
   * Creates the ObservableBasicMap instance on which to run the tests specified
   * in this class. This method is called by {@link #setUp()} and should set the
   * {@link #map} variable.
   */
  abstract protected void createMap();

  /** Tests listeners get events. */
  public void testEvents() {
    Listener listener1 = new Listener();
    Listener listener2 = new Listener();
    map.addListener(listener1);

    // New values
    map.put("A", 100);
    listener1.check(1, "A", null, 100);
    map.put("B", 200);
    listener1.check(2, "B", null, 200);
    map.put("A", 300);
    listener1.check(3, "A", 100, 300);

    // No change
    map.put("B", 200);
    listener1.check(3);

    // Add a second listener - both should get same event
    map.addListener(listener2);
    listener2.check(0);
    map.put("B", 400);
    listener1.check(4, "B", 200, 400);
    listener2.check(1, "B", 200, 400);

    // Remove one listener
    map.removeListener(listener1);
    map.put("A", 500);
    listener1.check(4); // no more events here
    listener2.check(2, "A", 300, 500); // but one here
  }

  /** Tests simple getting and putting of values. */
  public void testGetPut() {
    // New keys ought to have null values
    assertNull(map.get("A"));
    assertNull(map.get("B"));

    // Put values in, and get them out again
    assertTrue(map.put("A", 1));
    assertTrue(map.put("B", 2));
    assertEquals(Integer.valueOf(1), map.get("A"));
    assertEquals(Integer.valueOf(2), map.get("B"));

    // Rewrite a value
    assertTrue(map.put("A", 3));
    assertEquals(Integer.valueOf(3), map.get("A"));

    // Overwrite with same value
    assertFalse(map.put("A", 3));
    assertEquals(Integer.valueOf(3), map.get("A"));
  }

  /** Tests functionality of keySet method. */
  public void testKeySet() {
    // Should be empty to begin with
    assertEquals(CollectionUtils.immutableSet(), makeHashSet(map.keySet()));

    // Test with adding data
    map.put("A", 1);
    map.put("B", 2);
    assertEquals(CollectionUtils.immutableSet("A", "B"), makeHashSet(map.keySet()));
    map.put("C", 3);
    assertEquals(CollectionUtils.immutableSet("A", "B", "C"), makeHashSet(map.keySet()));

    // Remove something
    map.remove("B");
    assertEquals(CollectionUtils.immutableSet("A", "C"), makeHashSet(map.keySet()));
  }


  /** Tests basic functionality of remove method. */
  public void testRemove() {
    assertNull(map.get("A"));
    map.put("A", 1);
    assertEquals(Integer.valueOf(1), map.get("A"));

    map.remove("A");
    assertNull(map.get("A"));
  }
}