contestj-developer Mailing List for contestJ

Status: Inactive

Brought to you by: thomasra

contestj-developer — Developer discussion mailing list

You can subscribe to this list here.

2005	_Jan	_Feb	_Mar	_Apr	_May	_Jun	_Jul	_Aug	_Sep	_Oct (23)	_Nov	_Dec
2006	_Jan (6)	_Feb (43)	_Mar (20)	_Apr (12)	_May	_Jun	_Jul	_Aug	_Sep	_Oct	_Nov (2)	_Dec
2007	_Jan	_Feb	_Mar	_Apr	_May	_Jun (49)	_Jul	_Aug	_Sep	_Oct	_Nov	_Dec

Flat | Threaded

1 2 3 .. 7 > >> (Page 1 of 7)

[Contestj-developer] contestj/contestj2 - New directory

From: StÃ¥le P. <st...@us...> - 2007-06-20 15:10:20

Update of /cvsroot/contestj/contestj/contestj2
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv8182/contestj2

Log Message:
Directory /cvsroot/contestj/contestj/contestj2 added to the repository

[Contestj-developer] contestj/contestj2/src/main/java/org/contestj/duplicator MockInjector.java, NONE, 1.1 Duplicator.java, NONE, 1.1

From: StÃ¥le P. <st...@us...> - 2007-06-20 14:54:23

Update of /cvsroot/contestj/contestj/contestj2/src/main/java/org/contestj/duplicator
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv14426/contestj2/src/main/java/org/contestj/duplicator

Added Files:
	MockInjector.java Duplicator.java 
Log Message:
Initial upload of Contestj2
even though it supports most of the Contestj features its not ready to be used atm.

--- NEW FILE: Duplicator.java ---
package org.contestj.duplicator;

import java.io.IOException;

import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtField;
import javassist.CtMethod;
import javassist.CtNewMethod;
import javassist.CtPrimitiveType;
import javassist.Modifier;
import javassist.NotFoundException;

import org.apache.log4j.Logger;

public class Duplicator
{

   private static Logger log = Logger.getLogger(Duplicator.class.getName());
   
   private static String DUPLICATE = "_duplicate";
   
    /**
     * This method returns a duplicated object for use in runtime, using
     * javassist libraries for runtime bytecode manipulation. Send in an
     * instantiated class object or a class representing an interface and
     * get an instantiated object back, supporting the methods defined
     * in the class or interface for use in testing.
     * 
     * @param classOrInterface
     * @return
     */
    public static Object duplicate(String classOrInterface) {               
        
       if(doesDuplicateClassExist(classOrInterface)) {
           System.out.println("Duplicate already found in Classloader, using it...");
           return loadDuplicateObject(classOrInterface);
       }
         
       System.out.println("Duplicating " + classOrInterface + " (in-memory)");
       
        try {
            Class classOrInterfaceClass = Class.forName(classOrInterface);
            
            CtClass resultClass = null;
           
            // Split the responsibilities into two classes
            if(classOrInterfaceClass.isInterface() || Modifier.isAbstract(classOrInterfaceClass.getModifiers()) || classOrInterfaceClass.getName().equals("java.lang.Class")) {
                resultClass = duplicateInterface(classOrInterfaceClass);
            } 
            else
            {
               throw new RuntimeException("Can only duplicate interfaces");
            }
            
            //MockInjector.injectMock(resultClass);

           resultClass.writeFile("/tmp");
           
               return resultClass.toClass().newInstance();
           
        }  catch (ClassNotFoundException e) {
            throw new RuntimeException("Not found: " + e.getMessage());
        } catch (InstantiationException e) {
            throw new RuntimeException("Could not instantiate: " + e.getMessage());
        } catch (IllegalAccessException e) {
            throw new RuntimeException("Could not access: " + e.getMessage());
       } catch (IOException e) {
           throw new RuntimeException("I/O error: " + e.getMessage());
        } catch (CannotCompileException e) {
           throw new RuntimeException("Could not compile: " + e.getMessage());
       }
    }

