package org.infinispan.functional;

import static org.infinispan.functional.FunctionalListenerAssertions.assertNoEvents;
import static org.infinispan.functional.FunctionalListenerAssertions.assertOrderedEvents;
import static org.infinispan.functional.FunctionalListenerAssertions.assertUnorderedEvents;
import static org.infinispan.functional.FunctionalListenerAssertions.create;
import static org.infinispan.functional.FunctionalListenerAssertions.createAllRemoveAll;
import static org.infinispan.functional.FunctionalListenerAssertions.createModify;
import static org.infinispan.functional.FunctionalListenerAssertions.createModifyRemove;
import static org.infinispan.functional.FunctionalListenerAssertions.createRemove;
import static org.infinispan.functional.FunctionalListenerAssertions.write;
import static org.infinispan.functional.FunctionalListenerAssertions.writeRemove;

import java.util.Arrays;

import org.testng.annotations.Test;

@Test(groups = "functional", testName = "functional.FunctionalConcurrentMapEventsTest")
public class FunctionalConcurrentMapEventsTest extends FunctionalConcurrentMapTest {

   public void testLocalEmptyGetThenPut() {
      assertOrderedEvents(local2, super::testLocalEmptyGetThenPut, create("one"));
   }

   @Override
   public void testSimpleEmptyGetThenPut() {
      assertOrderedEvents(simple2, super::testSimpleEmptyGetThenPut, create("one"));
   }

   @Override
   public void testReplEmptyGetThenPutOnNonOwner() {
      assertOrderedEvents(repl2, super::testReplEmptyGetThenPutOnNonOwner, create("one"));
   }

   @Override
   public void testReplEmptyGetThenPutOnOwner() {
      assertOrderedEvents(repl2, super::testReplEmptyGetThenPutOnOwner, create("one"));
   }

   @Override
   public void testDistEmptyGetThenPutOnNonOwner() {
      assertNoEvents(dist2, super::testDistEmptyGetThenPutOnNonOwner);
   }

   @Override
   public void testDistEmptyGetThenPutOnOwner() {
      assertOrderedEvents(dist2, super::testDistEmptyGetThenPutOnOwner, create("one"));
   }

   @Override
   public void testLocalPutGet() {
      assertOrderedEvents(local2, super::testLocalPutGet, create("one"));
   }

   @Override
   public void testSimplePutGet() {
      assertOrderedEvents(simple2, super::testSimplePutGet, create("one"));
   }

   @Override
   public void testReplPutGetOnNonOwner() {
      assertOrderedEvents(repl2, super::testReplPutGetOnNonOwner, create("one"));
   }

   @Override
   public void testReplPutGetOnOwner() {
      assertOrderedEvents(repl2, super::testReplPutGetOnOwner, create("one"));
   }

   @Override
   public void testDistPutGetOnNonOwner() {
      assertNoEvents(dist2, super::testDistPutGetOnNonOwner);
   }

   @Override
   public void testDistPutGetOnOwner() {
      assertOrderedEvents(dist2, super::testDistPutGetOnOwner, create("one"));
   }

   @Override
   public void testLocalPutUpdate() {
      assertOrderedEvents(local2, super::testLocalPutUpdate, createModify("one", "uno"));
   }

   @Override
   public void testSimplePutUpdate() {
      assertOrderedEvents(simple2, super::testSimplePutUpdate, createModify("one", "uno"));
   }

   @Override
   public void testReplPutUpdateOnNonOwner() {
      assertOrderedEvents(repl2, super::testReplPutUpdateOnNonOwner, createModify("one", "uno"));
   }

   @Override
   public void testReplPutUpdateOnOwner() {
      assertOrderedEvents(repl2, super::testReplPutUpdateOnOwner, createModify("one", "uno"));
   }

   @Override
   public void testDistPutUpdateOnNonOwner() {
      assertNoEvents(dist2, super::testDistPutUpdateOnNonOwner);
   }

   @Override
   public void testDistPutUpdateOnOwner() {
      assertOrderedEvents(dist2, super::testDistPutUpdateOnOwner, createModify("one", "uno"));
   }

   @Override
   public void testLocalGetAndRemove() {
      assertOrderedEvents(local2, super::testLocalGetAndRemove, createRemove("one"));
   }

