// Copyright 2012 Google Inc. All Rights Reserved.
//
// 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.enterprise.adaptor;

import static java.util.AbstractMap.SimpleEntry;
import static java.util.Map.Entry;

import static org.junit.Assert.*;

import org.junit.*;
import org.junit.rules.ExpectedException;

import java.util.Arrays;
import java.util.Iterator;
import java.util.HashSet;
import java.util.Set;

/** Test cases for {@link Metadata}. */
public class MetadataTest {
  @Rule
  public ExpectedException thrown = ExpectedException.none();

  @Test
  public void testInitiallyEmpty() {
    Metadata m = new Metadata();
    assertTrue(m.isEmpty());
    assertTrue(m.getKeys().isEmpty());
    assertFalse(m.iterator().hasNext());
  }

  @Test
  public void testDupConstructor() {
    Metadata m1 = new Metadata();
    m1.add("foo", "home");
    m1.add("bar", "far");
    Metadata m2 = new Metadata(m1);
    assertEquals(m1, m2);
    m1.set("shoes", makeSet("bing", "bongo"));
    m2 = new Metadata(m1);
    assertEquals(m1, m2);
    // New values.
    m1.set("shoes", makeSet("bongo", "bing"));
    assertEquals(m1, m2);
  }

  @Test
  public void testSingleSetAndGet() {
    Metadata m = new Metadata();
    assertEquals(null, m.getOneValue("foo"));
    m.set("foo", "bar");
    assertEquals("bar", m.getOneValue("foo"));
    m.set("foo", "foo");
    assertEquals("foo", m.getOneValue("foo"));
    m.set("foo", "bar");
    assertEquals("bar", m.getOneValue("foo"));
  }

  @Test
  public void testSingleSetNullValue() {
    Metadata m = new Metadata();
    thrown.expect(NullPointerException.class);
    m.set("foo", (String) null);
  }

  @Test
  public void testSingleSetNullKey() {
    Metadata m = new Metadata();
    thrown.expect(NullPointerException.class);
    m.set(null, "bar");
  }

  @Test
  public void testSingleSetEffectOnKeys() {
    Metadata m = new Metadata();
    assertEquals(0, m.getKeys().size());
    m.set("foo", "bar");
    assertEquals(1, m.getKeys().size());
    m.set("foo", "bar");
    assertEquals(1, m.getKeys().size());
    m.set("bar", "foo");
    assertEquals(2, m.getKeys().size());
  }

  private static Set<String> makeSet(String ... s) {
    return new HashSet<String>(Arrays.asList(s));
  }

  @Test
  public void testMultipleSetAndGet() {
    Metadata m = new Metadata();
    assertEquals(null, m.getOneValue("foo"));
    m.set("foo", makeSet("bar", "home"));
    assertTrue(makeSet("bar", "home").contains(m.getOneValue("foo")));
    assertEquals(makeSet("bar", "home"), m.getAllValues("foo"));
    assertEquals(makeSet("home", "bar"), m.getAllValues("foo"));
    m.set("foo", makeSet("foo"));
    assertEquals("foo", m.getOneValue("foo"));
    assertEquals(makeSet("foo"), m.getAllValues("foo"));
    m.set("foo", makeSet("barf", "floor"));
    assertTrue(makeSet("barf", "floor").contains(m.getOneValue("foo")));
    assertEquals(makeSet("barf", "floor"), m.getAllValues("foo"));
  }

  @Test
  public void testMultipleGetNoKey() {
    Metadata m = new Metadata();
    assertEquals(makeSet(), m.getAllValues("foo"));
  }

  @Test
  public void testMultipleSetEmptySetRemoves() {
    Metadata m = new Metadata();
    m.set("foo", makeSet("bar", "home"));
    assertFalse(m.isEmpty());
    m.set("foo", makeSet());
    assertTrue(m.isEmpty());
  }

  @Test
  public void testMultipleSetNullValue() {
    Metadata m = new Metadata();
    assertTrue(m.isEmpty());
    Set<String> nullSet = null;
    thrown.expect(NullPointerException.class);
    m.set("foo", nullSet);
  }

  @Test
  public void testMultipleSetEmptySet() {
    Metadata m = new Metadata();
    assertTrue(m.isEmpty());
    Set<String> emptySet = makeSet();
    m.set("foo", emptySet);
    assertTrue(m.isEmpty());
    m.set("bar", makeSet("bar"));
    assertEquals(1, m.getKeys().size());
    m.set("foo", emptySet);
    assertEquals(1, m.getKeys().size());
    m.set("bar", emptySet);
    assertTrue(m.isEmpty());
  }

