Adding 20-second timeout to Java and Objective-C tests.

talk/app/webrtc/java/testcommon/src/org/webrtc/PeerConnectionTest.java

 /*
  * libjingle
  * Copyright 2013 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 32 matching lines @@
 import java.util.TreeSet;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
 import static junit.framework.Assert.*;
 
 /** End-to-end tests for PeerConnection.java. */
 public class PeerConnectionTest {
   // Set to true to render video.
   private static final boolean RENDER_TO_GUI = false;
+  private static final int TIMEOUT_SECONDS = 20;
   private TreeSet<String> threadsBeforeTest = null;
 
   private static class ObserverExpectations implements PeerConnection.Observer,
                                                        VideoRenderer.Callbacks,
                                                        DataChannel.Observer,
                                                        StatsObserver {
     private final String name;
     private int expectedIceCandidates = 0;
     private int expectedErrors = 0;
     private int expectedRenegotiations = 0;
@@ skipping 277 matching lines @@
         stillWaitingForExpectations.add("expectedRemoteDataChannelLabels: " +
                                         expectedRemoteDataChannelLabels.size());
       }
       if (expectedStatsCallbacks != 0) {
         stillWaitingForExpectations.add(
             "expectedStatsCallbacks: " + expectedStatsCallbacks);
       }
       return stillWaitingForExpectations;
     }
 