    private static boolean doesDuplicateClassExist(String classOrInterface) {
        try {
          Class clazz = Class.forName(classOrInterface + DUPLICATE);
          return (clazz != null);
        }
        catch(ClassNotFoundException ce) {
          return false;
        }
        catch(Exception e) {
          log.error("Class.forName().. exception: "+classOrInterface + DUPLICATE, e);
          return false;
        }  
    }

    private static Object loadDuplicateObject(String classOrInterface) {
        try {
          Class dupe = Class.forName(classOrInterface + DUPLICATE);
          return dupe.newInstance();
        } catch(ClassNotFoundException ce) {
            throw new RuntimeException("Didnt find class: " + ce.getMessage());
        } catch(IllegalAccessException ie ) {
            throw new RuntimeException("Illegal access: " + ie.getMessage());
        } catch(InstantiationException ine ) {
            throw new RuntimeException("Instantiation error: " + ine.getMessage());
        } catch(ExceptionInInitializerError ee ) {
            throw new RuntimeException("Initialize error: " + ee.getMessage());
        } catch(SecurityException se ) {
            throw new RuntimeException("Security error: " + se.getMessage());
        }
    }
    
    private static CtClass duplicateInterface(Class interfaceObject ) { 
       ClassPool cPool = ClassPool.getDefault();
       try {
           String interfaceCopyName = interfaceObject.getName() + DUPLICATE;
           CtClass ctClass = cPool.makeClass(interfaceCopyName);
           CtClass ctInterface = cPool.get(interfaceObject.getName());
           if(ctInterface.isInterface()) {
               ctClass.addInterface(ctInterface);
           } else {
               ctClass.setSuperclass(ctInterface);
           }

           overrideReturningMethods(ctClass, ctInterface);
           
           return ctClass;
           
       } catch (NotFoundException e) {
           throw new RuntimeException("Not found: " + e.getMessage());
       } catch (CannotCompileException e) {
           throw new RuntimeException("Cannot compile: " + e.getMessage());
       }
       
   }
    
    private static void overrideReturningMethods(CtClass copy, CtClass original) {
       
       System.out.println("Overriding returning methods");
       
       CtMethod[] methodsOnClass = null;
       CtMethod[] methodsOnSuperclass = null;

       // Should we look for methods on the original (interface) or the copy (class)?
       if(original == null) {
           methodsOnClass = copy.getDeclaredMethods();
           methodsOnSuperclass = copy.getMethods();
       } else {
           methodsOnClass = original.getDeclaredMethods();
           methodsOnSuperclass = original.getMethods();
       }
           
       // Loop through all of the methods to find non-void methods
       for (int i = 0; i < methodsOnSuperclass.length; i++) {
           CtMethod method = methodsOnSuperclass[i];
           System.out.println("transforming method: "+method.toString());
           
           // Find the non-void methods
           try {

               CtClass returnType = method.getReturnType();
               CtClass[] parameterTypes = method.getParameterTypes();
               CtClass[] exceptionTypes = method.getExceptionTypes();
               String methodName = method.getName();
               

               if(!method.getDeclaringClass().getName().equals("java.lang.Object")) {
                                   
                   if(!method.getReturnType().equals(CtPrimitiveType.voidType)) { 
                       
                       System.out.println("Modifying main method body: " + method.getName());
                       if(original == null) {
                           if(methodExistsOnCopy(method.getName(), method, methodsOnClass)) {
                               System.out.println("Changing method: " + methodName);
                               //method.setBody(createAccessorBody(returnType, methodName));
                               method.setBody(createReturnBody(returnType));
                           } else {
                               System.out.println("Adding new method (override from super): " + method.getName());
                               CtMethod accessor = CtNewMethod.make(
                                       returnType, 
                                       method.getName(), 
                                       parameterTypes, 
                                       exceptionTypes,                             
                                      // createAccessorBody(returnType, methodName),
                                       createReturnBody(returnType),
                                       copy);
                                       
                               copy.addMethod(accessor);
                           }
                       } else {
                           System.out.println("Adding new method: " + method.getName());
                           try {
                           CtMethod accessor = CtNewMethod.make(
                                   returnType, 
                                   method.getName(), 
                                   parameterTypes, 
                                   exceptionTypes,                             
                                   //createAccessorBody(returnType, methodName),
                                   createReturnBody(returnType),
                                   copy);
                                   
                           copy.addMethod(accessor);
                           }
                           catch(Exception e)
                           {
                              System.out.println("Got exception when adding method "+method.getName()+" to class");
                              e.printStackTrace();
                           }
                           
                       }
                       
                   } 
                   else {
                     if(original == null) {
                       if(methodExistsOnCopy(method.getName(), method, methodsOnClass)) {
                         System.out.println("Changing void method: " + method.getName());
                         method.setBody("{ System.out.println(\"calling method: "+method.getName()+"\");}");
                       } else {
                         System.out.println("Adding void method (override from super): " + method.getName());
                         CtMethod voidMethod = CtNewMethod.make(returnType, 
                                                                method.getName(), 
                                                                parameterTypes, 
                                                                exceptionTypes,
                                                                "{ System.out.println(\"calling method: "+method.getName()+"\");}",
                                                                copy);

                         copy.addMethod(voidMethod);
                       }
                     } else {
                       System.out.println("Adding void method: " + method.getName());
                       CtMethod voidMethod = CtNewMethod.make(returnType, 
                                                              method.getName(), 
                                                              parameterTypes, 
                                                              exceptionTypes,                             
                                                              "{ System.out.println(\"calling method: "+method.getName()+"\");}",
                                                              copy);

                       copy.addMethod(voidMethod);

                     }
                   }
               }
               
           } catch (NotFoundException e) {
               throw new RuntimeException("Not found: " + e);
           } catch (CannotCompileException e) {
               throw new RuntimeException("Cannot compile: " + e);
           }

       }   

   }
    
