/* Copyright (c) 2005 Per S Hustad. All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without 
    * modification, are permitted provided that the following conditions are met:
    *
    *  o Redistributions of source code must retain the above copyright notice, 
    *    this list of conditions and the following disclaimer. 
    *    
    *  o Redistributions in binary form must reproduce the above copyright notice, 
   *    this list of conditions and the following disclaimer in the documentation 
   *    and/or other materials provided with the distribution. 
   *    
   *  o Neither the name of surrogate.sourceforge.net nor the names of 
   *    its contributors may be used to endorse or promote products derived 
   *    from this software without specific prior written permission. 
   *    
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
   * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
   * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
   * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
   * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
   * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 
   * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package net.sf.surrogate.core;
  
  import junit.framework.TestCase;
  
  /***
   * Tests the SurrogateManager.
   * <p>
   * Note that this testCase will be woven by the test framwork so that it can
   * test that its own classes are "mocked" ! Keep this in mind when trying to
   * understand the code
   * 
   * @author Per S Hustad
   */
  public class SurrogateManagerTestCase extends TestCase {
  
      public SurrogateManagerTestCase(String name) {
          super(name);
      }
  
      /***
       * test the getMockObjectForInterface
       */
      public void testGetMockObject_ForInterface() throws Exception {
          SurrogateManager mm = SurrogateManager.getInstance();
          mm.reset();
          InterfaceToMockImp mI = new InterfaceToMockImp();
          mm.addMock(mI);
          Object mRet = mm.getMockObject(InterfaceToMock.class);
          assertEquals(mI, mRet);
          mm.reset();
          mRet = mm.getMockObject(InterfaceToMock.class);
          assertNull(mRet);
      }
  
      /***
       * test the getMockObjectForInterface
       */
      public void testGetMockObject_ForClass() throws Exception {
          SurrogateManager mm = SurrogateManager.getInstance();
          mm.reset();
          MockClassToMock mock = new MockClassToMock();
          mm.addMock(mock);
          Object mRet = mm.getMockObject(ClassToMock.class);
          assertEquals(mock, mRet);
          mm.reset();
          mRet = mm.getMockObject(ClassToMock.class);
          assertNull(mRet);
      }
  
      /***
       * Test basic AspectJ pointcut pcGetInterfaceOrClass interaction. In the
       * AspectJ file, we have defined a pointcut intercepting the calls to
       * "getInterfaceToMock"
       */
      public void testPcGetInterfaceOrClass() {
          SurrogateManager mm = SurrogateManager.getInstance();
          mm.reset();
          mm.addMock(new MockInterfaceToMock());
          InterfaceToMock it = (InterfaceToMock) new TestClass01().getInterfaceToMock();
          assertEquals("MOCK", it.getSomething("test"));
      }
  
      /***
       * This method is to test the difference between "call" and "execution"
       * pointcuts when the returned class is casted to another type. This method
       * MUST NOT be adviced
       * 
       * @return an ExtendedClassToMock
       */
      private ClassToMock getExtendedClassToMock_call() {
          return new ExtendedClassToMock();
 
     }
 
     /***
      * This method is to test the difference between "call" and "execution"
      * pointcuts when the returned class is casted to another type. This method
      * MUST be adviced
      * 
      * @return an ExtendedClassToMock
      */
     private ClassToMock getExtendedClassToMock_execution() {
         return new ExtendedClassToMock(); // AOP pointcut here !
     }
 
     /***
      * Test that if we register both a Mock Method and a mock object
      * corresponding to a poinctut, the MockMethod takes precedence
      * 
      * @throws Exception
      *             if unexpected failure
      */
     public void testSetMockMethodAndObject() throws Exception {
         SurrogateManager mm = SurrogateManager.getInstance();
         mm.reset();
         // first register a mock object
         MockInterfaceToMock mockInterfaceToMock = new MockInterfaceToMock();
         mm.addMock(mockInterfaceToMock);
         TestClass01 sub = new TestClass01();
         assertEquals("MOCK", sub.getInterfaceToMock().getSomething("hello"));
         // Then register a mockmethod and tell that method
         // to return a different mock class
         MockMethod mocktestCall01 = mm.addMockMethod(new MockMethod(TestClass01.class, "getInterfaceToMock"));
         mocktestCall01.setExpectedCalls(1);
         mocktestCall01.addReturnValue(new InterfaceToMock() {
             public String getSomething(String s) {
                 return "Setup by mockmethod";
             }
         });
         assertEquals("Setup by mockmethod", sub.getInterfaceToMock().getSomething("hello"));
         mocktestCall01.verify();
         // Then, remove the mock method and verify that the class is returned
         Object removedMethod = mm.removeMockMethod(mocktestCall01);
         assertEquals(mocktestCall01, removedMethod);
         assertEquals("MOCK", sub.getInterfaceToMock().getSomething("hello"));
         // Then remove the class and verify that "real" is returned
         Object removedMock = mm.removeMock(mockInterfaceToMock);
         assertEquals(mockInterfaceToMock, removedMock);
         assertEquals("REAL", sub.getInterfaceToMock().getSomething("hello"));
 
     }
 
     /***
      * Verifies that the SurrogateManager returns mocks corresponding to the
      * <b>signature </b> of the declared method in execution and call pointcuts.
      * I.e. when casting the class to another class, we might get a
      * ClassCastException
      * 
      * @throws Exception
      */
     public void testClassCastException() throws Exception {
         SurrogateManager mm = SurrogateManager.getInstance();
         mm.reset();
         MockClassToMock mockClassToMock = new MockClassToMock();
         MockExtendedClassToMock mockExtendedClassToMock = new MockExtendedClassToMock();
 
         // Verify that we get no ClassCastException - no mocks
         ExtendedClassToMock extendedClassToMock = (ExtendedClassToMock) getExtendedClassToMock_call(); // AOP
                                                                                                        // advice
                                                                                                        // here
                                                                                                        // !
         assertEquals("ExtendedClassToMock", extendedClassToMock.status);
         mm.addMock(mockClassToMock);
 
         // Check that casting of classes in a "call" pointcut is invariant. In
         // this
         // case, since the funtion actually returns a ExtendedClassToMock but
         // declares that
         // it returns a ClassToMock, the returned object will be MockClassToMock
         // but since we cast it to ExtendedClassToMock - we expect a
         // ClassCastException
         try {
             extendedClassToMock = (ExtendedClassToMock) getExtendedClassToMock_call(); // AOP
                                                                                        // advice
                                                                                        // here
                                                                                        // !
             fail("Expected ClassCastException");
         } catch (ClassCastException cce) {
         }
 
         ClassToMock classToMock = getExtendedClassToMock_call(); // AOP advice
                                                                  // here !
         assertEquals("MockClassToMock", classToMock.status);
 
         //   Check that casting of classes in a "execution" pointcut is invariant
         //   As in the case above, the method declares that it returns a
         // ClassToMock
         try {
             extendedClassToMock = (ExtendedClassToMock) getExtendedClassToMock_execution(); // AOP
                                                                                             // in
                                                                                             // method
                                                                                             // executing
             fail("Expected ClassCastException");
         } catch (ClassCastException cce) {
         }
 
         classToMock = getExtendedClassToMock_execution(); // AOP in method
                                                           // executing
         assertEquals("MockClassToMock", classToMock.status);
 
     }
 
     private static interface InterfaceToMock {
 
         public String getSomething(String s);
     }
 
     private static class MockInterfaceToMock implements InterfaceToMock {
 
         public String getSomething(String s) {
             return "MOCK";
         }
     }
 
     private static class InterfaceToMockImp implements InterfaceToMock {
 
         public String getSomething(String s) {
             return "REAL";
         }
     }
 
     private static class ClassToMock {
 
         public String status;
 
         public ClassToMock() {
             status = "ClassToMock";
         }
 
         public String getSomething(String s) {
             return s;
         }
     }
 
     private static class ExtendedClassToMock extends ClassToMock {
 
         public String status;
 
         public ExtendedClassToMock() {
             status = "ExtendedClassToMock";
         }
 
         public String getSomething(String s) {
             return s;
         }
 
         public void fooExtend() {
             ;
         }
     }
 
     private static class MockClassToMock extends ClassToMock {
 
         public String getSomething(String s) {
             return super.getSomething(s);
         }
 
         public MockClassToMock() {
             status = "MockClassToMock";
         }
 
         public String getStatus() {
             return status;
         }
     }
 
     private static class MockExtendedClassToMock extends ExtendedClassToMock {
 
         public String getSomething(String s) {
             return super.getSomething(s);
         }
 
         public MockExtendedClassToMock() {
             status = "MockExtendedClassToMock";
         }
 
         public String getStatus() {
             return status;
         }
     }
 
     private static class TestClass01 {
 
         //should be adviced in aspect
         public String testCall01(String a, String b) {
             return "OK";
         }
 
         //should be adviced
         public boolean isSomething() {
             return true;
         }
 
         // should be adviced
         public boolean isSomething(String arg1) {
             return true;
         }
 
         // should be adviced
         public InterfaceToMock getInterfaceToMock() {
             return new InterfaceToMockImp();
         }
 
     }
 
 }