-    public void waitForAllExpectationsToBeSatisfied() {
+    public boolean waitForAllExpectationsToBeSatisfied(int timeoutSeconds) {
       // TODO(fischman): problems with this approach:
       // - come up with something better than a poll loop
       // - avoid serializing expectations explicitly; the test is not as robust
       //   as it could be because it must place expectations between wait
       //   statements very precisely (e.g. frame must not arrive before its
       //   expectation, and expectation must not be registered so early as to
       //   stall a wait).  Use callbacks to fire off dependent steps instead of
       //   explicitly waiting, so there can be just a single wait at the end of
       //   the test.
+      long endTime = System.currentTimeMillis() + 1000 * timeoutSeconds;
       TreeSet<String> prev = null;
       TreeSet<String> stillWaitingForExpectations = unsatisfiedExpectations();
       while (!stillWaitingForExpectations.isEmpty()) {
         if (!stillWaitingForExpectations.equals(prev)) {
           System.out.println(
               name + " still waiting at\n    " +
               (new Throwable()).getStackTrace()[1] +
               "\n    for: " +
               Arrays.toString(stillWaitingForExpectations.toArray()));
         }
+        if (endTime < System.currentTimeMillis()) {
+          System.out.println(name + " timed out waiting for: "
+              + Arrays.toString(stillWaitingForExpectations.toArray()));
+          return false;
+        }
         try {
           Thread.sleep(10);
         } catch (InterruptedException e) {
           throw new RuntimeException(e);
         }
         prev = stillWaitingForExpectations;
         stillWaitingForExpectations = unsatisfiedExpectations();
       }
       if (prev == null) {
         System.out.println(name + " didn't need to wait at\n    " +
                            (new Throwable()).getStackTrace()[1]);
       }
+      return true;
     }
 
     // This methods return a list of all currently gathered ice candidates or waits until
     // 1 candidate have been gathered.
     public List<IceCandidate> getAtLeastOneIceCandidate() throws InterruptedException {
       synchronized (gotIceCandidates) {
         while (gotIceCandidates.isEmpty()) {
           gotIceCandidates.wait();
         }
         return new LinkedList<IceCandidate>(gotIceCandidates);
@@ skipping 262 matching lines @@
     for (IceCandidate candidate : offeringExpectations.getAtLeastOneIceCandidate()) {
       answeringPC.addIceCandidate(candidate);
     }
 
     // Wait for at least one ice candidate from the answering PC and forward them to the offering
     // PC.
     for (IceCandidate candidate : answeringExpectations.getAtLeastOneIceCandidate()) {
       offeringPC.addIceCandidate(candidate);
     }
 
-    offeringExpectations.waitForAllExpectationsToBeSatisfied();
-    answeringExpectations.waitForAllExpectationsToBeSatisfied();
+    assertTrue(offeringExpectations.waitForAllExpectationsToBeSatisfied(TIMEOUT_SECONDS));
+    assertTrue(answeringExpectations.waitForAllExpectationsToBeSatisfied(TIMEOUT_SECONDS));
 
     assertEquals(
         PeerConnection.SignalingState.STABLE, offeringPC.signalingState());
     assertEquals(
         PeerConnection.SignalingState.STABLE, answeringPC.signalingState());
 
     // Test send & receive UTF-8 text.
     answeringExpectations.expectMessage(
         ByteBuffer.wrap("hello!".getBytes(Charset.forName("UTF-8"))), false);
     DataChannel.Buffer buffer = new DataChannel.Buffer(
         ByteBuffer.wrap("hello!".getBytes(Charset.forName("UTF-8"))), false);
     assertTrue(offeringExpectations.dataChannel.send(buffer));
-    answeringExpectations.waitForAllExpectationsToBeSatisfied();
+    assertTrue(answeringExpectations.waitForAllExpectationsToBeSatisfied(TIMEOUT_SECONDS));
 
     // Construct this binary message two different ways to ensure no
     // shortcuts are taken.
     ByteBuffer expectedBinaryMessage = ByteBuffer.allocateDirect(5);
     for (byte i = 1; i < 6; ++i) {
       expectedBinaryMessage.put(i);
     }
     expectedBinaryMessage.flip();
     offeringExpectations.expectMessage(expectedBinaryMessage, true);
     assertTrue(answeringExpectations.dataChannel.send(
         new DataChannel.Buffer(
             ByteBuffer.wrap(new byte[] { 1, 2, 3, 4, 5 }), true)));
-    offeringExpectations.waitForAllExpectationsToBeSatisfied();
+    assertTrue(offeringExpectations.waitForAllExpectationsToBeSatisfied(TIMEOUT_SECONDS));
 
     offeringExpectations.expectStateChange(DataChannel.State.CLOSING);
     answeringExpectations.expectStateChange(DataChannel.State.CLOSING);
     offeringExpectations.expectStateChange(DataChannel.State.CLOSED);
     answeringExpectations.expectStateChange(DataChannel.State.CLOSED);
     answeringExpectations.dataChannel.close();
     offeringExpectations.dataChannel.close();
 
     if (RENDER_TO_GUI) {
       try {
@@ skipping 25 matching lines @@
     factory.dispose();
     System.gc();
   }
 
   private static void shutdownPC(
       PeerConnection pc, ObserverExpectations expectations) {
     expectations.dataChannel.unregisterObserver();
     expectations.dataChannel.dispose();
     expectations.expectStatsCallback();
     assertTrue(pc.getStats(expectations, null));
-    expectations.waitForAllExpectationsToBeSatisfied();
+    assertTrue(expectations.waitForAllExpectationsToBeSatisfied(TIMEOUT_SECONDS));
     expectations.expectIceConnectionChange(IceConnectionState.CLOSED);
     expectations.expectSignalingChange(SignalingState.CLOSED);
     pc.close();
-    expectations.waitForAllExpectationsToBeSatisfied();
+    assertTrue(expectations.waitForAllExpectationsToBeSatisfied(TIMEOUT_SECONDS));
     expectations.expectStatsCallback();
     assertTrue(pc.getStats(expectations, null));
-    expectations.waitForAllExpectationsToBeSatisfied();
+    assertTrue(expectations.waitForAllExpectationsToBeSatisfied(TIMEOUT_SECONDS));
 
     System.out.println("FYI stats: ");
     int reportIndex = -1;
     for (StatsReport[] reports : expectations.takeStatsReports()) {
       System.out.println(" Report #" + (++reportIndex));
       for (int i = 0; i < reports.length; ++i) {
         System.out.println("  " + reports[i].toString());
       }
     }
     assertEquals(1, reportIndex);
     System.out.println("End stats.");
 
     pc.dispose();
   }
 
   // Returns a set of thread IDs belonging to this process, as Strings.
   private static TreeSet<String> allThreads() {
     TreeSet<String> threads = new TreeSet<String>();
     // This pokes at /proc instead of using the Java APIs because we're also
     // looking for libjingle/webrtc native threads, most of which won't have
     // attached to the JVM.
     for (String threadId : (new File("/proc/self/task")).list()) {
       threads.add(threadId);
     }
     return threads;
   }
 }