/*
    * Copyright (C) 2011 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.testing;
  
  import com.google.common.testing.GcFinalization.FinalizationPredicate;
  import com.google.common.util.concurrent.SettableFuture;
  
  import junit.framework.TestCase;
  
  import java.lang.ref.WeakReference;
  import java.util.WeakHashMap;
  import java.util.concurrent.CountDownLatch;
  import java.util.concurrent.atomic.AtomicBoolean;
  
  /**
   * Tests for {@link GcFinalization}.
   *
   * @author Martin Buchholz
   * @author mike nonemacher
   */
  
  public class GcFinalizationTest extends TestCase {
  
    //----------------------------------------------------------------
    // Ordinary tests of successful method execution
    //----------------------------------------------------------------
  
    public void testAwait_CountDownLatch() {
      final CountDownLatch latch = new CountDownLatch(1);
      Object x = new Object() {
        @Override protected void finalize() { latch.countDown(); }
      };
      x = null;  // Hint to the JIT that x is unreachable
      GcFinalization.await(latch);
      assertEquals(0, latch.getCount());
    }
  
    public void testAwaitDone_Future() {
      final SettableFuture<Void> future = SettableFuture.create();
      Object x = new Object() {
        @Override protected void finalize() { future.set(null); }
      };
      x = null;  // Hint to the JIT that x is unreachable
      GcFinalization.awaitDone(future);
      assertTrue(future.isDone());
      assertFalse(future.isCancelled());
    }
  
    public void testAwaitDone_Future_Cancel() {
      final SettableFuture<Void> future = SettableFuture.create();
      Object x = new Object() {
        @Override protected void finalize() { future.cancel(false); }
      };
      x = null;  // Hint to the JIT that x is unreachable
      GcFinalization.awaitDone(future);
      assertTrue(future.isDone());
      assertTrue(future.isCancelled());
    }
  
    public void testAwaitClear() {
      final WeakReference<Object> ref = new WeakReference<Object>(new Object());
      GcFinalization.awaitClear(ref);
      assertNull(ref.get());
    }
  
    public void testAwaitDone_FinalizationPredicate() {
      final WeakHashMap<Object, Object> map = new WeakHashMap<Object, Object>();
      map.put(new Object(), Boolean.TRUE);
      GcFinalization.awaitDone(new FinalizationPredicate() {
        public boolean isDone() {
          return map.isEmpty();
        }
      });
      assertTrue(map.isEmpty());
    }
  
    //----------------------------------------------------------------
    // Test that interrupts result in RuntimeException, not InterruptedException.
    // Trickier than it looks, because runFinalization swallows interrupts.
    //----------------------------------------------------------------
  
    class Interruptenator extends Thread {
      final AtomicBoolean shutdown;
      Interruptenator(final Thread interruptee) {
        this(interruptee, new AtomicBoolean(false));
     }
     Interruptenator(final Thread interruptee,
                     final AtomicBoolean shutdown) {
       super(new Runnable() {
           public void run() {
             while (!shutdown.get()) {
               interruptee.interrupt();
               Thread.yield();
             }}});
       this.shutdown = shutdown;
       start();
     }
     void shutdown() {
       shutdown.set(true);
       while (this.isAlive()) {
         Thread.yield();
       }
     }
   }
 
   void assertWrapsInterruptedException(RuntimeException e) {
     assertTrue(e.getMessage().contains("Unexpected interrupt"));
     assertTrue(e.getCause() instanceof InterruptedException);
   }
 
   public void testAwait_CountDownLatch_Interrupted() {
     Interruptenator interruptenator = new Interruptenator(Thread.currentThread());
     try {
       final CountDownLatch latch = new CountDownLatch(1);
       try {
         GcFinalization.await(latch);
         fail("should throw");
       } catch (RuntimeException expected) {
         assertWrapsInterruptedException(expected);
       }
     } finally {
       interruptenator.shutdown();
       Thread.interrupted();
     }
   }
 
   public void testAwaitDone_Future_Interrupted_Interrupted() {
     Interruptenator interruptenator = new Interruptenator(Thread.currentThread());
     try {
       final SettableFuture<Void> future = SettableFuture.create();
       try {
         GcFinalization.awaitDone(future);
         fail("should throw");
       } catch (RuntimeException expected) {
         assertWrapsInterruptedException(expected);
       }
     } finally {
       interruptenator.shutdown();
       Thread.interrupted();
     }
   }
 
   public void testAwaitClear_Interrupted() {
     Interruptenator interruptenator = new Interruptenator(Thread.currentThread());
     try {
       final WeakReference<Object> ref = new WeakReference<Object>(Boolean.TRUE);
       try {
         GcFinalization.awaitClear(ref);
         fail("should throw");
       } catch (RuntimeException expected) {
         assertWrapsInterruptedException(expected);
       }
     } finally {
       interruptenator.shutdown();
       Thread.interrupted();
     }
   }
 
   public void testAwaitDone_FinalizationPredicate_Interrupted() {
     Interruptenator interruptenator = new Interruptenator(Thread.currentThread());
     try {
       try {
         GcFinalization.awaitDone(new FinalizationPredicate() {
             public boolean isDone() {
               return false;
             }
           });
         fail("should throw");
       } catch (RuntimeException expected) {
         assertWrapsInterruptedException(expected);
       }
     } finally {
       interruptenator.shutdown();
       Thread.interrupted();
     }
   }
 
   /**
    * awaitFullGc() is not quite as reliable a way to ensure calling of a
    * specific finalize method as the more direct await* methods, but should be
    * reliable enough in practice to avoid flakiness of this test.  (And if it
    * isn't, we'd like to know about it first!)
    */
   public void testAwaitFullGc() {
     final CountDownLatch finalizerRan = new CountDownLatch(1);
     final WeakReference<Object> ref = new WeakReference<Object>(
         new Object() {
           @Override protected void finalize() { finalizerRan.countDown(); }
         });
 
     // Don't copy this into your own test!
     // Use e.g. awaitClear or await(CountDownLatch) instead.
     GcFinalization.awaitFullGc();
 
     // If this test turns out to be flaky, add a second call to awaitFullGc()
     // GcFinalization.awaitFullGc();
 
     assertEquals(0, finalizerRan.getCount());
     assertNull(ref.get());
   }
 
 }