   @Override
   public void testSimpleGetAndRemove() {
      assertOrderedEvents(simple2, super::testSimpleGetAndRemove, createRemove("one"));
   }

   @Override
   public void testReplGetAndRemoveOnNonOwner() {
      assertOrderedEvents(repl2, super::testReplGetAndRemoveOnNonOwner, createRemove("one"));
   }

   @Override
   public void testReplGetAndRemoveOnOwner() {
      assertOrderedEvents(repl2, super::testReplGetAndRemoveOnOwner, createRemove("one"));
   }

   @Override
   public void testDistGetAndRemoveOnNonOwner() {
      assertNoEvents(dist2, super::testDistGetAndRemoveOnNonOwner);
   }

   @Override
   public void testDistGetAndRemoveOnOwner() {
      assertOrderedEvents(dist2, super::testDistGetAndRemoveOnOwner, createRemove("one"));
   }

   @Override
   public void testLocalContainsKey() {
      assertOrderedEvents(local2, super::testLocalContainsKey, create("one"));
   }

   @Override
   public void testSimpleContainsKey() {
      assertOrderedEvents(simple2, super::testSimpleContainsKey, create("one"));
   }

   @Override
   public void testReplContainsKeyOnNonOwner() {
      assertOrderedEvents(repl2, super::testReplContainsKeyOnNonOwner, create("one"));
   }

   @Override
   public void testReplContainsKeyOnOwner() {
      assertOrderedEvents(repl2, super::testReplContainsKeyOnOwner, create("one"));
   }

   @Override
   public void testDistContainsKeyOnNonOwner() {
      assertNoEvents(dist2, super::testDistContainsKeyOnNonOwner);
   }

   @Override
   public void testDistContainsKeyOnOwner() {
      assertOrderedEvents(dist2, super::testDistContainsKeyOnOwner, create("one"));
   }

   @Override
   public void testLocalContainsValue() {
      assertOrderedEvents(local2, super::testLocalContainsValue, create("one"));
   }

   @Override
   public void testSimpleContainsValue() {
      assertOrderedEvents(simple2, super::testSimpleContainsValue, create("one"));
   }

   @Override
   public void testReplContainsValueOnNonOwner() {
      assertOrderedEvents(repl2, super::testReplContainsValueOnNonOwner, create("one"));
   }

   @Override
   public void testReplContainsValueOnOwner() {
      assertOrderedEvents(repl2, super::testReplContainsValueOnOwner, create("one"));
   }

   @Override
   public void testDistContainsValueOnNonOwner() {
      assertNoEvents(dist2, super::testDistContainsValueOnNonOwner);
   }

   @Override
   public void testDistContainsValueOnOwner() {
      assertOrderedEvents(dist2, super::testDistContainsValueOnOwner, create("one"));
   }

   @Override
   public void testLocalSize() {
      assertOrderedEvents(local2, super::testLocalSize, createAllRemoveAll("one", "two"));
   }

   @Override
   public void testSimpleSize() {
      assertOrderedEvents(simple2, super::testSimpleSize, createAllRemoveAll("one", "two"));
   }

   @Override
   public void testReplSizeOnNonOwner() {
      assertOrderedEvents(repl2, super::testReplSizeOnNonOwner, createAllRemoveAll("one", "two"));
   }

   @Override
   public void testReplSizeOnOwner() {
      assertOrderedEvents(repl2, super::testReplSizeOnOwner, createAllRemoveAll("one", "two"));
   }

   @Override
   public void testDistSizeOnNonOwner() {
      assertNoEvents(dist2, super::testDistSizeOnNonOwner);
   }

   @Override
   public void testDistSizeOnOwner() {
      assertOrderedEvents(dist2, super::testDistSizeOnOwner, createAllRemoveAll("one", "two"));
   }

   @Override
   public void testLocalEmpty() {
      assertOrderedEvents(local2, super::testLocalEmpty, createRemove("one"));
   }

   @Override
   public void testSimpleEmpty() {
      assertOrderedEvents(simple2, super::testSimpleEmpty, createRemove("one"));
   }

   @Override
   public void testReplEmptyOnNonOwner() {
      assertOrderedEvents(repl2, super::testReplEmptyOnNonOwner, createRemove("one"));
   }