    private static boolean methodExistsOnCopy(String methodName, CtMethod method, CtMethod[] methodsOnClass) {
       for (int i = 0; i < methodsOnClass.length; i++) {
           CtMethod m = methodsOnClass[i];
           try {
               if(m.getName().equals(methodName)) {                    
                   if(m.getParameterTypes().length == method.getParameterTypes().length) {
                                     
                       CtClass[] mParams = m.getParameterTypes();
                       CtClass[] methodParams = method.getParameterTypes();
                       
                       for(int j = 0;j < mParams.length;j++) {
                           if(!(mParams[j].getName().equals(methodParams[j].getName()))) {
                               continue;
                           }
                       }
                       
                       if(m.getReturnType().getName().equals(method.getReturnType().getName())) {
                           return true;
                       }

                   }
               }
               
           } catch(NotFoundException e) {
               return false;
           }
       }
       return false;
   }
    
    private static String createReturnBody(CtClass returnType)
    {
       StringBuffer buffer = new StringBuffer("return ");
       
       if(returnType.isPrimitive())
       {
          if(returnType.equals(CtClass.booleanType))
             buffer.append("false;");
          else
             buffer.append("0;");
       }
       else
       {
          if(returnType.getConstructors() != null && returnType.getConstructors().length > 0)
          buffer.append(" new ").append(returnType.getName()).append("();");
          else
             buffer.append(" null;");
       }
       
       return buffer.toString();
    }
   
}

--- NEW FILE: MockInjector.java ---
package org.contestj.duplicator;

import org.contestj.introduction.Mock;
import org.contestj.introduction.MockImpl;

import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtField;
import javassist.CtMethod;
import javassist.NotFoundException;

/**
 * MockInjector.
 * 
 * @author <a href="st...@gm...">Stale W. Pedersen</a>
 * @version $Revision: 1.1 $
 */
public class MockInjector
{

   public static CtClass injectMock(CtClass clazz)
   {
      CtClass mockInterface = getCtClass(Mock.class.getName());
      CtClass mockClass = getCtClass(MockImpl.class.getName());
      
      //clazz.addInterface(mockInterface);
      
      CtField[] mockFields = mockClass.getFields();
      try
      {
         for(CtField field : mockFields)
            clazz.addField(field);
      }
      catch (CannotCompileException e)
      {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }

      CtMethod[] mockMethods = mockClass.getMethods();
      try
      {
         for(CtMethod method : mockMethods)
         {
            System.out.println("adding method: "+method.getName());
            clazz.addMethod(method);
         }
      }
      catch (CannotCompileException e)
      {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }

      return clazz;
   }
   
