/* 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.AssertionFailedError;
  import junit.framework.TestCase;
  
  /***
   * Tests the MockMethod internals.
   * <p>
   * 
   * @author Per S Hustad
   */
  public class MockMethodTestCase extends TestCase {
  
      public MockMethodTestCase(String name) {
          super(name);
      }
  
      /***
       * Test MockMethod standard behavior
       */
      public void testStandardExecute() throws Throwable {
  
          MockMethod mockMethod = new MockMethod(TestClass01.class, "testCall",
                  new Class[] { String.class, Integer.TYPE });
  
          mockMethod.addReturnValue("1");
          mockMethod.addReturnValue("2");
          mockMethod.addExpectedParameters(new Object[] { "A", new Integer(1) });
          mockMethod.addExpectedParameters(new Object[] { "B", new Integer(2) });
          mockMethod.addExpectedParameters(new Object[] { "C", new Integer(3) });
  
          mockMethod.setExpectedCalls(2);
          Object testRet = mockMethod.execute(new Object[] { "A", new Integer(1) });
          assertEquals("1", testRet);
  
          // Too few calls
          try {
              mockMethod.verify();
              fail("Verify should fail  - not exact calls");
          } catch (AssertionFailedError e) {
          }
          testRet = mockMethod.execute(new Object[] { "B", new Integer(2) });
          assertEquals("2", testRet);
          mockMethod.verify();
          // Too many calls
          try {
              testRet = mockMethod.execute(new Object[] { "C", new Integer(3) });
              fail("Expected exception because called more than specified");
          } catch (AssertionFailedError e) {
          }
          // Wrong actual argument
          mockMethod.setExpectedCalls(3);
          try {
              testRet = mockMethod.execute(new Object[] { "WRONG", new Integer(3) });
              fail("Expected AssertionFailedError - wrong arguments");
          } catch (AssertionFailedError e) {
          }
          // Wrong number of expected arguments
          try {
              mockMethod.addExpectedParameters(new Object[] { "B" });
              fail("Expected an IllegalArgumentException - to few arguments");
          } catch (IllegalArgumentException e) {
  
          }
  
      }
  
      /***
       * Test MockMethod for method with no arguments and void return
       * 
       * @throws Throwable
      *             if TestCase error
      */
     public void testExecuteWithVoid() throws Throwable {
         MockMethod mockMethod = new MockMethod(TestClass01.class, "noArgsAndVoid");
         mockMethod.setExpectedCalls(1);
         mockMethod.execute(null);
         mockMethod.verify();
         mockMethod.reset();
 
         try {
             mockMethod.addReturnValue(new Object());
             fail("Expected an IllegalArgumentException - no return for void method");
         } catch (IllegalArgumentException e) {
 
         }
 
     }
 
     /***
      * Test wrong arguments to constructors
      * 
      * @throws Throwable
      */
     public void testConstructors() throws Throwable {
         // Correct
         new MockMethod(TestClass01.class, new Class[] { String.class, Integer.TYPE });
         new MockMethod(TestClass01.class, "testCall", new Class[] { String.class, Integer.TYPE });
         new MockMethod(OverloadedTestClass.class, new Class[] { String.class, Integer.TYPE });
         new MockMethod(OverloadedTestClass.class, new Class[] { String.class, Integer.TYPE, String.class });
         new MockMethod(OverloadedTestClass.class, "testCall", new Class[] { String.class, Integer.TYPE });
         new MockMethod(OverloadedTestClass.class, "testCall", new Class[] { String.class, Integer.TYPE, String.class });
 
         // Test with wrong args
         try {
             new MockMethod(TestClass01.class, "testCall", new Class[] { String.class, Integer.TYPE, String.class });
             fail("Expected NoSuchMethodException");
         } catch (NoSuchMethodException e) {
         }
 
         // Test with non-existing method
         try {
             new MockMethod(TestClass01.class, "testCallNOT_EXISTING", new Class[] { String.class, Integer.TYPE });
             fail("Expected NoSuchMethodException");
         } catch (NoSuchMethodException e) {
         }
         // Test overloaded class
         try {
             new MockMethod(OverloadedTestClass.class, "testCall");
             fail("Expected IllegalArgumentException");
         } catch (IllegalArgumentException e) {
         }
 
     }
 
     /***
      * Test the setMock method for Exceptions
      * 
      * @see MockMethod#addThrowableReturnValue(Throwable)
      */
     public void testAddThrowableReturnValue() throws Throwable {
 
         MockMethod mockMethod = new MockMethod(TestClass01.class, "noArgs");
         mockMethod.addReturnValue("1");
         mockMethod.addThrowableReturnValue(new TestException());
         mockMethod.addReturnValue("2");
         Object retVal = mockMethod.execute(null);
         assertEquals("1", retVal);
         try {
             mockMethod.execute(null);
             fail("expected a TestException");
         } catch (TestException e) {
         }
         retVal = mockMethod.execute(null);
         assertEquals("2", retVal);
     }
 
     private static class TestClass01 {
 
         private TestClass01(String a, int b) {
 
         }
 
         private String testCall(String a, int b) {
             return "OK";
         }
 
         private String noArgs() {
             return "OK";
         }
 
         private void noArgsAndVoid() {
 
         }
     }
 
     private static class OverloadedTestClass {
         private OverloadedTestClass(String a, int b) {
 
         }
 
         private OverloadedTestClass(String a, int b, String c) {
 
         }
 
         private String testCall(String a, int b) {
             return "OK";
         }
 
         private String testCall(String a, int b, String c) {
             return "OK";
         }
     }
 
     private static class TestException extends Exception {
 
     }
 
 }