package org.msgpack;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.TimeoutException;

import org.junit.Before;

import org.junit.Test;

import org.msgpack.MessagePack;

import org.msgpack.packer.BufferPacker;

import org.msgpack.type.ArrayValue;

import org.msgpack.type.MapValue;

import org.msgpack.type.Value;

import org.msgpack.unpacker.BufferUnpacker;

public class TestThreadSafety {

private List<String> list = createList(1000);

private Map<String, String> map = createMap(1000);

private static final String EXAMPLE_STRING;

static {

StringBuilder buf = new StringBuilder();

for (int i = 0; i < 10; i++) {

buf.append("0000000000111111111122222222223333333333444444444455555555556666666666777777777788888888889999999999");

}

EXAMPLE_STRING = buf.toString();

}

private List<String> createList(int n) {

List<String> src = new ArrayList<String>();

for (int i = 0; i < n; i++) {

src.add(EXAMPLE_STRING);

}

return src;

}

private Map<String, String> createMap(int n) {

Map<String, String> src = new HashMap<String, String>();

for (int i = 0; i < n; i++) {

src.put(String.valueOf(i), EXAMPLE_STRING);

}

return src;

}

private void testMsgpackDynamicString(int n) throws IOException {

MessagePack msgpack = new MessagePack();

BufferPacker packer = msgpack.createBufferPacker();

for (int i = 0; i < n; i++) {

packer.write(EXAMPLE_STRING);

}

byte[] raw = packer.toByteArray();

BufferUnpacker unpacker = msgpack.createBufferUnpacker(raw);

for (int i = 0; i < n; i++) {

String dst = unpacker.read(String.class);

if (!dst.equals(EXAMPLE_STRING)) {

throw new AssertionError();

}

}

}

private void testMsgpackDynamicArray() throws IOException {

List<String> src = list;

MessagePack msgpack = new MessagePack();

byte[] raw;

raw = msgpack.write(src);

List<String> dst = new LinkedList<String>();

ArrayValue arrayValue = msgpack.read(raw).asArrayValue();

for (Value v : arrayValue) {

dst.add(v.asRawValue().getString());

if (!v.asRawValue().getString().equals(EXAMPLE_STRING)) {

throw new AssertionError();

}

}

}

private void testMsgpackDynamicMap() throws IOException {

Map<String, String> src = map;

MessagePack msgpack = new MessagePack();

byte[] raw;

raw = msgpack.write(src);

MapValue mv = msgpack.read(raw).asMapValue();

for (Entry<Value, Value> kv : mv.entrySet()) {

if (!kv.getValue().asRawValue().getString().equals(EXAMPLE_STRING)) {

throw new AssertionError();

}

}

}

static class TestRunner implements Callable<Void> {

private final TestThreadSafety main;

public TestRunner(TestThreadSafety main) {

this.main = main;

}

@Override

public Void call() throws Exception {

try {

main.testMsgpackDynamicString(1000);

main.testMsgpackDynamicArray();

main.testMsgpackDynamicMap();

} catch (IOException e) {

throw new RuntimeException(e);

}

return null;

}

}

@Test

public void testWithBulkData() throws InterruptedException, ExecutionException, TimeoutException {

final TestThreadSafety main = new TestThreadSafety();

List<Future<Void>> futures = new LinkedList<Future<Void>>();

ExecutorService executorService = Executors.newCachedThreadPool();

for (int i = 0; i < 20; i++) {

futures.add(executorService.submit(new TestRunner(main)));

}

for (Future<Void> future : futures) {

future.get(30, TimeUnit.SECONDS);

}

}

}