   private static CtClass getCtClass(String name)
   {
      ClassPool cPool = ClassPool.getDefault();
      CtClass ctMock = null;
      try 
      {
         ctMock = cPool.get(name);
      }
      catch (NotFoundException e) {
         throw new RuntimeException("Not found: " + e.getMessage());
     } 
      return ctMock;
   }
}

[Contestj-developer] contestj/contestj2/src/test/conf/method method-aop.xml, NONE, 1.1

From: StÃ¥le P. <st...@us...> - 2007-06-20 14:54:22

Update of /cvsroot/contestj/contestj/contestj2/src/test/conf/method
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv14426/contestj2/src/test/conf/method

Added Files:
	method-aop.xml 
Log Message:
Initial upload of Contestj2
even though it supports most of the Contestj features its not ready to be used atm.

--- NEW FILE: method-aop.xml ---
<?xml version="1.0" encoding="UTF-8"?>
<aop>

  <bind pointcut="execution(public * org.contestj.test.mock.clazz.Bar->getData())">
     <interceptor class="org.contestj.interceptor.MockMethodInterceptor"/>
  </bind>

  <bind pointcut="execution(public * org.contestj.test.mock.clazz.Bar->getData2(int))">
     <interceptor class="org.contestj.interceptor.MockMethodInterceptor"/>
  </bind>

  <bind pointcut="execution(static * org.contestj.test.mock.clazz.Bar->getData3())">
     <interceptor class="org.contestj.interceptor.MockMethodInterceptor"/>
  </bind>
  
  <bind pointcut="execution(public * org.contestj.test.mock.clazz.Bar->doStuff())">
     <interceptor class="org.contestj.interceptor.MockMethodInterceptor"/>
  </bind>
  
  <bind pointcut="execution(public * org.contestj.test.mock.clazz.Bar->returnStuff(..))">
     <interceptor class="org.contestj.interceptor.MockMethodInterceptor"/>
  </bind>

</aop>

[Contestj-developer] contestj/contestj2/src/main/java/org/contestj/mockservice MockInvocationHandler.java, NONE, 1.1 MockService.java, NONE, 1.1 ContestJSetup.java, NONE, 1.1 MockMethod.java, NONE, 1.1

From: StÃ¥le P. <st...@us...> - 2007-06-20 14:54:22

Update of /cvsroot/contestj/contestj/contestj2/src/main/java/org/contestj/mockservice
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv14426/contestj2/src/main/java/org/contestj/mockservice

Added Files:
	MockInvocationHandler.java MockService.java ContestJSetup.java 
	MockMethod.java 
Log Message:
Initial upload of Contestj2
even though it supports most of the Contestj features its not ready to be used atm.

--- NEW FILE: MockMethod.java ---
package org.contestj.mockservice;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Iterator;

import org.apache.log4j.Logger;

/**
 * This class wraps a java.lang.reflect.Method object, and implements the
 * ability to set the desired return value etc.
 * 
 * Part of the contestJ test framework.
 * 
 * Distributed under the terms of the LGPL.
 * 
 * Copyright (C) 2005 Thomas Roka-Aardal
 * 
 * @author Thomas Roka-Aardal
 * 
 *
 */
public class MockMethod {

    private Method method = null;
    private Class originatingClass = null;
    private ArrayList returnValues = null;
    private ArrayList arguments = null;
    private RuntimeException exception = null;
    private long waitTime = 0L;
    private boolean timedOnly = false;
    private long timeToWait = 0L;

    private MockInvocationHandler invocationHandler;
    
    private Logger logger = Logger.getLogger(MockMethod.class);
    /**
     * This constructor is calls the other constructor for void methods (using
     * new Class[0] as the arguments).
     * 
     * @param originatingClass
     * @param method
     */
    public MockMethod(String originatingClass, String method) {
        
        this(originatingClass, method, new Class[0]);
        
    }
    