   @Override
   public void testReplEmptyOnOwner() {
      assertOrderedEvents(repl2, super::testReplEmptyOnOwner, createRemove("one"));
   }

   @Override
   public void testDistEmptyOnNonOwner() {
      assertNoEvents(dist2, super::testDistEmptyOnNonOwner);
   }

   @Override
   public void testDistEmptyOnOwner() {
      assertOrderedEvents(dist2, super::testDistEmptyOnOwner, createRemove("one"));
   }

   @Override
   public void testLocalPutAll() {
      assertUnorderedEvents(local2, super::testLocalPutAll, writeRemove("one", "two", "two"));
   }

   @Override
   public void testSimplePutAll() {
      assertUnorderedEvents(simple2, super::testSimplePutAll, writeRemove("one", "two", "two"));
   }

   @Override
   public void testReplPutAllOnNonOwner() {
      assertUnorderedEvents(repl2, super::testReplPutAllOnNonOwner, writeRemove("one", "two", "two"));
   }

   @Override
   public void testReplPutAllOnOwner() {
      assertUnorderedEvents(repl2, super::testReplPutAllOnOwner, writeRemove("one", "two", "two"));
   }

   @Override
   public void testDistPutAllOnNonOwner() {
      assertNoEvents(dist2, super::testDistPutAllOnNonOwner);
   }

   @Override
   public void testDistPutAllOnOwner() {
      assertUnorderedEvents(dist2, super::testDistPutAllOnOwner, writeRemove("one", "two", "two"));
   }

   @Override
   public void testLocalClear() {
      assertUnorderedEvents(local2, super::testLocalClear, write("one", "two", "two"));
   }

   @Override
   public void testSimpleClear() {
      assertUnorderedEvents(simple2, super::testSimpleClear, write("one", "two", "two"));
   }

   @Override
   public void testReplClearOnNonOwner() {
      assertUnorderedEvents(repl2, super::testReplClearOnNonOwner, write("one", "two", "two"));
   }

   @Override
   public void testReplClearOnOwner() {
      assertUnorderedEvents(repl2, super::testReplClearOnOwner, write("one", "two", "two"));
   }

   @Override
   public void testDistClearOnNonOwner() {
      assertNoEvents(dist2, super::testDistClearOnNonOwner);
   }

   @Override
   public void testDistClearOnOwner() {
      assertUnorderedEvents(dist2, super::testDistClearOnOwner, write("one", "two", "two"));
   }

   @Override
   public void testLocalKeyValueAndEntrySets() {
      assertUnorderedEvents(local2, super::testLocalKeyValueAndEntrySets,
         createModifyRemove(Arrays.asList("one", "two", "two"), Arrays.asList("uno", "dos", "dos")));
   }

   @Override
   public void testSimpleKeyValueAndEntrySets() {
      assertUnorderedEvents(simple2, super::testSimpleKeyValueAndEntrySets,
            createModifyRemove(Arrays.asList("one", "two", "two"), Arrays.asList("uno", "dos", "dos")));
   }

   @Override
   public void testReplKeyValueAndEntrySetsOnNonOwner() {
      assertUnorderedEvents(repl2, super::testReplKeyValueAndEntrySetsOnNonOwner,
         createModifyRemove(Arrays.asList("one", "two", "two"), Arrays.asList("uno", "dos", "dos")));
   }

   @Override
   public void testReplKeyValueAndEntrySetsOnOwner() {
      assertUnorderedEvents(repl2, super::testReplKeyValueAndEntrySetsOnOwner,
         createModifyRemove(Arrays.asList("one", "two", "two"), Arrays.asList("uno", "dos", "dos")));
   }

   @Override
   public void testDistKeyValueAndEntrySetsOnNonOwner() {
      assertNoEvents(dist2, super::testDistKeyValueAndEntrySetsOnNonOwner);
   }

   @Override
   public void testDistKeyValueAndEntrySetsOnOwner() {
      assertUnorderedEvents(dist2, super::testDistKeyValueAndEntrySetsOnOwner,
         createModifyRemove(Arrays.asList("one", "two", "two"), Arrays.asList("uno", "dos", "dos")));
   }

