/*
    * MIT License
    * Copyright (c) 2006-2025 JMockit developers
    * See LICENSE file for full license text.
    */
   package mockit;
   
   import static org.junit.jupiter.api.Assertions.assertEquals;
   import static org.junit.jupiter.api.Assertions.assertFalse;
  import static org.junit.jupiter.api.Assertions.assertNotNull;
  import static org.junit.jupiter.api.Assertions.assertNotSame;
  import static org.junit.jupiter.api.Assertions.assertSame;
  import static org.junit.jupiter.api.Assertions.assertTrue;
  
  import java.awt.BasicStroke;
  import java.io.Reader;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.concurrent.Callable;
  
  import org.junit.jupiter.api.Test;
  
  public final class MockUpForSingleClassInstanceTest {
      public static class AClass {
          final int numericValue;
          final String textValue;
  
          AClass(int n) {
              this(n, null);
          }
  
          AClass(int n, String s) {
              numericValue = n;
              textValue = s;
          }
  
          public final int getNumericValue() {
              return numericValue;
          }
  
          public String getTextValue() {
              return textValue;
          }
  
          protected final int getSomeOtherValue() {
              return 0;
          }
  
          public static boolean doSomething() {
              return false;
          }
      }
  
      @Test
      public void multipleMockupsOfSameTypeWithOwnMockInstanceEach() {
          final class AClassMockUp extends MockUp<AClass> {
              private final int number;
              private final String text;
  
              AClassMockUp(int number, String text) {
                  this.number = number;
                  this.text = text;
              }
  
              @Mock
              int getNumericValue() {
                  return number;
              }
  
              @Mock
              String getTextValue() {
                  return text;
              }
          }
  
          MockUp<AClass> mockUp1 = new AClassMockUp(1, "one");
          AClass mock1 = mockUp1.getMockInstance();
  
          AClassMockUp mockUp2 = new AClassMockUp(2, "two");
          AClass mock2 = mockUp2.getMockInstance();
  
          assertNotSame(mock1, mock2);
          assertEquals(1, mock1.getNumericValue());
          assertEquals("one", mock1.getTextValue());
          assertEquals(0, mock1.getSomeOtherValue());
          assertEquals(2, mock2.getNumericValue());
          assertEquals("two", mock2.getTextValue());
          assertEquals(0, mock2.getSomeOtherValue());
          assertEquals("two", mock2.getTextValue());
      }
  
      public static class AClassMockUp extends MockUp<BasicStroke> {
          private final int value;
  
          AClassMockUp(int value) {
              this.value = value;
          }
  
          @Mock
         public float getLineWidth() {
             return value;
         }
     }
 
     @Test
     public void samePublicMockupAppliedMultipleTimes() {
         BasicStroke mock1 = new AClassMockUp(1).getMockInstance();
         BasicStroke mock2 = new AClassMockUp(2).getMockInstance();
 
         assertNotSame(mock1, mock2);
         assertEquals(1, mock1.getLineWidth(), 0);
         assertEquals(2, mock2.getLineWidth(), 0);
     }
 
     @Test
     public void sameAnonymousMockupAppliedMultipleTimesWithDifferentTargetInstances() {
         List<BasicStroke> targetInstances = new ArrayList<>();
 
         for (int i = 1; i <= 2; i++) {
             final int width = 100 * i;
             BasicStroke targetInstance = new BasicStroke(i);
             new MockUp<BasicStroke>(targetInstance) {
                 @Mock
                 float getLineWidth() {
                     return width;
                 }
             };
             targetInstances.add(targetInstance);
         }
 
         assertEquals(100, targetInstances.get(0).getLineWidth(), 0);
         assertEquals(200, targetInstances.get(1).getLineWidth(), 0);
     }
 
     @Test
     public void sameAnonymousMockupAppliedMultipleTimesWithoutTargetInstanceButWithMockInstanceCreatedFromMockup() {
         List<BasicStroke> mockInstances = new ArrayList<>();
 
         for (int i = 1; i <= 2; i++) {
             final int width = 100 * i;
             BasicStroke mockInstance = new MockUp<BasicStroke>() {
                 @Mock
                 float getLineWidth() {
                     return width;
                 }
             }.getMockInstance();
             mockInstances.add(mockInstance);
         }
 
         assertEquals(100, mockInstances.get(0).getLineWidth(), 0);
         assertEquals(200, mockInstances.get(1).getLineWidth(), 0);
     }
 
     @Test
     public void getMockInstanceFromInsideMockMethodForNonStaticMockedMethod() {
         new MockUp<AClass>() {
             @Mock
             String getTextValue() {
                 assertNotNull(getMockInstance());
                 return "mock";
             }
         };
 
         assertEquals("mock", new AClass(123).getTextValue());
     }
 
     @Test
     public void mockupAffectingOneInstanceButNotOthersOfSameClass() {
         AClass instance1 = new AClass(1);
         AClass instance2 = new AClass(2);
 
         AClass mockInstance = new MockUp<AClass>(instance1) {
             @Mock
             int getNumericValue() {
                 return 3;
             }
         }.getMockInstance();
 
         assertSame(instance1, mockInstance);
         assertEquals(3, instance1.getNumericValue());
         assertEquals(2, instance2.getNumericValue());
         assertEquals(1, new AClass(1).getNumericValue());
     }
 
     @Test
     public void accessCurrentMockedInstanceFromInsideMockMethodForAnyInstanceOfTheMockedClass() {
         AClass instance1 = new AClass(1);
         AClass instance2 = new AClass(2, "test2");
 
         MockUp<AClass> mockUp = new MockUp<AClass>() {
             @Mock
             String getTextValue() {
                 AClass mockedInstance = getMockInstance();
                 return "mocked: " + mockedInstance.textValue;
             }
         };
 
         AClass instance3 = new AClass(3, "test3");
         assertEquals("mocked: null", instance1.getTextValue());
         assertEquals("mocked: test2", instance2.getTextValue());
         assertEquals("mocked: test3", instance3.getTextValue());
         assertSame(instance3, mockUp.getMockInstance());
     }
 
     @Test
     public void accessCurrentMockedInstanceFromInsideMockMethodForSingleMockedInstance() {
         AClass unmockedInstance1 = new AClass(1, "test1");
         final int i = 123;
 
         MockUp<AClass> mockUp = new MockUp<AClass>() {
             final int numericValue = i;
 
             @Mock
             String getTextValue() {
                 AClass mockedInstance = getMockInstance();
                 return "mocked: " + mockedInstance.textValue;
             }
 
             @Mock
             int getNumericValue() {
                 return numericValue;
             }
         };
         AClass onlyInstanceToBeMocked = mockUp.getMockInstance();
 
         assertEquals("test1", unmockedInstance1.getTextValue());
         AClass unmockedInstance2 = new AClass(2, "test2");
         assertEquals("mocked: null", onlyInstanceToBeMocked.getTextValue());
         assertEquals("test2", unmockedInstance2.getTextValue());
         assertSame(onlyInstanceToBeMocked, mockUp.getMockInstance());
     }
 
     static final class ASubClass extends AClass {
         ASubClass(int n, String s) {
             super(n, s);
         }
 
         @Override
         public String getTextValue() {
             return "subtext";
         }
     }
 
     @Test
     public void applyMockupWithGivenSubclassInstance() {
         AClass realInstance = new ASubClass(123, "test");
 
         MockUp<AClass> mockUp = new MockUp<AClass>(realInstance) {
             @Mock
             String getTextValue() {
                 return "mock";
             }
 
             @Mock
             int getSomeOtherValue() {
                 return 45;
             }
         };
 
         AClass mockInstance = mockUp.getMockInstance();
         assertSame(realInstance, mockInstance);
 
         assertEquals(123, realInstance.getNumericValue());
         assertEquals("mock", mockInstance.getTextValue());
         assertEquals(45, mockInstance.getSomeOtherValue());
     }
 
     public abstract static class AbstractBase implements Runnable {
         protected abstract String getValue();
 
         public abstract void doSomething(int i);
 
         public boolean doSomethingElse() {
             return true;
         }
     }
 
     @Test
     public void getMockInstanceFromMockupForAbstractClass() {
         MockUp<AbstractBase> mockUp = new MockUp<AbstractBase>() {
             @Mock
             String getValue() {
                 AbstractBase mockInstance = getMockInstance();
                 assertNotNull(mockInstance);
                 return "test";
             }
 
             @Mock
             boolean doSomethingElse() {
                 return false;
             }
         };
 
         AbstractBase mock = mockUp.getMockInstance();
 
         assertEquals("test", mock.getValue());
         mock.doSomething(123);
         mock.run();
         assertFalse(mock.doSomethingElse());
         assertSame(mock, mockUp.getMockInstance());
     }
 
     public abstract static class GenericAbstractBase<T, N extends Number> implements Callable<N> {
         protected abstract int doSomething(String s, T value);
     }
 
     @Test
     public void getMockInstanceFromMockupForAbstractJREClass() throws Exception {
         MockUp<Reader> mockUp = new MockUp<Reader>() {
             @Mock
             int read(char[] cbuf, int off, int len) {
                 Reader mockInstance = getMockInstance();
                 assertNotNull(mockInstance);
                 return 123;
             }
 
             @Mock
             boolean ready() {
                 return true;
             }
         };
 
         Reader mock = mockUp.getMockInstance();
 
         assertEquals(123, mock.read(new char[0], 0, 0));
         mock.close();
         assertTrue(mock.ready());
         assertSame(mock, mockUp.getMockInstance());
     }
 }