    /**
     * This constructor looks up the method on the class and initializes the local
     * variables.
     * 
     * @param originatingClass
     * @param method
     */
    public MockMethod(String originatingClass, String method, Class[] methodArguments) {
        
        try {
            this.originatingClass = Class.forName(originatingClass);
            this.method = this.originatingClass.getDeclaredMethod(method, methodArguments);
            returnValues = new ArrayList();
            arguments = new ArrayList();
        } catch (Exception e) {
            throw new RuntimeException("Could not define mock because of reflection errors: " + e);
        }
    }

    public MockMethod(String originatingClass, String method, Class[] methodArguments,
                      MockInvocationHandler invocation) {
      this(originatingClass, method, methodArguments);
      this.invocationHandler = invocation;
    }

    /**
     * This constructor takes Class and Method reflection objects
     * as arguments in order to be a lot more rigid and avoid errors
     * because of classes not found etc.
     * 
     * @param originatingClass
     * @param method
     */
    public MockMethod(String originatingClass, String method, long milliSeconds) {
        
        this(originatingClass, method);
        
        //set up the waiting time 
        this.waitTime = milliSeconds;
        
    }
    
    /**
     * Set up the return value for the invocation of the method. Note that
     * for this to be foolproof it needs to get in an object of the same type
     * as the original method, else you will get classcast exceptions.
     * 
     * @param returnValue
     */
    public void setupInvoke(Object returnValue) {
        returnValues.add(returnValue);
    }
    
    /**
     * Set up an exception to be thrown when the invoke method is called. If this
     * exception is not set (defaults to null) or set to null, it will not be used,
     * if it is anything other than null, it will always be thrown on invoke.
     * 
     * @param exception
     */
    public void setupInvokeException(RuntimeException exception) {
        this.exception = exception;
    }

    public Method getMethod() {
        return method;
    }
    
    public Class getOriginatingClass() {
        return originatingClass;
    }

    public MockInvocationHandler getInvocationHandler() {
      return invocationHandler;
    }

    public void setInvocationHandler(MockInvocationHandler invHandler) {
      invocationHandler = invHandler;
      logger.debug("Setting invocation handler to: "+invHandler.toString());
    }
    
    /**
     * Returns the first set up value or throws an exception (if the exception is not null)
     * 
     * Note that this method returns FIFO according to the setupInvoke methods that were added
     * at the back of the array.
     * 
     * @return
     */
    public Object invoke(Object[] argument) {
        if(waitTime > 0) {
           System.out.println("Waiting for: ."+waitTime);
            new WaitThread(waitTime).run();
        }   
        
        arguments.add(argument);
	        
        if(exception == null) {
            if(invocationHandler != null) {
                Object result = invocationHandler.invoke(argument);
                return result;
            }

            else {
                Iterator iter = returnValues.iterator();
                Object result = null;
                if (iter.hasNext()) {
                    result = iter.next();                
                }
                
                if(result == null && returnValues.size() == 0) {
                    throw new RuntimeException("setupInvoke was not configured with enough return values!");
                }
                
                returnValues.remove(0);
                System.out.println("Returning object: "+result.getClass().getName());
                
                return result;
            }
            
        }
        
        throw exception;
        
    }
    
    /**
     * This method returns the arguments that were passed to the mock method in the
     * order they were called.
     * 
     * @return
     */
    public Object getArgument() {
        
        if(arguments.size() == 0) {
            throw new RuntimeException("getArgument was invoked without more arguments!");
        }
        
        Iterator iter = arguments.iterator();
        Object argument = null;
        while(iter.hasNext()) {
            argument = iter.next();
        }

        arguments.remove(argument);
        return argument;
        
    }
    
    private class WaitThread extends Thread {
        
        private long waitTime;
        
