/*
 * Copyright (c) 2008-2013, Hazelcast, 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.hazelcast.impl;

import com.hazelcast.cluster.AddOrRemoveConnection;
import com.hazelcast.config.*;
import com.hazelcast.core.*;
import com.hazelcast.examples.TestApp;
import com.hazelcast.monitor.DistributedMapStatsCallable;
import com.hazelcast.nio.Address;
import com.hazelcast.partition.MigrationEvent;
import com.hazelcast.partition.MigrationListener;
import com.hazelcast.partition.Partition;
import com.hazelcast.util.Clock;
import com.hazelcast.util.ConcurrentHashSet;
import org.junit.*;
import org.junit.runner.RunWith;

import java.io.Serializable;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

import static com.hazelcast.impl.TestUtil.*;
import static java.lang.Thread.sleep;
import static org.junit.Assert.*;

/**
 * Run these tests with
 * -Xms512m -Xmx512m
 */
@RunWith(com.hazelcast.util.RandomBlockJUnit4ClassRunner.class)
public class ClusterTest {

    @BeforeClass
    public static void init() throws Exception {
        System.setProperty(GroupProperties.PROP_WAIT_SECONDS_BEFORE_JOIN, "1");
        System.setProperty(GroupProperties.PROP_VERSION_CHECK_ENABLED, "false");
        Hazelcast.shutdownAll();
    }

    @After
    public void cleanup() throws Exception {
        Hazelcast.shutdownAll();
    }

    @Test
    public void testIdle() throws Exception {
        Config config = new Config();
        MapConfig mapConfig = config.getMapConfig("default");
        mapConfig.setMaxIdleSeconds(3);
        mapConfig.setEvictionDelaySeconds(10);
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(config);
        Map map = h1.getMap("default");
        map.put(1, 1);
        assertEquals(1, map.get(1));
        sleep(2000);
        assertEquals(1, map.get(1));
        sleep(2000);
        assertEquals(1, map.get(1));
        sleep(4000);
        assertNull(map.get(1));
        assertEquals(0, map.size());
    }

    @Test
    public void testPartitions() throws Exception {
        final HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        assertEquals(271, getLocalPartitions(h1).size());
        final HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        assertEquals(271, getLocalPartitions(h1).size() + getLocalPartitions(h2).size());
    }

    @Test
    public void testAtomicNumber() throws Exception {
        final HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        final HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        AtomicNumber a1 = h1.getAtomicNumber("default");
        AtomicNumber a2 = h2.getAtomicNumber("default");
        assertEquals(1, a1.incrementAndGet());
        assertEquals(1, a1.get());
        assertEquals(1, a2.get());
        assertEquals(5, a2.addAndGet(4));
        assertEquals(5, a1.getAndSet(13));
        assertEquals(13, a1.get());
        assertEquals(13, a2.get());
        h1.getLifecycleService().shutdown();
        assertEquals(13, a2.getAndSet(21));
        assertEquals(21, a2.get());
        final HazelcastInstance h3 = Hazelcast.newHazelcastInstance(new Config());
        AtomicNumber a3 = h3.getAtomicNumber("default");
        assertEquals(20, a3.decrementAndGet());
        assertEquals(20, a2.getAndAdd(-20));
        assertFalse(a2.compareAndSet(1, 6));
        assertFalse(a3.compareAndSet(1, 6));
        assertTrue(a2.compareAndSet(0, 6));
        assertTrue(a3.compareAndSet(6, 0));
        assertEquals(0, a3.get());
        assertEquals(0, a2.get());
        h2.getLifecycleService().shutdown();
        assertEquals(0, a3.get());
    }

    @Test
    public void testFirstNodeWait() throws Exception {
        final Config config = new Config();
        final BlockingQueue<Integer> counts = new ArrayBlockingQueue<Integer>(2);
        final HazelcastInstance[] instances = new HazelcastInstance[2];
        for (int i = 0; i < 2; i++) {
            instances[i] = Hazelcast.newHazelcastInstance(config);
        }
        for (int j = 0; j < 2; j++) {
            final int instanceIndex = j;
            new Thread(new Runnable() {
                public void run() {
                    final HazelcastInstance h = instances[instanceIndex];
                    for (int i = 0; i < 3000; i++) {
                        h.getMap("default").put(i, "value");
                    }
                    counts.offer(getLocalPartitions(h).size());
                }
            }).start();
        }
        int first = counts.take();
        int second = counts.take();
        assertTrue("Found " + first, first > 134);
        assertTrue("Found " + second, second > 134);
        assertEquals(271, second + first);
    }

    private Set<Partition> getLocalPartitions(HazelcastInstance h) {
        Set<Partition> partitions = h.getPartitionService().getPartitions();
        Set<Partition> localPartitions = new HashSet<Partition>();
        for (Partition partition : partitions) {
            if (h.getCluster().getLocalMember().equals(partition.getOwner())) {
                localPartitions.add(partition);
            }
        }
        return localPartitions;
    }

    @Test(timeout = 120000, expected = RuntimeException.class)
    public void testPutAfterShutdown() throws InterruptedException {
        final HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        Map map = h1.getMap("default");
        h1.shutdown();
        map.put("1", "value");
    }

