Add Event and EventTest

remoting/android/javatests/src/org/chromium/chromoting/EventTest.java

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.chromoting;
+
+import android.test.InstrumentationTestCase;
+import android.test.suitebuilder.annotation.MediumTest;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.chromium.base.test.util.Feature;
+
+/**
+ * Tests for {@link Event}.
+ */
+public class EventTest extends InstrumentationTestCase {
+    @SmallTest
+    @Feature({"Chromoting"})
+    public static void testBasicScenario() {
+        Event.Executor<Void> event = new Event.Executor<>();
+        final Counter callTimes = new Counter();
+        Object eventId1 = event.add(new Event.ParameterRunnable<Void>() {
+                @Override
+                public void run(Void nil) {
+                    callTimes.increment();
+                }
+        });
+        Object eventId2 = event.add(new Event.ParameterRunnable<Void>() {
+                @Override
+                public void run(Void nil) {
+                    callTimes.increment();
+                }
+        });
+        Object eventId3 = event.add(new Event.ParameterRunnable<Void>() {
+                @Override
+                public void run(Void nil) {
+                    // Should not reach.
+                    assertTrue(false);

[Lambros, 2016/05/27 22:26:07]

(Here and elsewhere) Use fail() instead of assertTrue(false).
You can optionally pass in a String message.

[Hzj_jie, 2016/05/28 00:32:07]

Done.

+                    callTimes.increment();
+                }
+        });
+        assertNotNull(eventId1);
+        assertNotNull(eventId2);
+        assertNotNull(eventId3);
+        assertTrue(event.remove(eventId3));
+        for (int i = 0; i < 100; i++) {
+            assertEquals(event.raise(null), 2);
+            assertEquals(callTimes.get(), (i + 1) << 1);
+        }
+        assertTrue(event.remove(eventId1));
+        assertTrue(event.remove(eventId2));
+        assertFalse(event.remove(eventId3));
+    }
+
+    private static class MultithreadingTestRunner extends Thread {
+        private final Event.Executor<Void> mEvent;
+        private final Pointer<Boolean> mError;

[Lambros, 2016/05/27 22:26:07]

Would a MutableBoolean class work better here?
(and then Pointer is no longer used anywhere)

[Hzj_jie, 2016/05/28 00:32:07]

I would prefer to remove Counter / MutableInteger, since Pointer is more common,
we do not need to write a new class for certain usage. i.e. MutableLong /
MutableFloat ...

+
+        public MultithreadingTestRunner(Event.Executor<Void> event,
+                                        Pointer<Boolean> error) {
+            Preconditions.notNull(event);
+            Preconditions.notNull(error);
+            mEvent = event;
+            mError = error;
+        }
+
+        @Override
+        public void run() {
+            for (int i = 0; i < 100; i++) {
+                final Pointer<Boolean> called = new Pointer<>();
+                Object id = mEvent.add(new Event.ParameterRunnable<Void>() {
+                        @Override
+                        public void run(Void nil) {

[Lambros, 2016/05/27 22:26:07]

Maybe just run(Void) ?

[Hzj_jie, 2016/05/28 00:32:07]

I do not think Java support this syntax. :)

+                            called.set(true);
+                        }
+                });
+                if (id == null) {
+                    mError.set(true);
+                }
+                for (int j = 0; j < 100; j++) {
+                    called.set(false);
+                    if (mEvent.raise(null) <= 0) {
+                        mError.set(true);
+                    }
+                    if (!called.get()) {
+                        mError.set(true);
+                    }
+                }
+                if (!mEvent.remove(id)) {
+                    mError.set(true);
+                }
+            }
+        }
+    }
+
+    @MediumTest
+    @Feature({"Chromoting"})
+    public static void testMultithreading() {
+        Event.Executor<Void> event = new Event.Executor<>();
+        final int threadCount = 10;
+        final Pointer<Boolean> error = new Pointer<>();
+        Thread[] threads = new Thread[threadCount];
+        for (int i = 0; i < threadCount; i++) {
+            threads[i] = new MultithreadingTestRunner(event, error);
+            threads[i].start();
+        }
+        for (int i = 0; i < threadCount; i++) {
+            try {
+                threads[i].join();
+            } catch (InterruptedException exception) {
+                assertTrue(false);
+            }
+        }
+        assertNull(error.get());
+    }
+
+    @SmallTest
+    @Feature({"Chromoting"})
+    public static void testSelfRemovable() {
+        Event.Executor<Void> event = new Event.Executor<>();
+        final Pointer<Boolean> called = new Pointer<>();
+        final Pointer<Boolean> nextReturn = new Pointer<>();
+        nextReturn.set(true);
+        event.addSelfRemovable(new Event.ParameterCallback<Boolean, Void>() {
+            @Override
+            public Boolean run(Void nil) {
+                called.set(true);
+                return nextReturn.get();
+            }
+        });
+        assertEquals(event.raise(null), 1);
+        assertTrue(called.get());
+        assertFalse(event.isEmpty());
+        called.set(false);
+        nextReturn.set(false);
+        assertEquals(event.raise(null), 1);
+        assertTrue(called.get());
+        assertTrue(event.isEmpty());
+        called.set(false);
+        nextReturn.set(true);
+        assertEquals(event.raise(null), 0);
+        assertFalse(called.get());
+        assertTrue(event.isEmpty());
+    }
+}