Version 0.6.17.4 .

dart/editor/tools/plugins/com.google.dart.tools.ui_test/src/com/google/dart/tools/ui/internal/text/dart/DartReconcilingStrategyTest.java

 /*
  * Copyright (c) 2013, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.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.eclipse.org/legal/epl-v10.html
  * 
  * 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
@@ skipping 28 matching lines @@
 import org.eclipse.jface.text.Document;
 import org.eclipse.jface.text.Region;
 import org.eclipse.jface.text.reconciler.DirtyRegion;
 import org.eclipse.swt.events.DisposeListener;
 import org.eclipse.swt.events.FocusListener;
 
 import java.io.File;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 
 public class DartReconcilingStrategyTest extends TestCase {
 
   /**
    * Content cache that can wait for contents to be set.
    * 
    * @see #expectSetContentsFor(Source)
    * @see #waitForSetContents(Source, long)
    */
@@ skipping 159 matching lines @@
       }
       priorityOrderLatch = null;
       return priorityOrder;
     }
   }
 
   /**
    * Mock editor for testing {@link DartReconcilingStrategy}
    */
   private final class MockEditor implements DartReconcilingEditor {
-    private CountDownLatch appliedLatch = null;
+    private Semaphore applied = null;
     private CompilationUnit appliedUnit = null;
     private DisposeListener disposeListener = null;
     private FocusListener focusListener = null;
 
     @Override
     public void addViewerDisposeListener(DisposeListener listener) {
       if (disposeListener != null) {
         throw new RuntimeException("dispose listener already added");
       }
       disposeListener = listener;
     }
 
     @Override
     public void addViewerFocusListener(FocusListener listener) {
       if (focusListener != null) {
         throw new RuntimeException("focus listener already added");
       }
       focusListener = listener;
     }
 
     @Override
     public void applyCompilationUnitElement(CompilationUnit unit) {
       appliedUnit = unit;
-      if (appliedLatch != null) {
-        appliedLatch.countDown();
+      if (applied != null) {
+        applied.release();
       }
     }
 
     public void expectApply() {
-      appliedLatch = new CountDownLatch(1);
+      applied = new Semaphore(0);
       appliedUnit = null;
     }
 
     public DisposeListener getDisposeListener() {
       return disposeListener;
     }
 
     @Override
     public AnalysisContext getInputAnalysisContext() {
       return mockContext;
     }
 
     @Override
     public Project getInputProject() {
       // TODO (danrubel): test null and non-null project
       return null;
     }
 
     @Override
     public Source getInputSource() {
       return mockSource;
     }
 
     @Override
     public String getTitle() {
       return mockSource.getShortName();
     }
 
-    public CompilationUnit waitForApply(long milliseconds, boolean expectAnother) {
-      if (appliedLatch == null) {
+    public CompilationUnit waitForApply(long milliseconds) {
+      if (applied == null) {
         throw new IllegalStateException("Call expectApply");
       }
       try {
-        assertTrue(appliedLatch.await(milliseconds, TimeUnit.MILLISECONDS));
+        assertTrue(applied.tryAcquire(milliseconds, TimeUnit.MILLISECONDS));
       } catch (InterruptedException e) {
-        assertEquals(0, appliedLatch.getCount());
+        assertTrue(applied.tryAcquire());
       }
-      appliedLatch = expectAnother ? new CountDownLatch(1) : null;
       return appliedUnit;
     }
   }
 
   private final static String EOL = System.getProperty("line.separator", "\n");
   private static final String INITIAL_CONTENTS = Joiner.on(EOL).join(//
       "library a;",
       "class A { foo() => 'two'; }");
 
   MockEditor mockEditor = new MockEditor();
@@ skipping 21 matching lines @@
   /**
    * Assert unit resolved, applied, and order set during initialReconcile
    */
   public void test_initialReconcile() {
     mockEditor.expectApply();
     mockContext.expectResolved(mockSource);
     mockContext.expectSetPriorityOrder();
 
     strategy.initialReconcile();
 
-    assertNotNull(mockEditor.waitForApply(5000, true));
+    assertNotNull(mockEditor.waitForApply(5000));
     CompilationUnit unit = mockContext.waitForResolution(mockSource, 5000);
     assertNotNull(unit);
-    assertSame(unit, mockEditor.waitForApply(5000, false));
-    List<Source> priorityOrder = mockContext.waitForSetPriorityOrder(5000);
+    unit = mockEditor.waitForApply(5000);
+    assertNotNull(unit);
+    List<Source> priorityOrder = mockContext.waitForSetPriorityOrder(15000);
     assertEquals(1, priorityOrder.size());
     assertSame(mockSource, priorityOrder.get(0));
     mockContext.assertPrioritySetBeforeBackgroundAnalysis();
   }
 
   /**
    * Assert unit resolved, applied, and order set during initialReconcile after AST has been removed
    * from the cache
    */
   public void test_initialReconcile_afterFlush() throws Exception {
     assertNotNull(mockContext.resolveCompilationUnit(mockSource, mockSource));
     mockContext.flushCompilationUnit(mockSource);
     assertNull(mockContext.getResolvedCompilationUnit(mockSource, mockSource));
 
     mockEditor.expectApply();
     mockContext.expectResolved(mockSource);
     mockContext.expectSetPriorityOrder();
 
     strategy.initialReconcile();
 
-    assertNotNull(mockEditor.waitForApply(5000, true));
+    assertNotNull(mockEditor.waitForApply(5000));
     CompilationUnit unit = mockContext.waitForResolution(mockSource, 5000);
     assertNotNull(unit);
-    assertSame(unit, mockEditor.waitForApply(5000, false));
-    List<Source> priorityOrder = mockContext.waitForSetPriorityOrder(5000);
+    unit = mockEditor.waitForApply(5000);
+    assertNotNull(unit);
+    List<Source> priorityOrder = mockContext.waitForSetPriorityOrder(15000);
     assertEquals(1, priorityOrder.size());
     assertSame(mockSource, priorityOrder.get(0));
     mockContext.assertPrioritySetBeforeBackgroundAnalysis();
   }
 
   /**
    * Assert unit resolved, applied, and order set during initialReconcile
    */
   public void test_initialReconcile_alreadyCached() throws Exception {
     CompilationUnit unit = mockContext.resolveCompilationUnit(mockSource, mockSource);
     assertNotNull(unit);
     mockEditor.expectApply();
     mockContext.expectResolved(mockSource);
     mockContext.expectSetPriorityOrder();
 
     strategy.initialReconcile();
 
-    assertSame(unit, mockEditor.waitForApply(5000, false));
+    assertSame(unit, mockEditor.waitForApply(5000));
     List<Source> priorityOrder = mockContext.waitForSetPriorityOrder(5000);
     assertEquals(1, priorityOrder.size());
     assertSame(mockSource, priorityOrder.get(0));
     mockContext.assertPrioritySetBeforeBackgroundAnalysis();
   }
 
   /**
    * Assert editor with no context does not throw exception
    */
   public void test_initialReconcile_nullContext() {
@@ skipping 15 matching lines @@
   }
 
   /**
    * Assert that a document change clears the cached unit and a resolve resets it
    */
   public void test_reconcileDirtyRegionIRegion() throws Exception {
     String newText = "//comment\n";
 
     mockEditor.expectApply();
     strategy.initialReconcile();
-    assertNotNull(mockEditor.waitForApply(5000, false));
+    assertNotNull(mockEditor.waitForApply(5000));
 
     mockEditor.expectApply();
     mockDocument.replace(0, 0, newText);
-    assertNull(mockEditor.waitForApply(5000, false));
+    assertNull(mockEditor.waitForApply(5000));
 
     mockEditor.expectApply();
     strategy.reconcile(new DirtyRegion(0, 0, DirtyRegion.INSERT, newText), new Region(0, 0));
-    CompilationUnit unit = mockEditor.waitForApply(5000, false);
+    CompilationUnit unit = mockEditor.waitForApply(5000);
     assertNotNull(unit);
   }
 
   /**
    * Assert editor with no context does not throw exception
    */
   public void test_reconcileDirtyRegionIRegion_nullContext() throws Exception {
     String newText = "//comment\n";
 
     mockContext = null;
     strategy.initialReconcile();
     mockDocument.replace(0, 0, newText);
     strategy.reconcile(new DirtyRegion(0, 0, DirtyRegion.INSERT, newText), new Region(0, 0));
 
     // test infrastructure asserts no exceptions
   }
 
   public void test_reconcileIRegion() throws Exception {
     String newText = "//comment\n";
 
     mockEditor.expectApply();
     strategy.initialReconcile();
-    assertNotNull(mockEditor.waitForApply(5000, false));
+    assertNotNull(mockEditor.waitForApply(5000));
 
     mockEditor.expectApply();
     mockDocument.replace(0, 0, newText);
-    assertNull(mockEditor.waitForApply(5000, false));
+    assertNull(mockEditor.waitForApply(5000));
 
     mockEditor.expectApply();
     strategy.reconcile(new Region(0, newText.length()));
-    CompilationUnit unit = mockEditor.waitForApply(5000, false);
+    CompilationUnit unit = mockEditor.waitForApply(5000);
     assertNotNull(unit);
   }
 
   /**
    * Assert editor with no context does not throw exception
    */
   public void test_reconcileIRegion_nullContext() throws Exception {
     String newText = "//comment\n";
 
     mockContext = null;
@@ skipping 17 matching lines @@
   }
 
   @Override
   protected void tearDown() throws Exception {
     // Ensure that strategy removes its AnalysisWorker listener
     if (strategy != null) {
       strategy.dispose();
     }
   }
 }