    @Test(timeout = 120000)
    public void testSuperClientPartitionOwnership() throws Exception {
        Config configSuperClient = new Config();
        configSuperClient.setLiteMember(true);
        HazelcastInstance hNormal = Hazelcast.newHazelcastInstance(new Config());
        final HazelcastInstance hSuper = Hazelcast.newHazelcastInstance(configSuperClient);
        IMap mapSuper = hSuper.getMap("default");
        IMap mapNormal = hNormal.getMap("default");
        for (int i = 0; i < 1000; i++) {
            mapNormal.put("item" + i, "value" + i);
        }
        for (int i = 1000; i < 2000; i++) {
            mapSuper.put("item" + i, "value" + i);
        }
        Set<Partition> partitions2 = hSuper.getPartitionService().getPartitions();
        for (Partition partition : partitions2) {
            assertEquals(partition.getOwner(), hNormal.getCluster().getLocalMember());
        }
        assertEquals(2000, mapNormal.size());
        assertEquals(2000, mapSuper.size());
        assertEquals(0, mapSuper.getLocalMapStats().getOwnedEntryCount());
        assertEquals(0, mapSuper.getLocalMapStats().getBackupEntryCount());
        assertEquals(2000, mapNormal.getLocalMapStats().getOwnedEntryCount());
        assertEquals(0, mapNormal.getLocalMapStats().getBackupEntryCount());
        hNormal.shutdown();
        Thread.sleep(3000);
        Set<Partition> partitions = hSuper.getPartitionService().getPartitions();
        for (Partition partition : partitions) {
            assertNull(partition.getOwner());
        }
        hNormal = Hazelcast.newHazelcastInstance(new Config());
        partitions = hSuper.getPartitionService().getPartitions();
        for (Partition partition : partitions) {
            assertEquals(hNormal.getCluster().getLocalMember(), partition.getOwner());
        }
        assertNull(mapSuper.put("1", "value"));
        hSuper.shutdown();
        partitions = hNormal.getPartitionService().getPartitions();
        for (Partition partition : partitions) {
            assertEquals(hNormal.getCluster().getLocalMember(), partition.getOwner());
        }
        assertEquals("value", hNormal.getMap("default").get("1"));
    }

    @Test(timeout = 50000)
    public void testPutAfterRestart() {
        final HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        Map map = h1.getMap("default");
        h1.getLifecycleService().restart();
        map.put("1", "value");
    }

    @Test
    public void testSuperBeingMaster() throws Exception {
        Config config = new Config();
        config.setLiteMember(true);
        final HazelcastInstance hSuper = Hazelcast.newHazelcastInstance(config);
        final HazelcastInstance hSuper2 = Hazelcast.newHazelcastInstance(config);
        sleep(11000);
        HazelcastInstance hNormal = Hazelcast.newHazelcastInstance(new Config());
        Map map = hSuper.getMap("default");
        map.put("1", "value");
        assertEquals("value", hNormal.getMap("default").get("1"));
        sleep(10000);
        assertEquals("value", hNormal.getMap("default").get("1"));
        assertEquals("value", map.get("1"));
    }

    @Test(timeout = 120000)
    public void testSuperClientPutAfterBeforeNormalMember() throws Exception {
        final CountDownLatch latch = new CountDownLatch(1);
        final CountDownLatch latchSuperPut = new CountDownLatch(1);
        new Thread(new Runnable() {
            public void run() {
                Config config = new Config();
                config.setLiteMember(true);
                final HazelcastInstance hSuper = Hazelcast.newHazelcastInstance(config);
                latch.countDown();
                Map map = hSuper.getMap("default");
                map.put("1", "value");
                latchSuperPut.countDown();
            }
        }).start();
        assertTrue(latch.await(10, TimeUnit.SECONDS));
        HazelcastInstance hNormal = Hazelcast.newHazelcastInstance(new Config());
        assertTrue(latchSuperPut.await(10, TimeUnit.SECONDS));
        assertEquals("value", hNormal.getMap("default").get("1"));
    }

