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 at\n    "
+              + (new Throwable()).getStackTrace()[1] + "\n    for: "

[AlexG, 2015/09/25 18:49:25]

Why "[1]" here? May be use Throwable.printStackTrace() instead or print all
elements of the array.

[Taylor Brandstetter, 2015/09/25 19:44:03]

I assume because waitForAllExpectationsToBeSatisfied will always be called from
doTest, and we really just want to know which line of doTest we're on. The rest
of the stack should just be unit test infrastructure.

+              + 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;
   }
 }