hugegraph-common/src/test/java/com/baidu/hugegraph/unit/event/EventHubTest.java - incubator-hugegraph-commons - Git at Google

 /*
  * Copyright 2017 HugeGraph Authors
  *
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements. See the NOTICE file distributed with this
  * work for additional information regarding copyright ownership. The ASF
  * licenses this file to You 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.baidu.hugegraph.unit.event;

 import java.util.concurrent.atomic.AtomicInteger;

 import org.junit.After;
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;

 import com.baidu.hugegraph.event.Event;
 import com.baidu.hugegraph.event.EventHub;
 import com.baidu.hugegraph.event.EventListener;
 import com.baidu.hugegraph.testutil.Assert;
 import com.baidu.hugegraph.unit.BaseUnitTest;
 import com.google.common.collect.ImmutableList;

 public class EventHubTest extends BaseUnitTest {

     private static final int THREADS_NUM = 8;

     private EventHub eventHub = null;

     @BeforeClass
     public static void init() {
         EventHub.init(THREADS_NUM);
     }

     @AfterClass
     public static void clear() throws InterruptedException {
         EventHub.destroy(30);
     }

     @Before
     public void setup() {
         this.eventHub = new EventHub("test");
         Assert.assertEquals("test", this.eventHub.name());
     }

     @After
     public void teardown() {
         this.eventHub = null;
     }

     private void wait100ms() {
         try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }
     }

     @Test
     public void testEventGetListenerNonResult() {
         Assert.assertFalse(this.eventHub.containsListener("not-exist"));
         Assert.assertEquals(0, this.eventHub.listeners("not-exist").size());
     }

     @Test
     public void testEventAddListener() {
         final String event = "event-test";

         EventListener listener = new EventListener() {
             @Override
             public Object event(Event arg0) {
                 return null;
             }
         };

         this.eventHub.listen(event, listener);

         Assert.assertTrue(this.eventHub.containsListener(event));
         Assert.assertEquals(1, this.eventHub.listeners(event).size());
         Assert.assertEquals(listener, this.eventHub.listeners(event).get(0));
     }

     @Test
     public void testEventAddListenerTwice() {
         final String event = "event-test";

         EventListener listener = new EventListener() {
             @Override
             public Object event(Event arg0) {
                 return null;
             }
         };

         this.eventHub.listen(event, listener);
         this.eventHub.listen(event, listener);

         Assert.assertTrue(this.eventHub.containsListener(event));
         Assert.assertEquals(2, this.eventHub.listeners(event).size());
         Assert.assertEquals(listener, this.eventHub.listeners(event).get(0));
         Assert.assertEquals(listener, this.eventHub.listeners(event).get(1));
     }

     @Test
     public void testEventRemoveListener() {
         final String event = "event-test";

         EventListener listener = new EventListener() {
             @Override
             public Object event(Event arg0) {
                 return null;
             }
         };

         this.eventHub.listen(event, listener);

         Assert.assertTrue(this.eventHub.containsListener(event));
         Assert.assertEquals(1, this.eventHub.listeners(event).size());
         Assert.assertEquals(listener, this.eventHub.listeners(event).get(0));

         Assert.assertEquals(1, this.eventHub.unlisten(event, listener));

         Assert.assertFalse(this.eventHub.containsListener(event));
         Assert.assertEquals(0, this.eventHub.listeners(event).size());
     }

     @Test
     public void testEventRemoveListenerButNonResult() {
         final String event = "event-test";

         EventListener listener = new EventListener() {
             @Override
             public Object event(Event arg0) {
                 return null;
             }
         };

         this.eventHub.listen(event, listener);

         Assert.assertTrue(this.eventHub.containsListener(event));
         Assert.assertEquals(1, this.eventHub.listeners(event).size());
         Assert.assertEquals(listener, this.eventHub.listeners(event).get(0));

         Assert.assertEquals(0, this.eventHub.unlisten(event, null));
         Assert.assertEquals(0, this.eventHub.unlisten("event-fake", listener));

         Assert.assertTrue(this.eventHub.containsListener(event));
         Assert.assertEquals(1, this.eventHub.listeners(event).size());
         Assert.assertEquals(listener, this.eventHub.listeners(event).get(0));
     }

     @Test
     public void testEventRemoveListenerOfOneInTwo() {
         final String event1 = "event-test1";
         final String event2 = "event-test2";

         EventListener listener = new EventListener() {
             @Override
             public Object event(Event arg0) {
                 return null;
             }
         };

         this.eventHub.listen(event1, listener);
         this.eventHub.listen(event2, listener);

         Assert.assertTrue(this.eventHub.containsListener(event1));
         Assert.assertEquals(1, this.eventHub.listeners(event1).size());
         Assert.assertEquals(listener, this.eventHub.listeners(event1).get(0));

         Assert.assertTrue(this.eventHub.containsListener(event2));
         Assert.assertEquals(1, this.eventHub.listeners(event2).size());
         Assert.assertEquals(listener, this.eventHub.listeners(event2).get(0));

         Assert.assertEquals(1, this.eventHub.unlisten(event1, listener));

         Assert.assertFalse(this.eventHub.containsListener(event1));
         Assert.assertFalse(this.eventHub.containsListener(event1));
         Assert.assertEquals(0, this.eventHub.listeners(event1).size());

         Assert.assertTrue(this.eventHub.containsListener(event2));
         Assert.assertEquals(1, this.eventHub.listeners(event2).size());
         Assert.assertEquals(listener, this.eventHub.listeners(event2).get(0));
     }

     @Test
     public void testEventRemoveListenerByEvent() {
         final String event = "event-test";

         EventListener listener1 = new EventListener() {
             @Override
             public Object event(Event arg0) {
                 return null;
             }
         };

         EventListener listener2 = new EventListener() {
             @Override
             public Object event(Event arg0) {
                 return null;
             }
         };

         this.eventHub.listen(event, listener1);
         this.eventHub.listen(event, listener2);

         Assert.assertTrue(this.eventHub.containsListener(event));
         Assert.assertEquals(2, this.eventHub.listeners(event).size());
         Assert.assertEquals(listener1, this.eventHub.listeners(event).get(0));
         Assert.assertEquals(listener2, this.eventHub.listeners(event).get(1));

         Assert.assertEquals(2, this.eventHub.unlisten(event).size());

         Assert.assertFalse(this.eventHub.containsListener(event));
         Assert.assertEquals(0, this.eventHub.listeners(event).size());
     }

     @Test
     public void testEventRemoveListenerByEventButNonResult() {
         final String event = "event-test";

         EventListener listener1 = new EventListener() {
             @Override
             public Object event(Event arg0) {
                 return null;
             }
         };

         EventListener listener2 = new EventListener() {
             @Override
             public Object event(Event arg0) {
                 return null;
             }
         };

         this.eventHub.listen(event, listener1);
         this.eventHub.listen(event, listener2);

         Assert.assertTrue(this.eventHub.containsListener(event));
         Assert.assertEquals(2, this.eventHub.listeners(event).size());
         Assert.assertEquals(listener1, this.eventHub.listeners(event).get(0));
         Assert.assertEquals(listener2, this.eventHub.listeners(event).get(1));

         Assert.assertEquals(0, this.eventHub.unlisten("event-fake").size());

         Assert.assertEquals(2, this.eventHub.listeners(event).size());
     }

     @Test
     public void testEventRemoveListenerByEventOf2SameListener() {
         final String event = "event-test";

         EventListener listener = new EventListener() {
             @Override
             public Object event(Event arg0) {
                 return null;
             }
         };

         this.eventHub.listen(event, listener);
         this.eventHub.listen(event, listener);

         Assert.assertTrue(this.eventHub.containsListener(event));
         Assert.assertEquals(2, this.eventHub.listeners(event).size());
         Assert.assertEquals(listener, this.eventHub.listeners(event).get(0));

         Assert.assertEquals(2, this.eventHub.unlisten(event, listener));

         Assert.assertFalse(this.eventHub.containsListener(event));
         Assert.assertEquals(0, this.eventHub.listeners(event).size());
     }

     @Test
     public void testEventCallWithoutArg() {
         final String call = "event-call";

         this.eventHub.listen(call, event -> {
             Assert.assertEquals(call, event.name());
             Assert.assertEquals(0, event.args().length);
             return "fake-event-result";
         });

         Assert.assertEquals("fake-event-result", this.eventHub.call(call));
     }

     @Test
     public void testEventCallWithArg1() {
         final String call = "event-call";

         this.eventHub.listen(call, event -> {
             Assert.assertEquals(call, event.name());

             event.checkArgs(Float.class);

             Object[] args = event.args();
             Assert.assertEquals(1, args.length);
             Assert.assertEquals(3.14f, args[0]);

             return "fake-event-result";
         });

         Assert.assertEquals("fake-event-result",
                             this.eventHub.call(call, 3.14f));
     }

     @Test
     public void testEventCallWithArg2() {
         final String call = "event-call";

         this.eventHub.listen(call, event -> {
             Assert.assertEquals(call, event.name());

             event.checkArgs(String.class, Integer.class);

             Object[] args = event.args();
             Assert.assertEquals(2, args.length);
             Assert.assertEquals("fake-arg0", args[0]);
             Assert.assertEquals(123, args[1]);

             return "fake-event-result";
         });

         Assert.assertEquals("fake-event-result",
                             this.eventHub.call(call, "fake-arg0", 123));
     }

     @Test
     public void testEventCallWithArg2ButArgNotMatched() {
         final String call = "event-call";

         this.eventHub.listen(call, event -> {
             Assert.assertEquals(call, event.name());

             event.checkArgs(String.class, Integer.class);

             Object[] args = event.args();
             Assert.assertEquals(2, args.length);
             Assert.assertEquals("fake-arg0", args[0]);
             Assert.assertEquals(123, args[1]);

             return "fake-event-result";
         });

         Assert.assertThrows(IllegalArgumentException.class, () -> {
             this.eventHub.call(call, "fake-arg0");
         });

         Assert.assertThrows(IllegalArgumentException.class, () -> {
             this.eventHub.call(call, "fake-arg0", 123, "456");
         });

         Assert.assertThrows(IllegalArgumentException.class, () -> {
             this.eventHub.call(call, 123, "fake-arg0");
         });

         Assert.assertThrows(IllegalArgumentException.class, () -> {
             this.eventHub.call(call, "fake-arg0", 123f);
         });

         Assert.assertThrows(IllegalArgumentException.class, () -> {
             this.eventHub.call(call, "fake-arg0", "123");
         });
     }

     @Test
     public void testEventNotify() {
         final String notify = "event-notify";
         AtomicInteger count = new AtomicInteger();

         this.eventHub.listen(notify, event -> {
             Assert.assertEquals(notify, event.name());
             Assert.assertEquals(0, event.args().length);
             count.incrementAndGet();
             return true;
         });

         this.eventHub.notify(notify);

         // Maybe should improve
         this.wait100ms();

         Assert.assertEquals(1, count.get());
     }

     @Test
     public void testEventNotifyAny() {
         AtomicInteger count = new AtomicInteger();

         this.eventHub.listen(EventHub.ANY_EVENT, event -> {
             Assert.assertTrue(ImmutableList.of("event1", "event2")
                                            .contains(event.name()));
             Assert.assertEquals(0, event.args().length);
             count.incrementAndGet();
             return true;
         });

         this.eventHub.notify("event1");
         this.eventHub.notify("event2");

         // Maybe should improve
         this.wait100ms();

         Assert.assertEquals(2, count.get());
     }

     @Test
     public void testEventNotifyWithArg2() {
         final String notify = "event-notify";
         AtomicInteger count = new AtomicInteger();

         this.eventHub.listen(notify, event -> {
             Assert.assertEquals(notify, event.name());

             event.checkArgs(String.class, Integer.class);

             Object[] args = event.args();
             Assert.assertEquals("fake-arg0", args[0]);
             Assert.assertEquals(123, args[1]);

             count.incrementAndGet();
             return true;
         });

         this.eventHub.notify(notify, "fake-arg0", 123);

         // Maybe should improve
         this.wait100ms();

         Assert.assertEquals(1, count.get());
     }

     @Test
     public void testEventNotifyWithMultiThreads() throws InterruptedException {
         final String notify = "event-notify";

         EventListener listener1 = new EventListener() {
             @Override
             public Object event(Event event) {
                 Assert.assertEquals(notify, event.name());
                 event.checkArgs(Integer.class);
                 return null;
             }
         };

         EventListener listener2 = new EventListener() {
             @Override
             public Object event(Event event) {
                 Assert.assertEquals(notify, event.name());

                 event.checkArgs(Integer.class);
                 int i = (int) event.args()[0];
                 if (i % 10000 == 0) {
                     System.out.println("On event '" + notify + "': " + i);
                 }
                 return null;
             }
         };

         Thread listenerUpdateThread = new Thread(() -> {
             // This will cost about 1s
             for (int i = 0; i < 10; i++) {
                 this.eventHub.listen(notify, listener1);
                 if (!this.eventHub.listeners(notify).contains(listener2)) {
                     this.eventHub.listen(notify, listener2);
                 }

                 this.wait100ms();

                 if (i % 2 == 0) {
                     this.eventHub.unlisten(notify);
                 } else {
                     this.eventHub.unlisten(notify, listener1);
                 }
             }
         });
         listenerUpdateThread.start();

         runWithThreads(THREADS_NUM, () -> {
             // This will cost about 1s ~ 2s
             for (int i = 0; i < 10000 * 10; i++) {
                 this.eventHub.notify(notify, i);
                 Thread.yield();
             }
         });

         listenerUpdateThread.join();
     }

     @Test
     public void testEventCallWithMultiThreads() {
         final String call = "event-call";

         EventListener listener = new EventListener() {
             @Override
             public Object event(Event event) {
                 Assert.assertEquals(call, event.name());

                 event.checkArgs(Integer.class);
                 int i = (int) event.args()[0];
                 return i;
             }
         };

         this.eventHub.listen(call, listener);

         runWithThreads(THREADS_NUM, () -> {
             for (int i = 0; i < 10000 * 1000; i++) {
                 Assert.assertEquals(i, this.eventHub.call(call, i));
             }
         });
     }
 }
	/*
	* Copyright 2017 HugeGraph Authors
	*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with this
	* work for additional information regarding copyright ownership. The ASF
	* licenses this file to You 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.baidu.hugegraph.unit.event;

	import java.util.concurrent.atomic.AtomicInteger;

	import org.junit.After;
	import org.junit.AfterClass;
	import org.junit.Before;
	import org.junit.BeforeClass;
	import org.junit.Test;

	import com.baidu.hugegraph.event.Event;
	import com.baidu.hugegraph.event.EventHub;
	import com.baidu.hugegraph.event.EventListener;
	import com.baidu.hugegraph.testutil.Assert;
	import com.baidu.hugegraph.unit.BaseUnitTest;
	import com.google.common.collect.ImmutableList;

	public class EventHubTest extends BaseUnitTest {

	private static final int THREADS_NUM = 8;

	private EventHub eventHub = null;

	@BeforeClass
	public static void init() {
	EventHub.init(THREADS_NUM);
	}

	@AfterClass
	public static void clear() throws InterruptedException {
	EventHub.destroy(30);
	}

	@Before
	public void setup() {
	this.eventHub = new EventHub("test");
	Assert.assertEquals("test", this.eventHub.name());
	}

	@After
	public void teardown() {
	this.eventHub = null;
	}

	private void wait100ms() {
	try {
	Thread.sleep(100);
	} catch (InterruptedException e) {
	throw new RuntimeException(e);
	}
	}

	@Test
	public void testEventGetListenerNonResult() {
	Assert.assertFalse(this.eventHub.containsListener("not-exist"));
	Assert.assertEquals(0, this.eventHub.listeners("not-exist").size());
	}

	@Test
	public void testEventAddListener() {
	final String event = "event-test";

	EventListener listener = new EventListener() {
	@Override
	public Object event(Event arg0) {
	return null;
	}
	};

	this.eventHub.listen(event, listener);

	Assert.assertTrue(this.eventHub.containsListener(event));
	Assert.assertEquals(1, this.eventHub.listeners(event).size());
	Assert.assertEquals(listener, this.eventHub.listeners(event).get(0));
	}

	@Test
	public void testEventAddListenerTwice() {
	final String event = "event-test";

	EventListener listener = new EventListener() {
	@Override
	public Object event(Event arg0) {
	return null;
	}
	};

	this.eventHub.listen(event, listener);
	this.eventHub.listen(event, listener);

	Assert.assertTrue(this.eventHub.containsListener(event));
	Assert.assertEquals(2, this.eventHub.listeners(event).size());
	Assert.assertEquals(listener, this.eventHub.listeners(event).get(0));
	Assert.assertEquals(listener, this.eventHub.listeners(event).get(1));
	}

	@Test
	public void testEventRemoveListener() {
	final String event = "event-test";

	EventListener listener = new EventListener() {
	@Override
	public Object event(Event arg0) {
	return null;
	}
	};

	this.eventHub.listen(event, listener);

	Assert.assertTrue(this.eventHub.containsListener(event));
	Assert.assertEquals(1, this.eventHub.listeners(event).size());
	Assert.assertEquals(listener, this.eventHub.listeners(event).get(0));

	Assert.assertEquals(1, this.eventHub.unlisten(event, listener));

	Assert.assertFalse(this.eventHub.containsListener(event));
	Assert.assertEquals(0, this.eventHub.listeners(event).size());
	}

	@Test
	public void testEventRemoveListenerButNonResult() {
	final String event = "event-test";

	EventListener listener = new EventListener() {
	@Override
	public Object event(Event arg0) {
	return null;
	}
	};

	this.eventHub.listen(event, listener);

	Assert.assertTrue(this.eventHub.containsListener(event));
	Assert.assertEquals(1, this.eventHub.listeners(event).size());
	Assert.assertEquals(listener, this.eventHub.listeners(event).get(0));

	Assert.assertEquals(0, this.eventHub.unlisten(event, null));
	Assert.assertEquals(0, this.eventHub.unlisten("event-fake", listener));

	Assert.assertTrue(this.eventHub.containsListener(event));
	Assert.assertEquals(1, this.eventHub.listeners(event).size());
	Assert.assertEquals(listener, this.eventHub.listeners(event).get(0));
	}

	@Test
	public void testEventRemoveListenerOfOneInTwo() {
	final String event1 = "event-test1";
	final String event2 = "event-test2";

	EventListener listener = new EventListener() {
	@Override
	public Object event(Event arg0) {
	return null;
	}
	};

	this.eventHub.listen(event1, listener);
	this.eventHub.listen(event2, listener);

	Assert.assertTrue(this.eventHub.containsListener(event1));
	Assert.assertEquals(1, this.eventHub.listeners(event1).size());
	Assert.assertEquals(listener, this.eventHub.listeners(event1).get(0));

	Assert.assertTrue(this.eventHub.containsListener(event2));
	Assert.assertEquals(1, this.eventHub.listeners(event2).size());
	Assert.assertEquals(listener, this.eventHub.listeners(event2).get(0));

	Assert.assertEquals(1, this.eventHub.unlisten(event1, listener));

	Assert.assertFalse(this.eventHub.containsListener(event1));
	Assert.assertFalse(this.eventHub.containsListener(event1));
	Assert.assertEquals(0, this.eventHub.listeners(event1).size());

	Assert.assertTrue(this.eventHub.containsListener(event2));
	Assert.assertEquals(1, this.eventHub.listeners(event2).size());
	Assert.assertEquals(listener, this.eventHub.listeners(event2).get(0));
	}

	@Test
	public void testEventRemoveListenerByEvent() {
	final String event = "event-test";

	EventListener listener1 = new EventListener() {
	@Override
	public Object event(Event arg0) {
	return null;
	}
	};

	EventListener listener2 = new EventListener() {
	@Override
	public Object event(Event arg0) {
	return null;
	}
	};

	this.eventHub.listen(event, listener1);
	this.eventHub.listen(event, listener2);

	Assert.assertTrue(this.eventHub.containsListener(event));
	Assert.assertEquals(2, this.eventHub.listeners(event).size());
	Assert.assertEquals(listener1, this.eventHub.listeners(event).get(0));
	Assert.assertEquals(listener2, this.eventHub.listeners(event).get(1));

	Assert.assertEquals(2, this.eventHub.unlisten(event).size());

	Assert.assertFalse(this.eventHub.containsListener(event));
	Assert.assertEquals(0, this.eventHub.listeners(event).size());
	}

	@Test
	public void testEventRemoveListenerByEventButNonResult() {
	final String event = "event-test";

	EventListener listener1 = new EventListener() {
	@Override
	public Object event(Event arg0) {
	return null;
	}
	};

	EventListener listener2 = new EventListener() {
	@Override
	public Object event(Event arg0) {
	return null;
	}
	};

	this.eventHub.listen(event, listener1);
	this.eventHub.listen(event, listener2);

	Assert.assertTrue(this.eventHub.containsListener(event));
	Assert.assertEquals(2, this.eventHub.listeners(event).size());
	Assert.assertEquals(listener1, this.eventHub.listeners(event).get(0));
	Assert.assertEquals(listener2, this.eventHub.listeners(event).get(1));

	Assert.assertEquals(0, this.eventHub.unlisten("event-fake").size());

	Assert.assertEquals(2, this.eventHub.listeners(event).size());
	}

	@Test
	public void testEventRemoveListenerByEventOf2SameListener() {
	final String event = "event-test";

	EventListener listener = new EventListener() {
	@Override
	public Object event(Event arg0) {
	return null;
	}
	};

	this.eventHub.listen(event, listener);
	this.eventHub.listen(event, listener);

	Assert.assertTrue(this.eventHub.containsListener(event));
	Assert.assertEquals(2, this.eventHub.listeners(event).size());
	Assert.assertEquals(listener, this.eventHub.listeners(event).get(0));

	Assert.assertEquals(2, this.eventHub.unlisten(event, listener));

	Assert.assertFalse(this.eventHub.containsListener(event));
	Assert.assertEquals(0, this.eventHub.listeners(event).size());
	}

	@Test
	public void testEventCallWithoutArg() {
	final String call = "event-call";

	this.eventHub.listen(call, event -> {
	Assert.assertEquals(call, event.name());
	Assert.assertEquals(0, event.args().length);
	return "fake-event-result";
	});

	Assert.assertEquals("fake-event-result", this.eventHub.call(call));
	}

	@Test
	public void testEventCallWithArg1() {
	final String call = "event-call";

	this.eventHub.listen(call, event -> {
	Assert.assertEquals(call, event.name());

	event.checkArgs(Float.class);

	Object[] args = event.args();
	Assert.assertEquals(1, args.length);
	Assert.assertEquals(3.14f, args[0]);

	return "fake-event-result";
	});

	Assert.assertEquals("fake-event-result",
	this.eventHub.call(call, 3.14f));
	}

	@Test
	public void testEventCallWithArg2() {
	final String call = "event-call";

	this.eventHub.listen(call, event -> {
	Assert.assertEquals(call, event.name());

	event.checkArgs(String.class, Integer.class);

	Object[] args = event.args();
	Assert.assertEquals(2, args.length);
	Assert.assertEquals("fake-arg0", args[0]);
	Assert.assertEquals(123, args[1]);

	return "fake-event-result";
	});

	Assert.assertEquals("fake-event-result",
	this.eventHub.call(call, "fake-arg0", 123));
	}

	@Test
	public void testEventCallWithArg2ButArgNotMatched() {
	final String call = "event-call";

	this.eventHub.listen(call, event -> {
	Assert.assertEquals(call, event.name());

	event.checkArgs(String.class, Integer.class);

	Object[] args = event.args();
	Assert.assertEquals(2, args.length);
	Assert.assertEquals("fake-arg0", args[0]);
	Assert.assertEquals(123, args[1]);

	return "fake-event-result";
	});

	Assert.assertThrows(IllegalArgumentException.class, () -> {
	this.eventHub.call(call, "fake-arg0");
	});

	Assert.assertThrows(IllegalArgumentException.class, () -> {
	this.eventHub.call(call, "fake-arg0", 123, "456");
	});

	Assert.assertThrows(IllegalArgumentException.class, () -> {
	this.eventHub.call(call, 123, "fake-arg0");
	});

	Assert.assertThrows(IllegalArgumentException.class, () -> {
	this.eventHub.call(call, "fake-arg0", 123f);
	});

	Assert.assertThrows(IllegalArgumentException.class, () -> {
	this.eventHub.call(call, "fake-arg0", "123");
	});
	}

	@Test
	public void testEventNotify() {
	final String notify = "event-notify";
	AtomicInteger count = new AtomicInteger();

	this.eventHub.listen(notify, event -> {
	Assert.assertEquals(notify, event.name());
	Assert.assertEquals(0, event.args().length);
	count.incrementAndGet();
	return true;
	});

	this.eventHub.notify(notify);

	// Maybe should improve
	this.wait100ms();

	Assert.assertEquals(1, count.get());
	}

	@Test
	public void testEventNotifyAny() {
	AtomicInteger count = new AtomicInteger();

	this.eventHub.listen(EventHub.ANY_EVENT, event -> {
	Assert.assertTrue(ImmutableList.of("event1", "event2")
	.contains(event.name()));
	Assert.assertEquals(0, event.args().length);
	count.incrementAndGet();
	return true;
	});

	this.eventHub.notify("event1");
	this.eventHub.notify("event2");

	// Maybe should improve
	this.wait100ms();

	Assert.assertEquals(2, count.get());
	}

	@Test
	public void testEventNotifyWithArg2() {
	final String notify = "event-notify";
	AtomicInteger count = new AtomicInteger();

	this.eventHub.listen(notify, event -> {
	Assert.assertEquals(notify, event.name());

	event.checkArgs(String.class, Integer.class);

	Object[] args = event.args();
	Assert.assertEquals("fake-arg0", args[0]);
	Assert.assertEquals(123, args[1]);

	count.incrementAndGet();
	return true;
	});

	this.eventHub.notify(notify, "fake-arg0", 123);

	// Maybe should improve
	this.wait100ms();

	Assert.assertEquals(1, count.get());
	}

	@Test
	public void testEventNotifyWithMultiThreads() throws InterruptedException {
	final String notify = "event-notify";

	EventListener listener1 = new EventListener() {
	@Override
	public Object event(Event event) {
	Assert.assertEquals(notify, event.name());
	event.checkArgs(Integer.class);
	return null;
	}
	};

	EventListener listener2 = new EventListener() {
	@Override
	public Object event(Event event) {
	Assert.assertEquals(notify, event.name());

	event.checkArgs(Integer.class);
	int i = (int) event.args()[0];
	if (i % 10000 == 0) {
	System.out.println("On event '" + notify + "': " + i);
	}
	return null;
	}
	};

	Thread listenerUpdateThread = new Thread(() -> {
	// This will cost about 1s
	for (int i = 0; i < 10; i++) {
	this.eventHub.listen(notify, listener1);
	if (!this.eventHub.listeners(notify).contains(listener2)) {
	this.eventHub.listen(notify, listener2);
	}

	this.wait100ms();

	if (i % 2 == 0) {
	this.eventHub.unlisten(notify);
	} else {
	this.eventHub.unlisten(notify, listener1);
	}
	}
	});
	listenerUpdateThread.start();

	runWithThreads(THREADS_NUM, () -> {
	// This will cost about 1s ~ 2s
	for (int i = 0; i < 10000 * 10; i++) {
	this.eventHub.notify(notify, i);
	Thread.yield();
	}
	});

	listenerUpdateThread.join();
	}

	@Test
	public void testEventCallWithMultiThreads() {
	final String call = "event-call";

	EventListener listener = new EventListener() {
	@Override
	public Object event(Event event) {
	Assert.assertEquals(call, event.name());

	event.checkArgs(Integer.class);
	int i = (int) event.args()[0];
	return i;
	}
	};

	this.eventHub.listen(call, listener);

	runWithThreads(THREADS_NUM, () -> {
	for (int i = 0; i < 10000 * 1000; i++) {
	Assert.assertEquals(i, this.eventHub.call(call, i));
	}
	});
	}
	}