        /* (non-Javadoc)
         * @see java.lang.Runnable#run()
         */
        public void run() {
            super.run();
            try {
                sleep(waitTime);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        public WaitThread(long milliSeconds) {
            this.waitTime = milliSeconds;
        }
        
        
        
    }

    public boolean isTimedOnly() {
    		return timedOnly;
    }
    
    public long getTimeToWait() {
    		return timeToWait;
    }
    
	public void setTimedOnly(boolean timedOnly, long timeToWait) {
		this.timedOnly = timedOnly;
		this.timeToWait = timeToWait;
	}
    
}

--- NEW FILE: MockService.java ---
/*
 * Created on Aug 3, 2004
 *
 * Copyright (C) 2004 Thomas Roka-Aardal
 */
package org.contestj.mockservice;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.apache.log4j.Logger;

/**
 * This class is a singleton that holds references to mocked classes and their
 * settings for use in a test environment. For more information, refer to
 * various articles on using AspectJ and MockObjects for unit testing.
 *
 * Part of the contestJ test framework.
 * 
 * Distributed under the terms of the LGPL.
 * 
 * Copyright (C) 2005 Thomas Roka-Aardal
 * 
 * @author Thomas Roka-Aardal
 * 
 *
 */
public class MockService {
    
    private Logger logger = Logger.getLogger(MockService.class);

    private static MockService instance = new MockService();
    
    private Map mockObjectReferences = null;
    private Map mockMethodReferences = null;
    
    protected MockService() {
        logger.debug("ContestJMockService initialized");
        mockObjectReferences = new Hashtable();
        mockMethodReferences = new Hashtable();
    }
    
    public static MockService getInstance() {
        return instance;
    }
 
    /**
     * Adds a mock method to the internal map, intended to be
     * used to mock both static and non-static methods.
     * 
     * It uses fully.qualified.classname::methodname as the key in
     * the private map.
     * 
     * @param mockMethod
     */
    public void addMockMethod(MockMethod mockMethod) {
        
        String classAndMethod = generateMethodKey(mockMethod.getOriginatingClass().getName(), mockMethod.getMethod().getName());
        
        logger.debug("ContestJMockService::addMockMethod adding mock for key: " + classAndMethod);
        
        mockMethodReferences.put(classAndMethod, mockMethod);
        
    }
    
    /**
     * 
     * @param mock
     */
    public void addMock(Object mock) {

        String className = mock.getClass().getSuperclass().getName();

        logger.debug("ContestJMockService::addMock adding mock for class: " + className);
        
        mockObjectReferences.put(className, mock);
        
    }
    
    
    /**
     * @return Mock objects in service
     */
    public Map getMocks() {
        return mockObjectReferences;
    }

    /**
     * @return Mock methods in service
     */
    public Map getMockMethods() {
        return mockMethodReferences;
    }

    /**
     * Prints mock object keys to System.out for debug purposes.
     */
    public void printMockObjectKeysToSystemOut() {
        String mocklist = "";
        Iterator iterKeys = mockObjectReferences.keySet().iterator();
        int counter = 0;
        while (iterKeys.hasNext()) {
            Object key = iterKeys.next();
            mocklist += "\"" + key + "\" ";
            counter++;
        }
        if (mocklist.equals("")) {
            System.out.println("[ContestJMockService] There are no keys for mock objects in ContestJMockService right now.");
        }
        else {
            System.out.println("[ContestJMockService] Keys (count=" + counter + ") for mock objects in ContestJMockService right now: " + mocklist);
        }
    }
    
    /**
     * Prints mock method keys to System.out for debug purposes.
     */
    public void printMockMethodKeysToSystemOut() {
        String mocklist = "";
        Iterator iterKeys = mockMethodReferences.keySet().iterator();
        int counter = 0;
        while (iterKeys.hasNext()) {
            Object key = iterKeys.next();
            mocklist += "\"" + key + "\" ";
            counter++;
        }
        if (mocklist.equals("")) {
            System.out.println("[ContestJMockService] There are no keys for mock methods in ContestJMockService right now.");
        }
        else {
            System.out.println("[ContestJMockService] Keys (count=" + counter + ") for mock methods in ContestJMockService right now: " + mocklist);
        }
    }
    
    
    /**
     * 
     * @param interfaceToMock
     * @return
     */
    public Object getMockForInterface(Class interfaceToMock) {

        logger.debug("ContestJMockService::getMockForInterface requesting mock for interface: " + interfaceToMock);
        
        Set keys = mockObjectReferences.keySet();
        
        for (Iterator iter = keys.iterator(); iter.hasNext();) {
            String element = (String) iter.next();
            logger.debug("ContestJMockService::getMockForInterface checking against registered mock: " + element);

            if(element.equals(interfaceToMock.getName())) {
                logger.debug("ContestJMockService::getMockForInterface found mock for interface: " + interfaceToMock);
                return mockObjectReferences.get(element);
            }
            
        }
        
        logger.debug("ContestJMockService::getMockForInterface didn't find mock for interface: " + interfaceToMock);        
        return null;
        
    }