  @Test
  public void testSetEntriesIterable() {
    HashSet<Entry<String, String>> e1 = new HashSet<Entry<String, String>>();
    HashSet<Entry<String, String>> e2 = new HashSet<Entry<String, String>>();
    e1.add(new SimpleEntry<String, String>("a", "b"));
    e1.add(new SimpleEntry<String, String>("b", "q"));
    e2.add(new SimpleEntry<String, String>("a", "b"));
    e2.add(new SimpleEntry<String, String>("b", "q"));
    Metadata m1 = new Metadata();
    m1.set(e1);
    Metadata m2 = new Metadata();
    m2.set(e2);
    assertEquals(m1, m2);
  }

  @Test
  public void testSetEntriesNull() {
    Metadata m = new Metadata();
    thrown.expect(NullPointerException.class);
    m.set(null);
  }

  @Test
  public void testSetMetadata() {
    Metadata m1 = new Metadata();
    Metadata m2 = new Metadata();
    m1.set("foo", makeSet("home", "floor"));
    m2.set(m1);
    assertEquals(m1, m2);
    m1.set("foo", makeSet("home", "floor"));
    assertEquals(m1, m2);
    Set<String> vals = new HashSet<String>();
    vals.add("pigeon");
    vals.add("eagle");
    m1.set("foo", vals);
    m2.set(m1);
    assertTrue(m1.equals(m2));
    // Should not change m2.
    m1.add("foo", "bird");
    assertFalse(m1.equals(m2));
  }

  @Test
  public void testReturningUnmodifiableSetsA() {
    Metadata m = new Metadata();
    m.set("foo", makeSet("bar", "home", "villa"));
    Set<String> all = m.getAllValues("foo");
    thrown.expect(UnsupportedOperationException.class);
    all.add("newnew");
  }

  @Test
  public void testReturningUnmodifiableSetsB() {
    Metadata m = new Metadata();
    m.set("foo", makeSet("bar", "home", "villa"));
    Set<String> all = m.getAllValues("foo");
    thrown.expect(UnsupportedOperationException.class);
    all.remove("bar");
  }

  @Test
  public void testEasyToWriteModificationLoopOverValues() {
    Metadata m = new Metadata();
    m.set("foo", makeSet("bar", "home", "villa"));
    // End setup.
    // Loop should be idiomatic to write.
    Set<String> dest = new HashSet<String>();
    for (String v : m.getAllValues("foo")) {
      dest.add(v.toUpperCase());
    }
    m.set("foo", dest);
    // Double check function.
    assertEquals(makeSet("BAR", "HOME", "VILLA"), m.getAllValues("foo"));
  }

  @Test
  public void testReturningRemovalKeys() {
    Metadata m = new Metadata();
    m.set("foo", makeSet("bar", "home"));
    m.set("sna", makeSet("fu"));
    Set<String> keys = m.getKeys();
    assertEquals(2, keys.size());
    keys.remove("sna");
    assertEquals(1, keys.size());
    assertEquals(1, m.getKeys().size());
    assertEquals(keys, m.getKeys());
  }

  @Test
  public void testIteratingOverImmutableEntries() {
    Metadata m = new Metadata();
    m.set("foo", makeSet("bar", "home"));
    thrown.expect(UnsupportedOperationException.class);
    m.iterator().next().setValue("HOME");
  }

  private static Entry<String, String> ne(String k, String v) {
    return new SimpleEntry<String, String>(k, v);
  }

  @Test
  public void testEntriesGivenSorted() {
    Metadata m = new Metadata();
    m.set("foo", makeSet("home", "bar"));
    m.set("early", makeSet("bird"));
    m.set("cleary", makeSet("obfuscated"));
    m.set("dearly", makeSet("beloved"));
    m.set("badly", makeSet("traversed", "implied"));
    Iterator<Entry<String, String>> it = m.iterator();
    assertEquals(ne("badly", "implied"), it.next());
    assertEquals(ne("badly", "traversed"), it.next());
    assertEquals(ne("cleary", "obfuscated"), it.next());
    assertEquals(ne("dearly", "beloved"), it.next());
    assertEquals(ne("early", "bird"), it.next());
    assertEquals(ne("foo", "bar"), it.next());
    assertEquals(ne("foo", "home"), it.next());
    assertFalse(it.hasNext());
  }

  @Test
  public void testEmptyIterator() {
    Metadata m = new Metadata();
    assertFalse(m.iterator().hasNext());
  }

