/*
    * Copyright (C) 2010 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
    *
   * 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 or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.util.concurrent;
  
  import com.google.common.testing.NullPointerTester;
  import com.google.common.testing.TearDownStack;
  
  import junit.framework.TestCase;
  
  import java.util.Random;
  import java.util.concurrent.TimeUnit;
  
  /**
   * Tests for {@link Monitor}, either interruptible or uninterruptible.
   *
   * @author Justin T. Sampson
   */
  
  public abstract class MonitorTestCase extends TestCase {
  
    public class TestGuard extends Monitor.Guard {
      private volatile boolean satisfied;
  
      public TestGuard(boolean satisfied) {
        super(MonitorTestCase.this.monitor);
        this.satisfied = satisfied;
      }
  
      @Override public boolean isSatisfied() {
        return this.satisfied;
      }
  
      public void setSatisfied(boolean satisfied) {
        this.satisfied = satisfied;
      }
    }
  
    private final boolean interruptible;
    private Monitor monitor;
    private final TearDownStack tearDownStack = new TearDownStack(true);
    private TestThread<Monitor> thread1;
    private TestThread<Monitor> thread2;
  
    protected MonitorTestCase(boolean interruptible) {
      this.interruptible = interruptible;
    }
  
    @Override protected final void setUp() throws Exception {
      boolean fair = new Random().nextBoolean();
      monitor = new Monitor(fair);
      tearDownStack.addTearDown(thread1 = new TestThread<Monitor>(monitor, "TestThread #1"));
      tearDownStack.addTearDown(thread2 = new TestThread<Monitor>(monitor, "TestThread #2"));
    }
  
    @Override protected final void tearDown() {
      tearDownStack.runTearDown();
    }
  
    private String enter() {
      return interruptible ? "enterInterruptibly" : "enter";
    }
  
    private String tryEnter() {
      return "tryEnter";
    }
  
    private String enterIf() {
      return interruptible ? "enterIfInterruptibly" : "enterIf";
    }
  
    private String tryEnterIf() {
      return "tryEnterIf";
    }
  
    private String enterWhen() {
      return interruptible ? "enterWhen" : "enterWhenUninterruptibly";
    }
  
    private String waitFor() {
      return interruptible ? "waitFor" : "waitForUninterruptibly";
    }
  
    private String leave() {
      return "leave";
    }
 
   public final void testMutualExclusion() throws Exception {
     thread1.callAndAssertReturns(enter());
     thread2.callAndAssertBlocks(enter());
     thread1.callAndAssertReturns(leave());
     thread2.assertPriorCallReturns(enter());
   }
 
   public final void testTryEnter() throws Exception {
     thread1.callAndAssertReturns(true, tryEnter());
     thread2.callAndAssertReturns(false, tryEnter());
     thread1.callAndAssertReturns(true, tryEnter());
     thread2.callAndAssertReturns(false, tryEnter());
     thread1.callAndAssertReturns(leave());
     thread2.callAndAssertReturns(false, tryEnter());
     thread1.callAndAssertReturns(leave());
     thread2.callAndAssertReturns(true, tryEnter());
   }
 
   public final void testSystemStateMethods() throws Exception {
     checkSystemStateMethods(0);
     thread1.callAndAssertReturns(enter());
     checkSystemStateMethods(1);
     thread1.callAndAssertReturns(enter());
     checkSystemStateMethods(2);
     thread1.callAndAssertReturns(leave());
     checkSystemStateMethods(1);
     thread1.callAndAssertReturns(leave());
     checkSystemStateMethods(0);
   }
 
   private void checkSystemStateMethods(int enterCount) throws Exception {
     thread1.callAndAssertReturns(enterCount != 0, "isOccupied");
     thread1.callAndAssertReturns(enterCount != 0, "isOccupiedByCurrentThread");
     thread1.callAndAssertReturns(enterCount, "getOccupiedDepth");
 
     thread2.callAndAssertReturns(enterCount != 0, "isOccupied");
     thread2.callAndAssertReturns(false, "isOccupiedByCurrentThread");
     thread2.callAndAssertReturns(0, "getOccupiedDepth");
   }
 
   public final void testEnterWhen_initiallyTrue() throws Exception {
     TestGuard guard = new TestGuard(true);
     thread1.callAndAssertReturns(enterWhen(), guard);
   }
 
   public final void testEnterWhen_initiallyFalse() throws Exception {
     TestGuard guard = new TestGuard(false);
     thread1.callAndAssertWaits(enterWhen(), guard);
     monitor.enter();
     guard.setSatisfied(true);
     monitor.leave();
     thread1.assertPriorCallReturns(enterWhen());
   }
 
   public final void testEnterWhen_alreadyOccupied() throws Exception {
     TestGuard guard = new TestGuard(true);
     thread2.callAndAssertReturns(enter());
     thread1.callAndAssertBlocks(enterWhen(), guard);
     thread2.callAndAssertReturns(leave());
     thread1.assertPriorCallReturns(enterWhen());
   }
 
   public final void testEnterIf_initiallyTrue() throws Exception {
     TestGuard guard = new TestGuard(true);
     thread1.callAndAssertReturns(true, enterIf(), guard);
     thread2.callAndAssertBlocks(enter());
   }
 
   public final void testEnterIf_initiallyFalse() throws Exception {
     TestGuard guard = new TestGuard(false);
     thread1.callAndAssertReturns(false, enterIf(), guard);
     thread2.callAndAssertReturns(enter());
   }
 
   public final void testEnterIf_alreadyOccupied() throws Exception {
     TestGuard guard = new TestGuard(true);
     thread2.callAndAssertReturns(enter());
     thread1.callAndAssertBlocks(enterIf(), guard);
     thread2.callAndAssertReturns(leave());
     thread1.assertPriorCallReturns(true, enterIf());
   }
 
   public final void testTryEnterIf_initiallyTrue() throws Exception {
     TestGuard guard = new TestGuard(true);
     thread1.callAndAssertReturns(true, tryEnterIf(), guard);
     thread2.callAndAssertBlocks(enter());
   }
 
   public final void testTryEnterIf_initiallyFalse() throws Exception {
     TestGuard guard = new TestGuard(false);
     thread1.callAndAssertReturns(false, tryEnterIf(), guard);
     thread2.callAndAssertReturns(enter());
   }
 
   public final void testTryEnterIf_alreadyOccupied() throws Exception {
     TestGuard guard = new TestGuard(true);
     thread2.callAndAssertReturns(enter());
     thread1.callAndAssertReturns(false, tryEnterIf(), guard);
   }
 
   public final void testWaitFor_initiallyTrue() throws Exception {
     TestGuard guard = new TestGuard(true);
     thread1.callAndAssertReturns(enter());
     thread1.callAndAssertReturns(waitFor(), guard);
   }
 
   public final void testWaitFor_initiallyFalse() throws Exception {
     TestGuard guard = new TestGuard(false);
     thread1.callAndAssertReturns(enter());
     thread1.callAndAssertWaits(waitFor(), guard);
     monitor.enter();
     guard.setSatisfied(true);
     monitor.leave();
     thread1.assertPriorCallReturns(waitFor());
   }
 
   public final void testWaitFor_withoutEnter() throws Exception {
     TestGuard guard = new TestGuard(true);
     thread1.callAndAssertThrows(IllegalMonitorStateException.class, waitFor(), guard);
   }
 
   public void testNulls() {
     monitor.enter();  // Inhibit IllegalMonitorStateException
     new NullPointerTester()
         .setDefault(TimeUnit.class, TimeUnit.SECONDS)
         .setDefault(Monitor.Guard.class, new TestGuard(true))
         .testAllPublicInstanceMethods(monitor);
   }
 
   // TODO: Test enter(long, TimeUnit).
   // TODO: Test enterWhen(Guard, long, TimeUnit).
   // TODO: Test enterIf(Guard, long, TimeUnit).
   // TODO: Test waitFor(Guard, long, TimeUnit).
   // TODO: Test getQueueLength().
   // TODO: Test hasQueuedThreads().
   // TODO: Test getWaitQueueLength(Guard).
   // TODO: Test automatic signaling before leave, waitFor, and reentrant enterWhen.
   // TODO: Test blocking to re-enter monitor after being signaled.
   // TODO: Test interrupts with both interruptible and uninterruptible monitor.
   // TODO: Test multiple waiters: If guard is still satisfied, signal next waiter.
   // TODO: Test multiple waiters: If guard is no longer satisfied, do not signal next waiter.
 
 }