    /**
     * This method checks the private method map to see if a certain method
     * is registered on the service. If it is, it is returned.
     * 
     * @param method
     * @return
     */
    public MockMethod getMockForMethod(String className, String methodName) {
        
        String keyToFind = generateMethodKey(className, methodName);
        
        System.out.println("ContestJMockService::getMockForMethod requesting mock for method: " + keyToFind);
        
        Set keys = mockMethodReferences.keySet();
        
        for (Iterator iter = keys.iterator(); iter.hasNext();) {
            String key = (String) iter.next();
            if(key.equals(keyToFind)) {
                logger.debug("ContestJMockService::getMockForMethod found mock for method: " + keyToFind);                
                return (MockMethod) mockMethodReferences.get(key);
            }
        }
        logger.debug("ContestJMockService::getMockForMethod didn't find mock for method: " + keyToFind);                
        return null;
    }
    
    /**
     * @param mockMethod
     * @return
     */
    private String generateMethodKey(String className, String methodName) {
        String classAndMethod = new StringBuffer().append(className)
        									.append("::")
        									.append(methodName)
        									.toString();
        return classAndMethod;
    }

    /**
     * Resets the mocks in the singleton
     *
     */
    public void reset() {
        
        logger.debug("ContestJMockService resetting values");
        mockMethodReferences.clear();
        mockObjectReferences.clear();
        
    }
    
}

--- NEW FILE: MockInvocationHandler.java ---
package org.contestj.mockservice;

/**
 * MockInvocationHandler.
 * 
 * @author <a href="st...@gm...">Stale W. Pedersen</a>
 * @version $Revision: 1.1 $
 */
public interface MockInvocationHandler {

  public Object invoke(Object[] o);

}

--- NEW FILE: ContestJSetup.java ---
package org.contestj.mockservice;

import org.contestj.introduction.Mock;

/**
 * A simple replacement of the original ContestJSetup.
 * 
 * @author <a href="st...@gm...">Stale W. Pedersen</a>
 * @version $Revision: 1.1 $
 */
public class ContestJSetup {

    /**
     * This method primes the mock method with a return value so that it returns expected
     * results. This will only work on classes thats already been duplicated by
     * Duplicator.
     * 
     * Note that for use with varargs in Java5 you need to tell this method that the arguments
     * are an array (because that is how the bytecode works). So if you have a method:
     * doStuff(String ... args)
     * ...you need to tell this method that the arguments are an array of strings (String[].class).
     * 
     * Multiple invocations on this method stacks return values.
     * 
     * @param instance
     * @param method
     * @param arguments
     * @param returnValue
     */
	public static void setup(Object instance, String method, Class[] arguments, Object returnValue) {
       if(arguments != null && arguments.length > 0)
       {
       ((Mock) instance).setupMock(method, arguments, returnValue);
       }
       else
       {
          ((Mock) instance).setupMock(method, returnValue);
       }
	}
	