  @Test
  public void testNormalAdd() {
    Metadata m = new Metadata();
    m.add("foo", "home");
    assertEquals("home", m.getOneValue("foo"));
    m.add("foo", "bar");
    assertTrue(makeSet("bar", "home").contains(m.getOneValue("foo")));
    assertEquals(makeSet("home", "bar"), m.getAllValues("foo"));
    assertEquals(1, m.getKeys().size());
    m.add("foo", "few");
    assertEquals(1, m.getKeys().size());
    m.add("bar", "mor");
    assertEquals(makeSet("mor"), m.getAllValues("bar"));
    m.add("bar", "far");
    assertEquals(2, m.getKeys().size());
    assertEquals(makeSet("far", "mor"), m.getAllValues("bar"));
    m.add("bar", "far");
    assertEquals(makeSet("far", "mor"), m.getAllValues("bar"));
    m.add("bar", "mor");
    assertEquals(makeSet("far", "mor"), m.getAllValues("bar"));
  }

  @Test
  public void testNullAddA() {
    Metadata m = new Metadata();
    thrown.expect(NullPointerException.class);
    m.add("foo", null);
  }

  @Test
  public void testNullAddB() {
    Metadata m = new Metadata();
    m.add("foo", "bar");
    thrown.expect(NullPointerException.class);
    m.add("foo", null);
  }

  @Test
  public void testNullKeysNotAllowedInAdd() {
    Metadata m = new Metadata();
    thrown.expect(NullPointerException.class);
    m.add(null, "can-no-add");
  }

  @Test
  public void testEquals() {
    Metadata m1 = new Metadata();
    m1.add("foo", "home");
    Metadata m2 = new Metadata();
    m2.add("foo", "home");
    assertEquals(m1, m2);

    m1.add("foo", "bar");
    m2.add("foo", "bar");
    assertEquals(m1, m2);

    m1.set("foo", "high");
    m2.set("foo", "low");
    assertFalse(m1.equals(m2));

    m2.set("foo", "high");
    assertEquals(m1, m2);

    m1.set("bar", makeSet("floor", "door"));
    m2.set("bar", makeSet("floor", "door"));
    assertEquals(m1, m2);

    m1.set("bar", makeSet("near", "far"));
    assertFalse(m1.equals(m2));
    m2.set("bar", makeSet("near", "far"));
    assertEquals(m1, m2);
  }

  @Test
  public void testUnmodifiableSetSingle() {
    Metadata m = new Metadata().unmodifiableView();
    thrown.expect(UnsupportedOperationException.class);
    m.set("foo", "bar");
  }

  @Test
  public void testUnmodifiableSetMultiple() {
    Metadata m = new Metadata().unmodifiableView();
    thrown.expect(UnsupportedOperationException.class);
    m.set("foo", makeSet("bar", "home"));
  }

  @Test
  public void testUnmodifiableAdd() {
    Metadata m = new Metadata().unmodifiableView();
    thrown.expect(UnsupportedOperationException.class);
    m.add("foo", "bar");
  }

  @Test
  public void testUnmodifiableSetIterable() {
    Metadata m = new Metadata().unmodifiableView();
    thrown.expect(UnsupportedOperationException.class);
    m.set(new Metadata());
  }
  @Test
  public void testUnmodifiableSetSingleB() {
    Metadata m = new Metadata().unmodifiableView();
    thrown.expect(UnsupportedOperationException.class);
    m.set("foo", (String) null);
  }

  @Test
  public void testUnmodifiableSetMultipleB() {
    Metadata m = new Metadata().unmodifiableView();
    thrown.expect(UnsupportedOperationException.class);
    m.set("foo", (Set<String>) null);
  }

  @Test
  public void testUnmodifiableAddB() {
    Metadata m = new Metadata().unmodifiableView();
    thrown.expect(UnsupportedOperationException.class);
    m.add("foo", null);
  }

  @Test
  public void testUnmodifiableSetIterableB() {
    Metadata m = new Metadata().unmodifiableView();
    thrown.expect(UnsupportedOperationException.class);
    m.set(null);
  }

  @Test
  public void testUnmodifiableDoesNotAllowKeyRemoval() {
    Metadata m = new Metadata();
    m.set("foo", makeSet("bar", "home"));
    m.set("sna", makeSet("fu"));
    m = m.unmodifiableView();
    Set<String> keys = m.getKeys();
    assertEquals(2, keys.size());
    thrown.expect(UnsupportedOperationException.class);
    keys.remove("sna");
  }
}