package twist;

import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.List;
import java.util.Map;
import java.util.Random;

import static org.junit.Assert.*;
import java.util.Map.Entry;
import java.util.HashMap;
import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;

import org.junit.Before;
import org.junit.Test;

class CHMtester extends Thread{

    Map myMap;
    int count;
    boolean getOrPut;

    public CHMtester(Map map){
        myMap = map;
        getOrPut = false;
        count = 0;
    }

    public boolean getOrPutm(){
        return getOrPut;
    }


    public int getCount(){
        return count;
    }

    @Override
    public void run(){
        double num = Math.random();
        try {
            sleep(Math.abs((long)num*10));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if(num > 0.5){
            try{
                if (myMap.put(Math.abs(num), num)!=null)
                    getOrPut = true;
            }

            catch(ConcurrentModificationException e) {
                System.out.print("hello");
                throw new ConcurrentModificationException();
            }
        }
        else{
            try{
            Random rnd = new Random();
            List keys = new ArrayList(myMap.keySet());
            if (rnd.nextInt(keys.size())>=0)
            if (myMap.get(keys.get(rnd.nextInt(keys.size())))!=null)
                getOrPut = true;
            }
            catch (IllegalArgumentException ee) {

            }
            catch(ConcurrentModificationException ex){
                System.out.print("hello2");
                throw new ConcurrentModificationException();
            }
        }

    }
}


public class MyTest {
    static ConcurrentHashMap chm = new ConcurrentHashMap();

    @Before
    public void tester(){
        chm.put("A","NA");
    }

    @Test
    public void putObjectReturnObject(){
        chm.put("B","NB");
        assertTrue(chm.containsKey("B"));
    }

    @Test
    public void putTwinReturnTwin(){
        chm.put("A","NNAA");
        assertTrue(chm.containsValue("NNAA"));
    }

    @Test(expected = NullPointerException.class)
    public void putnullReturnNullPointerExceptionone(){
        chm.put("B",null);
    }

    @Test(expected = NullPointerException.class)
    public void putnullReturnNullPointerExceptiontwo(){
        chm.put(null,"QWE");
    }

    @Test
    public void thr1(){
        Map<String,String> myMap = new ConcurrentHashMap<String,String>();
        myMap.put("1", "3");
        myMap.put("2", "3");
        myMap.put("3", "3");
        myMap.put("4", "3");
        myMap.put("5", "3");
        Iterator it = myMap.entrySet().iterator();
        while (it.hasNext()){
            Entry item = (Map.Entry)it.next();
            myMap.remove(item.getKey());
        }
    }

    @Test
    public void thr2(){
        int n=1000;
        int count=0;
        Map<String,String> myMap = new ConcurrentHashMap<String,String>();
        CHMtester [] hm = new CHMtester[n];
        for(int i = 0; i < n; i++)
            hm[i] = new CHMtester(myMap);
        for(int i = 0; i < n; i++)
            hm[i].start();
        Iterator it = myMap.entrySet().iterator();
        while (it.hasNext()){
            Entry item = (Map.Entry)it.next();
            myMap.remove(item.getKey());
        }
        System.out.print(count);
    }

    @Test (expected = ConcurrentModificationException.class)
    public void thr3(){
        Map<String,String> myMap = new HashMap<String,String>();
        myMap.put("A", "B");
        myMap.put("V", "B");
        myMap.put("Z", "B");
        Iterator it = myMap.entrySet().iterator();
        while (it.hasNext()){
           Entry item = (Map.Entry)it.next();
           myMap.remove(item.getKey());
        }
    }
}