Fix data race in CircularOutputStream.

Calls to write(int) from different threads may read the same value of 'end'.

Author: juangj

java/client/src/org/openqa/selenium/io/CircularOutputStream.java

@@ -39,7 +39,7 @@ public CircularOutputStream() {
   }
 
   @Override
-  public void write(int b) throws IOException {
+  public synchronized void write(int b) throws IOException {
     if (end == buffer.length) {
       filled = true;
       end = 0;

java/client/test/org/openqa/selenium/remote/internal/CircularOutputStreamTest.java

@@ -20,6 +20,7 @@
 
 import static org.junit.Assert.assertEquals;
 
+import java.io.IOException;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -127,4 +128,53 @@ public void testCircularness() {
       assertEquals("56789", os.toString());
     }
   }
+
+  @Test
+  public void testConcurrentWrites() throws InterruptedException {
+    final int bytesToWrite = 10000;
+    CircularOutputStream os = new CircularOutputStream(2 * bytesToWrite);
+
+    Thread t1 = new Thread(new WriteChar(os, 'a', bytesToWrite));
+    Thread t2 = new Thread(new WriteChar(os, 'b', bytesToWrite));
+    t1.start();
+    t2.start();
+    t1.join();
+    t2.join();
+
+    int a = 0;
+    int b = 0;
+    for (char c : os.toString().toCharArray()) {
+      if (c == 'a') {
+        a++;
+      } else if (c == 'b') {
+        b++;
+      }
+    }
+    assertEquals(bytesToWrite, a);
+    assertEquals(bytesToWrite, b);
+  }
+
+  private static class WriteChar implements Runnable {
+    private final CircularOutputStream stream;
+    private final char c;
+    private final int count;
+
+    public WriteChar(CircularOutputStream stream, char c, int count) {
+      this.stream = stream;
+      this.c = c;
+      this.count = count;
+    }
+
+    @Override
+    public void run() {
+      try {
+        for (int i = 0; i < count; i++) {
+          stream.write(c);
+          Thread.yield();
+        }
+      } catch (IOException e) {
+        // Ignore; the test will fail later when we discover that not all writes finished.
+      }
+    }
+  }
 }