   @Override
   public void testLocalPutIfAbsent() {
      assertOrderedEvents(local2, super::testLocalPutIfAbsent, createRemove("one"));
   }

   @Override
   public void testSimplePutIfAbsent() {
      assertOrderedEvents(simple2, super::testSimplePutIfAbsent, createRemove("one"));
   }

   @Override
   public void testReplPutIfAbsentOnNonOwner() {
      assertOrderedEvents(repl2, super::testReplPutIfAbsentOnNonOwner, createRemove("one"));
   }

   @Override
   public void testReplPutIfAbsentOnOwner() {
      assertOrderedEvents(repl2, super::testReplPutIfAbsentOnOwner, createRemove("one"));
   }

   @Override
   public void testDistPutIfAbsentOnNonOwner() {
      assertNoEvents(dist2, super::testDistPutIfAbsentOnNonOwner);
   }

   @Override
   public void testDistPutIfAbsentOnOwner() {
      assertOrderedEvents(dist2, super::testDistPutIfAbsentOnOwner, createRemove("one"));
   }

   @Override
   public void testLocalConditionalRemove() {
      assertOrderedEvents(local2, super::testLocalConditionalRemove, createRemove("one"));
   }

   @Override
   public void testSimpleConditionalRemove() {
      assertOrderedEvents(simple2, super::testSimpleConditionalRemove, createRemove("one"));
   }

   @Override
   public void testReplConditionalRemoveOnNonOwner() {
      assertOrderedEvents(repl2, super::testReplConditionalRemoveOnNonOwner, createRemove("one"));
   }

   @Override
   public void testReplConditionalRemoveOnOwner() {
      assertOrderedEvents(repl2, super::testReplConditionalRemoveOnOwner, createRemove("one"));
   }

   @Override
   public void testDistConditionalRemoveOnNonOwner() {
      assertNoEvents(dist2, super::testDistConditionalRemoveOnNonOwner);
   }

   @Override
   public void testDistConditionalRemoveOnOwner() {
      assertOrderedEvents(dist2, super::testDistConditionalRemoveOnOwner, createRemove("one"));
   }

   @Override
   public void testLocalReplace() {
      assertOrderedEvents(local2, super::testLocalReplace, createModifyRemove("one", "uno"));
   }

   @Override
   public void testSimpleReplace() {
      assertOrderedEvents(simple2, super::testSimpleReplace, createModifyRemove("one", "uno"));
   }

   @Override
   public void testReplReplaceOnNonOwner() {
      assertOrderedEvents(repl2, super::testReplReplaceOnNonOwner, createModifyRemove("one", "uno"));
   }

   @Override
   public void testReplReplaceOnOwner() {
      assertOrderedEvents(repl2, super::testReplReplaceOnOwner, createModifyRemove("one", "uno"));
   }

   @Override
   public void testDistReplaceOnNonOwner() {
      assertNoEvents(dist2, super::testDistReplaceOnNonOwner);
   }

   @Override
   public void testDistReplaceOnOwner() {
      assertOrderedEvents(dist2, super::testDistReplaceOnOwner, createModifyRemove("one", "uno"));
   }

   @Override
   public void testLocalReplaceWithValue() {
      assertOrderedEvents(local2, super::testLocalReplaceWithValue, createModifyRemove("one", "uno"));
   }

   @Override
   public void testSimpleReplaceWithValue() {
      assertOrderedEvents(simple2, super::testSimpleReplaceWithValue, createModifyRemove("one", "uno"));
   }

   @Override
   public void testReplReplaceWithValueOnNonOwner() {
      assertOrderedEvents(repl2, super::testReplReplaceWithValueOnNonOwner, createModifyRemove("one", "uno"));
   }

   @Override
   public void testReplReplaceWithValueOnOwner() {
      assertOrderedEvents(repl2, super::testReplReplaceWithValueOnOwner, createModifyRemove("one", "uno"));
   }

   @Override
   public void testDistReplaceWithValueOnNonOwner() {
      assertNoEvents(dist2, super::testDistReplaceWithValueOnNonOwner);
   }

   @Override
   public void testDistReplaceWithValueOnOwner() {
      assertOrderedEvents(dist2, super::testDistReplaceWithValueOnOwner, createModifyRemove("one", "uno"));
   }

}