    @Test(timeout = 120000)
    public void testRestart() throws Exception {
        final HazelcastInstance h = Hazelcast.newHazelcastInstance(new Config());
        IMap map = h.getMap("default");
        map.put("1", "value");
        final CountDownLatch latch = new CountDownLatch(1);
        Thread interrupter = new Thread(new Runnable() {
            public void run() {
                try {
                    sleep(1000);
                    h.getLifecycleService().restart();
                    latch.countDown();
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            }
        });
        interrupter.start();
        map.put("1", "value2");
        assertTrue(latch.await(10, TimeUnit.SECONDS));
    }

    @Test(timeout = 120000)
    public void testRestart2() throws Exception {
        HazelcastInstance h = Hazelcast.newHazelcastInstance(new Config());
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        IMap map = h2.getMap("default");
        map.put("1", "value1");
        assertEquals(2, h.getCluster().getMembers().size());
        h2.getLifecycleService().restart();
        sleep(400);
        assertEquals("value1", map.get("1"));
        assertEquals("value1", map.put("1", "value2"));
        assertEquals("value2", map.get("1"));
        assertEquals("value2", h.getMap("default").get("1"));
    }

    @Test
    public void issue397MapReplaceLeadsToMemoryLeak() {
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        IMap map1 = h1.getMap("def");
        Object old = map1.replace(1, "v");
        assertNull(old);
        old = map1.replace(200, "v");
        assertNull(old);
        old = map1.replace(140, "v");
        assertNull(old);
        old = map1.replace(55, "v");
        assertNull(old);
        assertFalse(map1.containsKey(1));
        assertFalse(map1.containsKey(200));
        assertFalse(map1.containsKey(55));
        assertEquals(0, map1.getLocalMapStats().getBackupEntryCount());
        IMap map2 = h2.getMap("def");
        assertEquals(0, map2.getLocalMapStats().getBackupEntryCount());
    }

    @Test
    public void issue452SetMigration() throws InterruptedException {
        Config config = new Config();
        final CountDownLatch latch = new CountDownLatch(1);
        config.addListenerConfig(new ListenerConfig(new MigrationListener() {
            public void migrationStarted(MigrationEvent migrationEvent) {
            }

            public void migrationCompleted(MigrationEvent migrationEvent) {
                latch.countDown();
            }

            public void migrationFailed(final MigrationEvent migrationEvent) {
            }
        }));
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(config);
        ISet set1 = h1.getSet("mySet");
        for (int i = 0; i < 1000; i++) {
            set1.add(i);
        }
        assertEquals(1000, set1.size());
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        HazelcastInstance h3 = Hazelcast.newHazelcastInstance(new Config());
        ISet set2 = h2.getSet("mySet");
        ISet set3 = h3.getSet("mySet");
        assertTrue(latch.await(30, TimeUnit.SECONDS));
        assertEquals(1000, set1.size());
        assertEquals(1000, set2.size());
        assertEquals(1000, set3.size());
        h2.getLifecycleService().shutdown();
        assertEquals(1000, set1.size());
        assertEquals(1000, set3.size());
    }

    @Test(timeout = 60000)
    public void testMapReplaceIfSame() throws Exception {
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        IMap map1 = h1.getMap("default");
        IMap map2 = h2.getMap("default");
        map1.put("1", "value1");
        assertEquals(2, h1.getCluster().getMembers().size());
        assertEquals("value1", map1.get("1"));
        assertEquals("value1", map2.get("1"));
        assertTrue(map2.replace("1", "value1", "value2"));
        assertTrue(map1.replace("1", "value2", "value3"));
    }

    @Test
    public void testMapReplaceIfSame2() throws Exception {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance(new Config());
        final IMap<String, String> map = hz.getMap("default");
        final int loop = 50000;
        final String key = "key";
        final String value = "value";
        map.put(key, value);

        final int threads = 10;
        final CountDownLatch latch = new CountDownLatch(loop);
        ExecutorService ex = Executors.newFixedThreadPool(threads);
        try {
            for (int i = 0; i < loop; i++) {
                ex.execute(new Runnable() {
                    public void run() {
                        if (map.replace(key, value, value)) {
                            latch.countDown();
                        }
                    }
                });
            }
        } finally {
            ex.shutdown();
            ex.awaitTermination(5, TimeUnit.SECONDS);
        }
        assertTrue(latch.await(30, TimeUnit.SECONDS));
    }

    @Test
    public void testMapReplaceIfSame3() throws Exception {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance(new Config());
        final IMap<String, Counter> map = hz.getMap("default");
        final int loop = 10000;
        final String id = "key";
        map.put(id, new Counter(id, 0L));

        Thread[] threads = new Thread[2];
        for (int k = 0; k < threads.length; k++) {
            threads[k] = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < loop; i++) {
                        increment();
                    }
                }
                void increment() {
                    for (; ; ) {
                        Counter oldCounter = map.get(id);
                        if (oldCounter == null) throw new IllegalArgumentException();
                        Counter newCounter = new Counter(id, oldCounter.value);
                        newCounter.inc();
                        if (map.replace(id, oldCounter, newCounter)) {
                            return;
                        }
                    }
                }
            });
        }

        for (Thread thread : threads) thread.start();

        for (Thread thread : threads) thread.join();

        long actualCount = map.get(id).value;
        long expectedCount = loop * threads.length;
        assertEquals(expectedCount, actualCount);
    }

    @Test
    public void testMapRemoveIfSame() throws Exception {
        HazelcastInstance hz = Hazelcast.newHazelcastInstance(new Config());
        final IMap<String, Counter> map = hz.getMap("default");
        final int loop = 10000;
        final String key = "key";

        final int t = 3;
        final ExecutorService ex = Executors.newFixedThreadPool(t);
        try {
            final AtomicInteger k = new AtomicInteger();
            for (int i = 0; i < loop; i++) {
                final Counter c = new Counter(key, i);
                map.put(key, c) ;
                final CountDownLatch latch = new CountDownLatch(t);
                for (int j = 0; j < t; j++) {
                    ex.submit(new Runnable() {
                        public void run() {
                            if (map.remove(key, c)) {
                                k.incrementAndGet();
                            }
                            latch.countDown();
                        }
                    });
                }
                assertTrue(latch.await(3, TimeUnit.SECONDS));
                assertEquals("Remove if same should be successful only once! ["
                         + i + "]", 1, k.getAndSet(0));
            }
        } finally {
            ex.shutdownNow();
        }
    }

    static class Counter implements Serializable {

        private String id;
        private long value;

        public Counter() {
        }

        public Counter(String id, long value) {
            this.value = value;
            this.id = id;
        }

        public void inc() {
            value++;
        }

        public boolean equals(Object thatObject) {
            if (thatObject == this) return true;
            if (!(thatObject instanceof Counter)) return false;
            Counter that = (Counter) thatObject;
            if (!(that.id.equals(this.id))) return false;
            if (that.value != this.value) return false;
            return true;
        }

        public int hashCode() {
            int hash = id.hashCode();
            hash = 31 * hash + ((int) (value ^ (value >>> 32)));
            return hash;
        }
    }


    @Test
    public void testLockInstance() {
        ILock lock = Hazelcast.getLock("testLock");
        lock.lock();
        Collection<Instance> instances = Hazelcast.getInstances();
        boolean found = false;
        for (Instance instance : instances) {
            if (instance.getInstanceType().isLock()) {
                ILock lockInstance = (ILock) instance;
                if (lockInstance.getLockObject().equals("testLock")) {
                    found = true;
                }
            }
        }
        Assert.assertTrue(found);
        instances = Hazelcast.getInstances();
        found = false;
        for (Instance instance : instances) {
            if (instance.getInstanceType().isLock()) {
                ILock lockInstance = (ILock) instance;
                if (lockInstance.getLockObject().equals("testLock2")) {
                    found = true;
                }
            }
        }
        assertFalse(found);
        Hazelcast.getLock("testLock2");
        instances = Hazelcast.getInstances();
        found = false;
        for (Instance instance : instances) {
            if (instance.getInstanceType().isLock()) {
                ILock lockInstance = (ILock) instance;
                if (lockInstance.getLockObject().equals("testLock2")) {
                    found = true;
                }
            }
        }
        Assert.assertTrue(found);
    }

    @Test
    public void testPutIfAbsentWhenThereIsTTL() throws InterruptedException {
        String mapName = "testTTL";
        int ttl = 1;
        Config myConfig = configTTLForMap(mapName, ttl);
        HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(myConfig);
        IMap<String, String> myMap = hazelcast.getMap(mapName);
        String key = "1";
        String value = "value1";
        myMap.put(key, value);
        assertEquals(value, myMap.get(key));
        assertTrue(myMap.containsKey(key));
        sleep((ttl + 1) * 1000);
        assertFalse(myMap.containsKey(key));
        assertNull(myMap.get(key));
        assertNull(myMap.putIfAbsent(key, "value2"));
    }

    @Test
    public void testPutIfAbsentWhenThereIsTTLAndRemovedBeforeTTL() throws InterruptedException {
        String mapName = "testTTL";
        int ttl = 1;
        Config myConfig = configTTLForMap(mapName, ttl);
        HazelcastInstance hazelcast = Hazelcast.newHazelcastInstance(myConfig);
        IMap<String, String> myMap = hazelcast.getMap(mapName);
        String key = "1";
        String value = "value1";
        myMap.put(key, value);
        assertEquals(value, myMap.get(key));
        assertTrue(myMap.containsKey(key));
        assertEquals(value, myMap.remove(key));
        sleep((ttl + 1) * 1000);
        assertFalse(myMap.containsKey(key));
        assertNull(myMap.get(key));
        assertNull(myMap.putIfAbsent(key, "value2"));
    }

    private Config configTTLForMap(String mapName, int ttl) {
        Config myConfig = new Config();
        Map<String, MapConfig> myHazelcastMapConfigs = myConfig.getMapConfigs();
        MapConfig myMapConfig = myHazelcastMapConfigs.get(mapName);
        if (myMapConfig == null) {
            myMapConfig = new MapConfig();
            myMapConfig.setName(mapName);
            myMapConfig.setTimeToLiveSeconds(ttl);
            myConfig.addMapConfig(myMapConfig);
        } else {
            myMapConfig.setTimeToLiveSeconds(ttl);
        }
        return myConfig;
    }

    @Test(timeout = 120000)
    public void testDifferentGroups() {
        Config c1 = new Config();
        c1.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false);
        c1.getNetworkConfig().getJoin().getTcpIpConfig().setEnabled(true);
        c1.getNetworkConfig().getJoin().getTcpIpConfig().addMember("127.0.0.1");
        c1.getNetworkConfig().getInterfaces().clear();
        c1.getNetworkConfig().getInterfaces().addInterface("127.0.0.1");
        c1.getNetworkConfig().getInterfaces().setEnabled(true);
        Config c2 = new Config();
        c2.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false);
        c2.getNetworkConfig().getJoin().getTcpIpConfig().setEnabled(true);
        c2.getNetworkConfig().getJoin().getTcpIpConfig().addMember("127.0.0.1");
        c2.getNetworkConfig().getInterfaces().clear();
        c2.getNetworkConfig().getInterfaces().addInterface("127.0.0.1");
        c2.getNetworkConfig().getInterfaces().setEnabled(true);
        c1.getGroupConfig().setName("sameGroup");
        c2.getGroupConfig().setName("sameGroup");
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(c1);
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(c2);
        assertEquals(2, h1.getCluster().getMembers().size());
        assertEquals(2, h2.getCluster().getMembers().size());
        Hazelcast.shutdownAll();
        c2.getGroupConfig().setName("differentGroup");
        h1 = Hazelcast.newHazelcastInstance(c1);
        h2 = Hazelcast.newHazelcastInstance(c2);
        assertEquals(1, h1.getCluster().getMembers().size());
        assertEquals(1, h2.getCluster().getMembers().size());
    }

    @Test(timeout = 60000)
    public void shutdownSuperClient() {
        Config c1 = new Config();
        Config c2 = new Config();
        c2.setLiteMember(true);
        HazelcastInstance hNormal = Hazelcast.newHazelcastInstance(c1);
        HazelcastInstance hSuper = Hazelcast.newHazelcastInstance(c2);
        hNormal.getMap("default").put("1", "first");
        assert hSuper.getMap("default").
                get("1").equals("first");
        hNormal.shutdown();
        hSuper.shutdown();
    }

    @Test(timeout = 60000)
    public void testSuperClientRestart() throws Exception {
        Config configNormal = new Config();
        configNormal.setProperty(GroupProperties.PROP_CONNECTION_MONITOR_INTERVAL, "1");
        configNormal.setProperty(GroupProperties.PROP_CONNECTION_MONITOR_MAX_FAULTS, "1");
        Config configSuper = new Config();
        configSuper.setProperty(GroupProperties.PROP_CONNECTION_MONITOR_INTERVAL, "1");
        configSuper.setProperty(GroupProperties.PROP_CONNECTION_MONITOR_MAX_FAULTS, "1");
        configSuper.setLiteMember(true);
        HazelcastInstance h = Hazelcast.newHazelcastInstance(configNormal);
        HazelcastInstance s = Hazelcast.newHazelcastInstance(configSuper);
        assertEquals(2, h.getCluster().getMembers().size());
        assertEquals(2, s.getCluster().getMembers().size());
        assertFalse(h.getCluster().getLocalMember().isLiteMember());
        assertTrue(s.getCluster().getLocalMember().isLiteMember());
        IMap map = h.getMap("default");
        final IMap maps = s.getMap("default");
        assertNull(map.put("1", "value1"));
        assertEquals("value1", map.get("1"));
        assertEquals("value1", maps.get("1"));
        assertEquals(1, map.size());
        assertEquals(1, maps.size());
        h.getLifecycleService().shutdown();
        sleep(500);
        assertEquals(1, s.getCluster().getMembers().size());
        final CountDownLatch latch = new CountDownLatch(1);
        new Thread(new Runnable() {
            public void run() {
                maps.size();
                assertNull(maps.get("1"));
                maps.put("1", "value3");
                latch.countDown();
            }
        }).start();
        h = Hazelcast.newHazelcastInstance(configNormal);
        assertTrue(latch.await(20, TimeUnit.SECONDS));
        assertEquals(2, h.getCluster().getMembers().size());
        assertEquals(2, s.getCluster().getMembers().size());
        assertFalse(h.getCluster().getLocalMember().isLiteMember());
        assertTrue(s.getCluster().getLocalMember().isLiteMember());
        map = h.getMap("default");
        assertEquals("value3", map.put("1", "value2"));
        assertEquals("value2", map.get("1"));
        assertEquals(1, map.size());
        assertEquals(1, maps.size());
    }

    /**
     * 3 node cluster: normal member(h1), super client (hSuper) and another normal member (h2)
     * if h1 goes down, hSuper becomes the oldest member
     * If hSuper fails to update the partition ownerships,
     * h2.getMap("default").get(key) gets into infinite Re-Do.
     *
     * @throws Exception
     */
    @Test
    public void testSuperClientBeingOldestMember() throws Exception {
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        Config superConfig = new Config();
        superConfig.setLiteMember(true);
        HazelcastInstance hSuper = Hazelcast.newHazelcastInstance(superConfig);
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        final IMap map = h2.getMap("default");
        h1.getLifecycleService().shutdown();
        final CountDownLatch latch = new CountDownLatch(1);
        new Thread(new Runnable() {
            public void run() {
                assertTrue(map.get("1") == null);
                latch.countDown();
            }
        }).start();
        assertTrue(latch.await(10, TimeUnit.SECONDS));
    }

    @Test(timeout = 120000)
    public void testTcpIpWithMembers() throws Exception {
        Config c = new Config();
        c.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false);
        c.getNetworkConfig().getJoin().getTcpIpConfig().setEnabled(true);
        c.getNetworkConfig().getInterfaces().setEnabled(true);
        c.getNetworkConfig().getJoin().getTcpIpConfig().addMember("127.0.0.1");
        c.getNetworkConfig().getInterfaces().addInterface("127.0.0.1");
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(c);
        assertEquals(1, h1.getCluster().getMembers().size());
        h1.getMap("default").put("1", "value1");
        assertEquals("value1", h1.getMap("default").put("1", "value2"));
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(c);
        testTwoNodes(h1, h2);
        h1.getLifecycleService().shutdown();
        h1 = Hazelcast.newHazelcastInstance(c);
        testTwoNodes(h2, h1);
    }

    @Test(timeout = 120000)
    public void testTcpIp() throws Exception {
        Config c = new Config();
        c.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false);
        c.getNetworkConfig().getJoin().getTcpIpConfig().setEnabled(true);
        c.getNetworkConfig().getInterfaces().setEnabled(true);
        c.getNetworkConfig().getJoin().getTcpIpConfig()
                .addAddress(new Address("127.0.0.1", 5701))
                .addAddress(new Address("127.0.0.1", 5702));
        c.getNetworkConfig().getInterfaces().addInterface("127.0.0.1");
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(c);
        assertEquals(1, h1.getCluster().getMembers().size());
        h1.getMap("default").put("1", "value1");
        assertEquals("value1", h1.getMap("default").put("1", "value2"));
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(c);
        testTwoNodes(h1, h2);
        h1.getLifecycleService().shutdown();
        h1 = Hazelcast.newHazelcastInstance(c);
        testTwoNodes(h2, h1);
    }

    @Test(timeout = 120000)
    public void testTcpIpWithoutInterfaces() throws Exception {
        Config c = new Config();
        c.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false);
        c.getNetworkConfig().getJoin().getTcpIpConfig().setEnabled(true);
        c.getNetworkConfig().getInterfaces().setEnabled(true);
        c.getNetworkConfig().getJoin().getTcpIpConfig()
                .addAddress(new Address("127.0.0.1", 5701))
                .addAddress(new Address("127.0.0.1", 5702));
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(c);
        assertEquals(1, h1.getCluster().getMembers().size());
        h1.getMap("default").put("1", "value1");
        assertEquals("value1", h1.getMap("default").put("1", "value2"));
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(c);
        testTwoNodes(h1, h2);
        h1.getLifecycleService().shutdown();
        h1 = Hazelcast.newHazelcastInstance(c);
        testTwoNodes(h2, h1);
    }

    @Test(timeout = 120000)
    public void testMulticast() throws Exception {
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        assertEquals(1, h1.getCluster().getMembers().size());
        h1.getMap("default").put("1", "value1");
        assertEquals("value1", h1.getMap("default").put("1", "value2"));
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        testTwoNodes(h1, h2);
    }

    private void testTwoNodes(HazelcastInstance h1, HazelcastInstance h2) throws Exception {
        h1.getMultiMap("default").clear();
        IMap map1 = h1.getMap("default");
        IMap map2 = h2.getMap("default");
        assertEquals(2, h1.getCluster().getMembers().size());
        assertEquals(2, h2.getCluster().getMembers().size());
        assertEquals("value2", h2.getMap("default").get("1"));
        assertEquals("value2", h1.getMap("default").get("1"));
        assertEquals(1, h1.getMap("default").size());
        assertEquals(1, h2.getMap("default").size());
        assertFalse(map1.containsKey("2"));
        assertFalse(map2.containsKey("2"));
        assertFalse(map1.containsValue("value1"));
        assertFalse(map2.containsValue("value1"));
        assertTrue(map1.containsKey("1"));
        assertTrue(map2.containsKey("1"));
        assertTrue(map1.containsValue("value2"));
        assertTrue(map2.containsValue("value2"));
        map1.lock("1");
        assertFalse(map2.tryLock("1"));
        map1.unlock("1");
        assertTrue(map2.tryLock("1"));
        map2.unlock("1");
        assertEquals("value2", map1.putIfAbsent("1", "value1"));
        assertEquals("value2", map2.putIfAbsent("1", "value1"));
        assertEquals("value2", map1.get("1"));
        assertEquals("value2", map2.get("1"));
        assertNull(map1.putIfAbsent("3", "value3"));
        assertEquals("value3", map1.get("3"));
        assertEquals("value3", map2.get("3"));
        assertEquals("value3", map2.remove("3"));
        assertNull(map1.get("3"));
        assertNull(map2.get("3"));
        assertNull(map2.putIfAbsent("3", "value3"));
        assertEquals("value3", map1.get("3"));
        assertEquals("value3", map2.get("3"));
        assertEquals("value3", map1.remove("3"));
        assertNull(map1.get("3"));
        assertNull(map2.get("3"));
        assertEquals(1, map1.keySet().size());
        assertEquals(1, map1.values().size());
        assertEquals(1, map1.entrySet().size());
        assertEquals(1, map2.keySet().size());
        assertEquals(1, map2.values().size());
        assertEquals(1, map2.entrySet().size());
        Set<Map.Entry> entries = map1.entrySet();
        for (Map.Entry entry : entries) {
            assertEquals("1", entry.getKey());
            assertEquals("value2", entry.getValue());
        }
        entries = map2.entrySet();
        for (Map.Entry entry : entries) {
            assertEquals("1", entry.getKey());
            assertEquals("value2", entry.getValue());
        }
        allMapListenerTest(map2, "5", map1);
        MultiMap<String, String> mm1 = h1.getMultiMap("default");
        MultiMap<String, String> mm2 = h2.getMultiMap("default");
        mm1.put("Hello", "World");
        Collection<String> values = mm2.get("Hello");
        assertEquals("World", values.iterator().next());
        mm2.put("Hello", "Europe");
        mm1.put("Hello", "America");
        mm1.put("Hello", "Asia");
        mm1.put("Hello", "Africa");
        mm1.put("Hello", "Antartica");
        mm1.put("Hello", "Australia");
        values = mm2.get("Hello");
        assertEquals(7, values.size());
        junit.framework.Assert.assertFalse(mm2.remove("Hello", "Unknown"));
        assertEquals(7, mm1.get("Hello").size());
        assertTrue(mm1.remove("Hello", "Antartica"));
        assertEquals(6, mm1.get("Hello").size());
    }

    @Test(timeout = 120000)
    public void testListeners2() throws Exception {
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        final Member member1 = h1.getCluster().getLocalMember();
        final Member member2 = h2.getCluster().getLocalMember();
        final CountDownLatch latchAdded = new CountDownLatch(4);
        final CountDownLatch latchUpdated = new CountDownLatch(2);
        final CountDownLatch latchRemoved = new CountDownLatch(2);
        final CountDownLatch latchEvicted = new CountDownLatch(2);
        EntryListener listener = new EntryListener() {
            public synchronized void entryAdded(EntryEvent entryEvent) {
                if (latchAdded.getCount() > 2) {
                    assertEquals(member1, entryEvent.getMember());
                } else {
                    assertEquals(member2, entryEvent.getMember());
                }
                latchAdded.countDown();
            }

            public void entryRemoved(EntryEvent entryEvent) {
                assertEquals(member1, entryEvent.getMember());
                latchRemoved.countDown();
            }

            public void entryUpdated(EntryEvent entryEvent) {
                assertEquals(member2, entryEvent.getMember());
                latchUpdated.countDown();
            }

            public void entryEvicted(EntryEvent entryEvent) {
                assertEquals(member2, entryEvent.getMember());
                latchEvicted.countDown();
            }
        };
        IMap map2 = h2.getMap("default");
        IMap map1 = h1.getMap("default");
        Object key = "2133aa";
        map1.addEntryListener(listener, key, true);
        map2.addEntryListener(listener, key, true);
        assertNull(map1.put(key, "value5"));
        assertEquals("value5", map2.put(key, "value55"));
        assertTrue(map2.evict(key));
        assertNull(map2.put(key, "value5"));
        assertEquals("value5", map1.remove(key));
        int waitSeconds = 20;
        assertTrue(latchRemoved.await(waitSeconds, TimeUnit.SECONDS));
        map1.removeEntryListener(listener, key);
        assertFalse(map2.evict(key));
        map2.removeEntryListener(listener, key);
        assertTrue(latchAdded.await(waitSeconds, TimeUnit.SECONDS));
        assertTrue(latchUpdated.await(waitSeconds, TimeUnit.SECONDS));
        assertTrue(latchRemoved.await(waitSeconds, TimeUnit.SECONDS));
        assertTrue(latchEvicted.await(waitSeconds, TimeUnit.SECONDS));
    }

    @Test(timeout = 120000)
    public void testListeners() throws Exception {
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        assertEquals(1, h1.getCluster().getMembers().size());
        h1.getMap("default").put("1", "value1");
        assertEquals("value1", h1.getMap("default").put("1", "value2"));
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        allMapListenerTest(h2.getMap("default"), "5", h1.getMap("default"));
    }

    private void allMapListenerTest(IMap map, Object keyToUpdate, IMap mapSource) throws Exception {
        final CountDownLatch latchAdded = new CountDownLatch(2);
        final CountDownLatch latchUpdated = new CountDownLatch(1);
        final CountDownLatch latchRemoved = new CountDownLatch(1);
        final CountDownLatch latchEvicted = new CountDownLatch(1);
        EntryListener listener = new EntryListener() {
            public void entryAdded(EntryEvent entryEvent) {
                latchAdded.countDown();
            }

            public void entryRemoved(EntryEvent entryEvent) {
                latchRemoved.countDown();
            }

            public void entryUpdated(EntryEvent entryEvent) {
                latchUpdated.countDown();
            }

            public void entryEvicted(EntryEvent entryEvent) {
                latchEvicted.countDown();
            }
        };
        map.addEntryListener(listener, true);
        assertNull(mapSource.put(keyToUpdate, "value5"));
        assertEquals("value5", mapSource.put(keyToUpdate, "value55"));
        assertTrue(mapSource.evict(keyToUpdate));
        assertNull(mapSource.put(keyToUpdate, "value5"));
        assertEquals("value5", mapSource.remove(keyToUpdate));
        int waitSeconds = 20;
        assertTrue(latchAdded.await(waitSeconds, TimeUnit.SECONDS));
        assertTrue(latchUpdated.await(waitSeconds, TimeUnit.SECONDS));
        assertTrue(latchRemoved.await(waitSeconds, TimeUnit.SECONDS));
        assertTrue(latchEvicted.await(waitSeconds, TimeUnit.SECONDS));
        map.removeEntryListener(listener);
    }

    @Test(timeout = 120000)
    public void testTcpIpWithDifferentBuildNumber() throws Exception {
        System.setProperty("hazelcast.build", "1");
        Config c = new Config();
        c.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(false);
        c.getNetworkConfig().getJoin().getTcpIpConfig().setEnabled(true);
        c.getNetworkConfig().getInterfaces().setEnabled(true);
        c.getNetworkConfig().getJoin().getTcpIpConfig().addAddress(new Address("127.0.0.1", 5701));
        c.getNetworkConfig().getInterfaces().addInterface("127.0.0.1");
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(c);
        assertEquals(1, h1.getCluster().getMembers().size());
        h1.getMap("default").put("1", "value1");
        assertEquals("value1", h1.getMap("default").put("1", "value2"));
        System.setProperty("hazelcast.build", "2");
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(c);
        assertEquals(2, h1.getCluster().getMembers().size());
        assertEquals(2, h2.getCluster().getMembers().size());
        System.clearProperty("hazelcast.build");
    }

    @Test(timeout = 120000)
    public void testMulticastWithDifferentBuildNumber() throws Exception {
        System.setProperty("hazelcast.build", "1");
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        assertEquals(1, h1.getCluster().getMembers().size());
        h1.getMap("default").put("1", "value1");
        assertEquals("value1", h1.getMap("default").put("1", "value2"));
        System.setProperty("hazelcast.build", "2");
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        assertEquals(2, h1.getCluster().getMembers().size());
        assertEquals(2, h2.getCluster().getMembers().size());
        System.setProperty("hazelcast.build", "t");
    }

    @Test(timeout = 120000)
    public void testMapMaxSize() throws Exception {
        int maxSize = 40;
        Config c = new Config();
        MapConfig mapConfig = c.getMapConfig("default");
        mapConfig.setEvictionPolicy("LRU");
        mapConfig.setMaxSizeConfig(new MaxSizeConfig()
                                           .setMaxSizePolicy(MaxSizeConfig.POLICY_CLUSTER_WIDE_MAP_SIZE)
                                           .setSize(maxSize));
        mapConfig.setEvictionPercentage(25);
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(c);
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(c);
        IMap map1 = h1.getMap("default");
        for (int i = 0; i < 100; i++) {
            map1.put(String.valueOf(i), String.valueOf(i));
            int mapSize = map1.size();
            assertTrue("CurrentMapSize : " + mapSize, mapSize <= maxSize);
        }
        IMap map2 = h2.getMap("default");
        for (int i = 0; i < 100; i++) {
            map2.put(String.valueOf(i), String.valueOf(i));
            int mapSize = map2.size();
            assertTrue("CurrentMapSize : " + mapSize, mapSize <= maxSize);
        }
    }

    @Test(timeout = 120000)
    @Ignore
    public void testMapMaxHeap() throws Exception {
        int maxSize = 1; // MB
        Config c = new Config();
        c.setProperty(GroupProperties.PROP_CLEANUP_DELAY_SECONDS, "1");
        MapConfig mapConfig = c.getMapConfig("default");
        mapConfig.setMaxSizeConfig(new MaxSizeConfig()
                                           .setMaxSizePolicy(MaxSizeConfig.POLICY_USED_HEAP_SIZE)
                                           .setSize(maxSize));
        final byte[] data = new byte[700]; // cost = value + overhead(312) = 1012
        HazelcastInstance hz = Hazelcast.newHazelcastInstance(c);
        IMap map = hz.getMap("default");
        for (int i = 0; i < 1024; i++) {  // cost = key(+overhead)(12) + value(700) + overhead(312) = 1024
            map.put(i, data);
        }
        Thread.sleep(1500); // wait for cleanup
        assertFalse(map.tryPut(1024, data, 0, TimeUnit.SECONDS));
        map.remove(0);
        Thread.sleep(1500); // wait for cleanup
        assertTrue(map.tryPut(1024, data, 0, TimeUnit.SECONDS));
    }

    /**
     * Test for issue #204:
     * http://code.google.com/p/hazelcast/issues/detail?id=204
     * <p/>
     * Summary:
     * Eviction events are not fired
     */
    @Test
    public void testEvictionOfEntriesWithTTL() throws Exception {
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        IMap map1 = h1.getMap("default");
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        IMap map2 = h2.getMap("default");
        TestEntryListener cl1 = new TestEntryListener(100, 0, 0, 100);
        TestEntryListener cl2 = new TestEntryListener(100, 0, 0, 100);
        map1.addEntryListener(cl1, true);
        map2.addEntryListener(cl2, true);
        for (int i = 0; i < 50; i++) {
            map1.put(Integer.valueOf(i), i, 5, TimeUnit.SECONDS);
            map1.put(String.valueOf(i), i, 5, TimeUnit.SECONDS);
        }
        assertTrue(cl1.await(30));
        assertTrue(cl2.await(30));
    }

    @Test(timeout = 180000)
    public void testLosingEntries() throws Exception {
        final CountDownLatch latch = new CountDownLatch(2);
        final HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        final AtomicBoolean failed = new AtomicBoolean(false);
        new Thread(new Runnable() {
            public void run() {
                try {
                    callSize(h1, 110000);
                } catch (Exception e) {
                    failed.set(true);
                    fail(e.getMessage());
                } finally {
                    latch.countDown();
                }
            }
        }).start();
        sleep(4000);
        final HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        new Thread(new Runnable() {
            public void run() {
                try {
                    callSize(h2, 2000);
                } catch (Exception e) {
                    failed.set(true);
                    fail(e.getMessage());
                } finally {
                    latch.countDown();
                }
            }
        }).start();
        assertTrue(latch.await(20, TimeUnit.SECONDS));
        assertFalse(failed.get());
    }

    private void callSize(HazelcastInstance h, int numberOfIterations) throws Exception {
        Random r = new Random();
        Map<Integer, Integer> map = h.getMap("testMap");
        try {
            sleep(5000);
        } catch (InterruptedException ignored) {
        }
        int size = 0;
        for (int i = 0; i < numberOfIterations; i++) {
            if (i % 1000 == 0) {
                int sizeNow = map.size();
                if (sizeNow < size)
                    throw new RuntimeException("CurrentSize cannot be smaller. " + sizeNow + ", was " + size);
                size = sizeNow;
            }
            map.put(r.nextInt(200000), i);
        }
        h.getLifecycleService().shutdown();
    }

    @Test(timeout = 60000)
    public void testMapRecovery() throws Exception {
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        IMap map1 = h1.getMap("default");
        map1.put("1", "value");
        assertEquals(1, map1.size());
        assertEquals(1, map1.keySet().size());
        CMap cmap1 = getCMap(h1, "default");
        assertEquals(1, cmap1.mapRecords.size());
        assertEquals(1, cmap1.getMapIndexService().getOwnedRecords().size());
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        MigrationCompletionLatch l = new MigrationCompletionLatch("1", h1, h2);
        l.await(3, TimeUnit.SECONDS);
        IMap map2 = h2.getMap("default");
        CMap cmap2 = getCMap(h2, "default");
        assertEquals(1, cmap1.mapRecords.size());
        assertEquals(1, cmap2.mapRecords.size());
        assertEquals(1, cmap1.getMapIndexService().getOwnedRecords().size()
                + cmap2.getMapIndexService().getOwnedRecords().size());
        assertEquals(1, map1.size());
        assertEquals(1, map1.keySet().size());
        assertEquals(1, map2.size());
        assertEquals(1, map2.keySet().size());
        h1.getLifecycleService().shutdown();
        assertEquals(1, map2.size());
        assertEquals(1, map2.keySet().size());
        assertEquals(1, cmap2.mapRecords.size());
        assertEquals(1, cmap2.getMapIndexService().getOwnedRecords().size());
    }

    @Test(timeout = 60000)
    public void testMultiMapRecovery() throws Exception {
        HazelcastInstance h1 = Hazelcast.newHazelcastInstance(new Config());
        MultiMap mm = h1.getMultiMap("default");
        CMap cmap1 = getCMapForMultiMap(h1, "default");
        Collection<String> expectedValues = new HashSet<String>();
        expectedValues.add("value1");
        expectedValues.add("value2");
        mm.put("1", "value1");
        mm.put("1", "value2");
        assertEquals(2, mm.size());
        assertEquals(1, mm.keySet().size());
        Collection values = mm.get("1");
        for (Object value : values) {
            assertTrue(expectedValues.contains(value));
        }
        assertEquals(1, cmap1.getMapIndexService().getOwnedRecords().size());
        HazelcastInstance h2 = Hazelcast.newHazelcastInstance(new Config());
        MultiMap mm2 = h2.getMultiMap("default");
        CMap cmap2 = getCMapForMultiMap(h2, "default");
        MigrationCompletionLatch l = new MigrationCompletionLatch("1", h1, h2);
        l.await(3, TimeUnit.SECONDS);
        assertEquals(1, cmap1.getMapIndexService().getOwnedRecords().size()
                + cmap2.getMapIndexService().getOwnedRecords().size());
        cmap1.startCleanup(true);
        cmap2.startCleanup(true);
        assertEquals(2, mm.size());
        assertEquals(1, mm.keySet().size());
        values = mm.get("1");
        for (Object value : values) {
            assertTrue(expectedValues.contains(value));
        }
        assertEquals(2, mm2.size());
        assertEquals(1, mm2.keySet().size());
        values = mm2.get("1");
        for (Object value : values) {
            assertTrue(expectedValues.contains(value));…