package org.apidesign.gc;

 import java.lang.ref.Reference;

 import java.lang.ref.WeakReference;

 import org.junit.Test;

 import org.netbeans.junit.NbTestCase;

 import static org.junit.Assert.*;

 // BEGIN: compiler.surprises.intro

 public class CompilerSurprisesTest {

     Reference<String> cache;

     public String factory() {

         String value = new String("Can I disappear?");

         cache = new WeakReference<String>(value);

         return value;

     }

     @Test

     public void checkThatTheValueCanDisapper() {

         String retValue = factory();

         retValue = null;

         assertGC("Nobody holds the string value anymore." +

                 "It can be GCed.", cache);

     }

 // FINISH: compiler.surprises.intro

 // BEGIN: compiler.surprises.error

     @Test

     public void obviouslyWithoutClearingTheReferenceItCannotBeGCed() {

         String retValue = factory();

 // commented out:        retValue = null;

         assertNotGC("The reference is still on stack." +

                 "It cannot be GCed.", cache);

     }

 // END: compiler.surprises.error

 // BEGIN: compiler.surprises.surprise

     boolean yes = true;

     @Test

     public void canItBeGCedSurprisingly() {

         String retValue;

         if (yes) {

             retValue = factory();

         }

         assertGC("Can be GCed, as retValue is not on stack!!!!", cache);

     }

 // END: compiler.surprises.surprise

 // BEGIN: compiler.surprises.fix

     boolean ok = true;

     @Test

     public void canItBeGCedIfInitialized() {

         String retValue = null;

         if (ok) {

             retValue = factory();

         }

         assertNotGC("Cannot be GCed as retValue is not stack", cache);

     }

 // END: compiler.surprises.fix

 // BEGIN: compiler.surprises.fix.init

     @Test public void properInitializationFixesTheProblem() {

         String retValue;

         if (yes) {

             retValue = factory();

         } else {

             retValue = null;

         }

         assertNotGC("Cannot be GCed, now the retValue is on stack", cache);

     }

 // END: compiler.surprises.fix.init

 // BEGIN: compiler.surprises.fix.final

     @Test public void properUseOfFinalFixesTheProblem() {

         final String retValue;

         if (yes) {

             retValue = factory();

         } else {

             retValue = null;

         }

         assertNotGC("Cannot be GCed, now the retValue is on stack", cache);

     }

 // END: compiler.surprises.fix.final

 // BEGIN: compiler.surprises.scope

     @Test public void canItBeHeldByNoLongerExistingScopeSurprisingly() {

         {

             Object val = factory();

         }

         assertNotGC("Surprisingly this variable cannot be GCed, " +

                 "even val is out of scope!!!!", cache);

     }

 // END: compiler.surprises.scope

     private static void assertGC(String msg, Reference<?> ref) {

         NbTestCase.assertGC(msg, ref);

     }

     private static void assertNotGC(String msg, Reference<?> ref) {

         try {

             NbTestCase.assertGC("Cannot be GCed. " + msg, ref);

         } catch (Error ex) {

             // OK

             return;

         }

         fail(msg + ref.get());

     }

 }