package net.sourceforge.jenesis4java.impl;
   
   /*
    * #%L
    * Jenesis 4 Java Code Generator
    * %%
    * Copyright (C) 2000 - 2016 jenesis4java
    * %%
    * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation, either version 3 of the
   * License, or (at your option) any later version.
   * 
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Lesser Public License for more details.
   * 
   * You should have received a copy of the GNU General Lesser Public
   * License along with this program.  If not, see
   * <http://www.gnu.org/licenses/lgpl-3.0.html>.
   * #L%
   */
  
  import net.sourceforge.jenesis4java.*;
  import net.sourceforge.jenesis4java.util.InstanceReplacingVisitor;
  import net.sourceforge.jenesis4java.util.StatementTestBase;
  import net.sourceforge.jenesis4java.util.WithVmAndMethod;
  import org.junit.Before;
  import org.junit.Test;
  import org.junit.experimental.runners.Enclosed;
  import org.junit.runner.RunWith;
  
  import static net.sourceforge.jenesis4java.util.Shortcuts.dummyClass;
  import static net.sourceforge.jenesis4java.util.TestHelper.LS;
  import static net.sourceforge.jenesis4java.util.TestHelper.vm;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertSame;
  
  @RunWith(Enclosed.class)
  public class SynchronizedTest {
  
      public static class Syntax extends WithVmAndMethod {
  
          @Test
          public void synchronizedBlock() {
              Synchronized synchronizedBlock = method.newSynchronized(vm().newFree("mutex"));
              assertEquals("synchronized (mutex) {" + LS + "}", synchronizedBlock.toString());
          }
  
      }
  
      public static class SettersAndGetters {
  
          private Synchronized synchronizedStmt;
  
          @Before
          public void setUp() {
              ClassMethod method = dummyClass().newMethod("method");
              synchronizedStmt = method.newSynchronized(vm().newFree("mutex"));
          }
  
          @Test
          public void setIsChainable() {
              Expression replacementMutex = vm().newFree("mutex");
              Synchronized aSynchronized = synchronizedStmt.setMutex(replacementMutex);
              assertSame(aSynchronized, synchronizedStmt);
          }
  
          @Test
          public void setAndGetMutex() {
              Expression replacementMutex = vm().newFree("mutex");
              synchronizedStmt.setMutex(replacementMutex);
              assertEquals(replacementMutex, synchronizedStmt.getMutex());
          }
  
      }
  
      public static class Visitors {
  
          @Test
          public void replaceMutex() {
              ClassMethod method = dummyClass().newMethod("method");
              Expression original = vm().newFree("mutex");
              Synchronized aSynchronized = method.newSynchronized(original);
              Expression replacement = vm().newFree("mutex");
              aSynchronized.visit(new InstanceReplacingVisitor(original, replacement));
              assertEquals(replacement, aSynchronized.getMutex());
          }
      }
  
      public static class InheritedFunctionality extends StatementTestBase {
  
          @Override
          public Statement getInstance() {
              return dummyClass().newMethod("method").newSynchronized(vm().newFree("xx"));
          }
      }
  }