    /**
     * This method primes the mock method with an exception value so that it returns expected
     * results.
     * 
     * Note that for use with varargs in Java5 you need to tell this method that the arguments
     * are an array (because that is how the bytecode works). So if you have a method:
     * doStuff(String ... args)
     * ...you need to tell this method that the arguments are an array of strings (String[].class).
     * 
     * 
     * @param method
     * @param arguments
     * @param exception
     */
	public static void setupException(Object instance, String method, Class[] arguments, Object exception) {
       if(arguments != null && arguments.length > 0)
       {
       ((Mock) instance).setupExceptionMock(method, arguments, new Exception(exception.toString()));
       }
       else
       {
          ((Mock) instance).setupExceptionMock(method, new Exception(exception.toString()));
       }
	}
    
}

[Contestj-developer] contestj/contestj2/src/main/java/org/contestj/annotation MockClass.java, NONE, 1.1

From: StÃ¥le P. <st...@us...> - 2007-06-20 14:54:20

Update of /cvsroot/contestj/contestj/contestj2/src/main/java/org/contestj/annotation
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv14426/contestj2/src/main/java/org/contestj/annotation

Added Files:
	MockClass.java 
Log Message:
Initial upload of Contestj2
even though it supports most of the Contestj features its not ready to be used atm.

--- NEW FILE: MockClass.java ---
package org.contestj.annotation;

/**
 * 
 * @author <a href="st...@gm...">Stale W. Pedersen</a>
 * @version $Revision: 1.1 $
 */
public @interface MockClass {

}

[Contestj-developer] contestj/contestj2/src/main/java/org/contestj/util Generator.java, NONE, 1.1

From: StÃ¥le P. <st...@us...> - 2007-06-20 14:54:20

Update of /cvsroot/contestj/contestj/contestj2/src/main/java/org/contestj/util
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv14426/contestj2/src/main/java/org/contestj/util

Added Files:
	Generator.java 
Log Message:
Initial upload of Contestj2
even though it supports most of the Contestj features its not ready to be used atm.

--- NEW FILE: Generator.java ---
package org.contestj.util;

public class Generator
{
   
   public static String generateMethodName(String method, Object[] params)
   {
      StringBuffer setupMethodName = new StringBuffer();
      setupMethodName.append(method);
      for (int i = 0; i < params.length; i++) {
          Class argument = params[i].getClass();
          setupMethodName.append("_");
          String simpleName = argument.getSimpleName();
          if(argument.isArray()) {
              simpleName = simpleName.replaceAll("\\[\\]", "Array");
          }
          setupMethodName.append(simpleName);
      }
      
      return setupMethodName.toString();
   }
   

}

[Contestj-developer] contestj/contestj2/src/test/conf mock-test-aop.xml, NONE, 1.1

From: StÃ¥le P. <st...@us...> - 2007-06-20 14:54:19

Update of /cvsroot/contestj/contestj/contestj2/src/test/conf
In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv14426/contestj2/src/test/conf

Added Files:
	mock-test-aop.xml 
Log Message:
Initial upload of Contestj2
even though it supports most of the Contestj features its not ready to be used atm.

--- NEW FILE: mock-test-aop.xml ---
<?xml version="1.0" encoding="UTF-8"?>
<aop>

  <!-- All classes thats fully mocked must be described like this.
       The only thing that need to be changed from class to class is
       class="path.to.class.and.classname" -->
  <introduction class="org.contestj.mock.simpleclass.Bar">
    <mixin>
      <interfaces>
          org.contestj.introduction.Mock
      </interfaces>
      <class>
          org.contestj.introduction.MockImpl	
      </class>
      <construction>
          new org.contestj.introduction.MockImpl(this)	
      </construction>
    </mixin>
  </introduction>

  <!-- add this for each class thats fully mocked, change the name for each class -->
  <pointcut name="bar" expr="execution(public * org.contestj.mock.simpleclass.Bar->*(..))"/>

  <!-- do not touch -->
  <pointcut name="mockMethods" expr="execution(public * *->getReturnObject(..))"/>
  <pointcut name="mockMethods2" expr="execution(public * *->setup(..))"/>

  <!-- for each fully mocked class you must add the pointcut to the end here.
       leave mockMethods and mockMethods2 be  
  -->
  <bind pointcut="!mockMethods AND !mockMethods2 AND bar">
     <interceptor class="org.contestj.interceptor.MockInterceptor"/>
  </bind>


  <!-- for each method thats mocked, add a line similar to this -->
  <bind pointcut="execution(public * org.contestj.mock.simpleclass.Foo->getBar())">
     <interceptor class="org.contestj.interceptor.MockMethodInterceptor"/>
  </bind>

  <bind pointcut="execution(public * org.contestj.mock.simpleclass.Bar->getData())">
     <interceptor class="org.contestj.interceptor.MockMethodInterceptor"/>
  </bind>


</aop>

[Contestj-developer] contestj/contestj2 pom.xml, NONE, 1.1 README, NONE, 1.1