JUnitCodeGenerator.java

/**
 * Copyright (C) 2010-2017 Gordon Fraser, Andrea Arcuri and EvoSuite
 * contributors
 *
 * This file is part of EvoSuite.
 *
 * EvoSuite 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.0 of the License, or
 * (at your option) any later version.
 *
 * EvoSuite 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
 * Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with EvoSuite. If not, see <http://www.gnu.org/licenses/>.
 */
package org.evosuite.testcarver.codegen;

import gnu.trove.list.array.TIntArrayList;
import gnu.trove.map.hash.TIntObjectHashMap;
import gnu.trove.set.hash.TIntHashSet;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Queue;
import java.util.Set;

import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ArrayAccess;
import org.eclipse.jdt.core.dom.ArrayCreation;
import org.eclipse.jdt.core.dom.ArrayInitializer;
import org.eclipse.jdt.core.dom.ArrayType;
import org.eclipse.jdt.core.dom.Assignment;
import org.eclipse.jdt.core.dom.Assignment.Operator;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.BooleanLiteral;
import org.eclipse.jdt.core.dom.CastExpression;
import org.eclipse.jdt.core.dom.CatchClause;
import org.eclipse.jdt.core.dom.CharacterLiteral;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.FieldAccess;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.ImportDeclaration;
import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodInvocation;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;
import org.eclipse.jdt.core.dom.Name;
import org.eclipse.jdt.core.dom.NormalAnnotation;
import org.eclipse.jdt.core.dom.PackageDeclaration;
import org.eclipse.jdt.core.dom.PrimitiveType;
import org.eclipse.jdt.core.dom.QualifiedType;
import org.eclipse.jdt.core.dom.ReturnStatement;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.SimpleType;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.Statement;
import org.eclipse.jdt.core.dom.StringLiteral;
import org.eclipse.jdt.core.dom.TryStatement;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.TypeLiteral;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
import org.evosuite.testcarver.capture.CaptureLog;
import org.evosuite.testcarver.capture.CaptureUtil;
import org.evosuite.utils.Utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;



public final class JUnitCodeGenerator implements ICodeGenerator<CompilationUnit>
{
	private static final Logger logger = LoggerFactory.getLogger(JUnitCodeGenerator.class);
	
	//--- source generation
	private final TIntObjectHashMap<String>   oidToVarMapping;
	private final TIntObjectHashMap<Class<?>> oidToTypeMapping;
	
	private int         varCounter;
	private TIntHashSet failedRecords;
	
	private boolean postprocessing;
	
	
	private boolean isNewInstanceMethodNeeded;
	private boolean isCallMethodMethodNeeded;
	private boolean isSetFieldMethodNeeded;
	private boolean isGetFieldMethodNeeded;
	private boolean isXStreamNeeded;
	
	
	private String cuName;
	private String packageName;
	
	public JUnitCodeGenerator(final String cuName, final String packageName)
	{
		if(cuName == null || cuName.isEmpty())
		{
			throw new IllegalArgumentException("Illegal compilation unit name: " + cuName);
		}
		
		if(packageName == null)
		{
			throw new NullPointerException("package name must not be null");
		}
		
		this.packageName = packageName;
		this.cuName = cuName;
		
		this.oidToVarMapping  = new TIntObjectHashMap<String>();
		this.oidToTypeMapping = new TIntObjectHashMap<Class<?>>();
		this.failedRecords    = new TIntHashSet();
		
		this.init();
	}

	
	private void init()
	{
		this.oidToVarMapping.clear();
		this.oidToTypeMapping.clear();
		this.failedRecords.clear();
		
		this.varCounter       = 0;
		
		this.postprocessing = false;
		
		this.isNewInstanceMethodNeeded = false;
		this.isCallMethodMethodNeeded  = false;
		this.isSetFieldMethodNeeded    = false;
		this.isGetFieldMethodNeeded    = false;
		this.isXStreamNeeded           = false;
	}
	
	public void enablePostProcessingCodeGeneration()
	{
		this.postprocessing = true;
	}
	
	public void disablePostProcessingCodeGeneration(final TIntArrayList failedRecords)
	{
		this.postprocessing = false;
		this.failedRecords.addAll(failedRecords);
	}
	
	
	

	private AST ast;
	private CompilationUnit cu;
	private Block methodBlock;
	TypeDeclaration td;
	
	@SuppressWarnings("unchecked")
	@Override
	public void before(CaptureLog log) {
		ast = AST.newAST(AST.JLS3);
		cu = ast.newCompilationUnit();

		// package declaration
		final PackageDeclaration p1 = ast.newPackageDeclaration();
		p1.setName(ast.newName(packageName.split("\\.")));
		cu.setPackage(p1);

		// import specifications
		ImportDeclaration id = ast.newImportDeclaration();
		id.setName(ast.newName(new String[] { "org", "junit", "Test" }));
		cu.imports().add(id);
		
		// class declaration
		td = ast.newTypeDeclaration();
		td.setName(ast.newSimpleName(cuName));
		td.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
		cu.types().add(td);
		

		
		// test method construction
		final MethodDeclaration md = ast.newMethodDeclaration();
		md.setName(ast.newSimpleName("test"));
		md.thrownExceptions().add(ast.newSimpleName("Exception"));

		
		
		// sets @Test annotation to test method
		final NormalAnnotation annotation = ast.newNormalAnnotation();
		annotation.setTypeName(ast.newSimpleName("Test"));
		md.modifiers().add(annotation);
		
		// sets method to public
		md.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD));
		td.bodyDeclarations().add(md);
		
		methodBlock = ast.newBlock();
		md.setBody(methodBlock);
		
	}





	@SuppressWarnings("unchecked")
	@Override
	public void after(CaptureLog log) 
	{
		if(this.isXStreamNeeded)
		{
			ImportDeclaration id = ast.newImportDeclaration();
			id.setName(ast.newName(new String[] { "com", "thoughtworks", "xstream", "XStream" }));
			cu.imports().add(id);
			
			// create XSTREAM constant: private static final XStream XSTREAM = new XStream();
			final VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
			vd.setName(ast.newSimpleName("XSTREAM"));			
			final ClassInstanceCreation ci = ast.newClassInstanceCreation();
			ci.setType(this.createAstType("XStream", ast));
			vd.setInitializer(ci);
			final FieldDeclaration xstreamConst = ast.newFieldDeclaration(vd);
			xstreamConst.setType(this.createAstType("XStream", ast));
			xstreamConst.modifiers().add(ast.newModifier(ModifierKeyword.PRIVATE_KEYWORD));
			xstreamConst.modifiers().add(ast.newModifier(ModifierKeyword.STATIC_KEYWORD));
			xstreamConst.modifiers().add(ast.newModifier(ModifierKeyword.FINAL_KEYWORD));
			td.bodyDeclarations().add(xstreamConst);
			
			this.isXStreamNeeded = false;
		}
		
		
		//-- creates utility method to set field value via reflections
		if(this.isSetFieldMethodNeeded)
		{
			this.createSetFieldMethod(td, cu, ast);
			this.isSetFieldMethodNeeded = false;
		}
		
		//-- creates utility method to get field value via reflections
		if(this.isGetFieldMethodNeeded)
		{
			this.createGetFieldMethod(td, cu, ast);
			this.isGetFieldMethodNeeded = false;
		}
		
		//-- creates utility method to call method via reflections
		if(this.isCallMethodMethodNeeded)
		{
			this.createCallMethod(td, cu, ast);
			this.isCallMethodMethodNeeded = false;
		}
		
		//-- creates utility method to call constructor via reflections
		if(this.isNewInstanceMethodNeeded)
		{
			this.createNewInstanceMethod(td, cu, ast);
			this.isNewInstanceMethodNeeded = false;
		}
	}



	@Override
	public CompilationUnit getCode() {
		return this.cu;
	}


	@Override
	public void clear() 
	{
		this.init();
	}

	private String createNewVarName(final int oid, final String typeName)
	{
		return this.createNewVarName(oid, typeName, false);
	}
	
	private String createNewVarName(final int oid, final String typeName, final boolean asObject)
	{
		if(this.oidToVarMapping.containsKey(oid))
		{
			throw new IllegalStateException("There is already an oid to var mapping for oid " + oid);
		}
		
//		try
//		{
			if(asObject)
			{
				this.oidToTypeMapping.put(oid, Object.class);
			}
			else
			{
				this.oidToTypeMapping.put(oid, getClassForName(typeName));
			}
//		}
//		catch(final ClassNotFoundException e)
//		{
//			throw new IllegalArgumentException(e);
//		}
//		
		
		final String varName = "var" + this.varCounter++;
		this.oidToVarMapping.put(oid, varName);
		
		return varName;
	}
	
	
	// TODO easy but inefficient implementation
	private Type createAstArrayType(final String type, final AST ast)
	{
		// NOTE: see asm4 guide p. 11 for more insights about internal type representation
		
		final int arrayDim = type.lastIndexOf('[') + 1;
		
		if(type.contains("[L")) 
		{
			// --- object array
			
			// TODO use regex for extraction
			
			String extractedType = type.substring(type.indexOf('L') + 1, type.length() - 1);
			extractedType        = extractedType.replaceFirst("java\\.lang\\.", "");
			extractedType        = extractedType.replace('$', '.');
			
			return ast.newArrayType(this.createAstType(extractedType, ast), arrayDim);
		}
		else
		{
			// --- primitive type array
			
			if(type.contains("[I")) // int[]
			{
				return ast.newArrayType(ast.newPrimitiveType(PrimitiveType.INT), arrayDim);
			}
			else if(type.contains("[B")) // byte[]
			{
				return ast.newArrayType(ast.newPrimitiveType(PrimitiveType.BYTE), arrayDim);
			}
			else if(type.contains("[C")) // char[]
			{
				return ast.newArrayType(ast.newPrimitiveType(PrimitiveType.CHAR), arrayDim);

			}
			else if(type.contains("[D")) // double[]
			{
				return ast.newArrayType(ast.newPrimitiveType(PrimitiveType.DOUBLE), arrayDim);
			}
			else if(type.contains("[Z")) // boolean[]
			{
				return ast.newArrayType(ast.newPrimitiveType(PrimitiveType.BOOLEAN), arrayDim);
			}
			else if(type.contains("[F")) // float[]
			{
				return ast.newArrayType(ast.newPrimitiveType(PrimitiveType.FLOAT), arrayDim);
			}
			else if(type.contains("[S")) // short[]
			{
				return ast.newArrayType(ast.newPrimitiveType(PrimitiveType.SHORT), arrayDim);
			}
			else if(type.contains("[J")) // long[]
			{
				return ast.newArrayType(ast.newPrimitiveType(PrimitiveType.LONG), arrayDim);
			}
			else
			{
				throw new RuntimeException("Can not create array type for " + type);
			}
		}
	}
	
	
	
	private Type createAstType(final String type, final AST ast)
	{
		if(type.startsWith("[")) // does type specify an array?
		{
			return this.createAstArrayType(type, ast);
		}
		else
		{
			final String[] fragments = type.split("\\.");
			if(fragments.length == 1)
			{
				if(fragments[0].contains("$"))
				{
					return ast.newSimpleType(ast.newName(fragments[0].replace('$', '.')));
				}
				else
				{
					return ast.newSimpleType(ast.newSimpleName(fragments[0]));
				}
			}
			
			if(type.startsWith("java.lang"))
			{
				return ast.newSimpleType(ast.newSimpleName(fragments[2]));
			}
			
			final String[] pkgArray = new String[fragments.length - 1];
			System.arraycopy(fragments, 0, pkgArray, 0, pkgArray.length);
			final SimpleType pkgType = ast.newSimpleType(ast.newName(pkgArray));
			
			final String clazzName = fragments[fragments.length - 1];
			if(clazzName.contains("$"))
			{
				final String[] clazzSplit = clazzName.split("\\$");
				
				final String[] newPkgType = new String[pkgArray.length + clazzSplit.length - 1];
				System.arraycopy(pkgArray,   0, newPkgType, 0,               pkgArray.length);
				System.arraycopy(clazzSplit, 0, newPkgType, pkgArray.length, clazzSplit.length - 1);

				if(clazzName.endsWith("[]"))
				{
					final QualifiedType t = ast.newQualifiedType(  ast.newSimpleType(ast.newName(newPkgType)), ast.newSimpleName(clazzSplit[clazzSplit.length - 1].replace("[]", "")));
					return ast.newArrayType(t);
				}
				else
				{
					return  ast.newQualifiedType(  ast.newSimpleType(ast.newName(newPkgType)), ast.newSimpleName(clazzSplit[clazzSplit.length - 1]));
				}
			}
			else
			{
		    	final String[] clazzSplit = clazzName.split("\\$");
				
				final String[] newPkgType = new String[pkgArray.length + clazzSplit.length - 1];
				System.arraycopy(pkgArray,   0, newPkgType, 0,               pkgArray.length);
				System.arraycopy(clazzSplit, 0, newPkgType, pkgArray.length, clazzSplit.length - 1);

				if(clazzName.endsWith("[]"))
				{
					final QualifiedType t = ast.newQualifiedType(  ast.newSimpleType(ast.newName(newPkgType)), ast.newSimpleName(clazzSplit[clazzSplit.length - 1].replace("[]", "")));
					return ast.newArrayType(t);
				}
				else
				{
					return  ast.newQualifiedType(  ast.newSimpleType(ast.newName(newPkgType)), ast.newSimpleName(clazzSplit[clazzSplit.length - 1]));
				}
			}
		}
	}
	
	
	/*
	 * Needed to preserve program flow: 
	 * 
	 * try
	 * {
	 *    var0.doSth();
	 * }
	 * catch(Throwable t) {}
	 */
	@SuppressWarnings("unchecked")
	private TryStatement createTryStmtWithEmptyCatch(final AST ast, Statement stmt)
	{
		final TryStatement tryStmt = ast.newTryStatement();
		tryStmt.getBody().statements().add(stmt);
		
		final CatchClause cc = ast.newCatchClause();
		SingleVariableDeclaration excDecl = ast.newSingleVariableDeclaration();
		excDecl.setType(ast.newSimpleType(ast.newSimpleName("Throwable")));
		excDecl.setName(ast.newSimpleName("t"));
		cc.setException(excDecl);
		tryStmt.catchClauses().add(cc);
		
		return tryStmt;
	}
	
	/*
	 * try
	 * {
	 *    var0.doSth();
	 * }
	 * catch(Throwable t)
	 * {
	 *    org.uni.saarland.sw.prototype.capture.PostProcessor.captureException(<logRecNo>);
	 * }
	 */
	@SuppressWarnings("unchecked")
	private TryStatement createTryStatementForPostProcessing(final AST ast, final Statement stmt, final int logRecNo)
	{
		final TryStatement     tryStmt = this.createTryStmtWithEmptyCatch(ast, stmt);
		final CatchClause      cc      = (CatchClause) tryStmt.catchClauses().get(0);
		final MethodInvocation m       = ast.newMethodInvocation();
		
		m.setExpression(ast.newName(new String[]{"org", "evosuite","testcarver","codegen", "PostProcessor"}));
		m.setName(ast.newSimpleName("captureException"));
		m.arguments().add(ast.newNumberLiteral(String.valueOf(logRecNo)));
		cc.getBody().statements().add(ast.newExpressionStatement(m));
		
		
		MethodInvocation m2 = ast.newMethodInvocation();
		m2.setExpression(ast.newSimpleName("t"));
		m2.setName(ast.newSimpleName("printStackTrace"));
		cc.getBody().statements().add(ast.newExpressionStatement(m2));
		
		return tryStmt;
	}
	
	
	
	
	@SuppressWarnings("unchecked")
	private MethodInvocation createCallMethodOrNewInstanceCallStmt(final boolean isConstructorCall, final AST ast, final String varName, final String targetTypeName, final String methodName, final Object[] methodArgs, final org.objectweb.asm.Type[] paramTypes)
	{
		//-- construct getField() call
		final MethodInvocation callMethodCall = ast.newMethodInvocation();
		
		if(isConstructorCall)
		{
			callMethodCall.setName(ast.newSimpleName("newInstance"));
		}
		else
		{
			callMethodCall.setName(ast.newSimpleName("callMethod"));
		}
		
		
		StringLiteral stringLiteral = ast.newStringLiteral();
		stringLiteral.setLiteralValue(targetTypeName);
		callMethodCall.arguments().add(stringLiteral);              // class name
		
		if(! isConstructorCall)
		{
			stringLiteral = ast.newStringLiteral();
			stringLiteral.setLiteralValue(methodName);
			callMethodCall.arguments().add(stringLiteral);              // method name
	
			if(varName == null)
			{
				callMethodCall.arguments().add(ast.newNullLiteral()); // static call -> no receiver
			}
			else
			{
				callMethodCall.arguments().add(ast.newSimpleName(varName)); // receiver
			}
		}
		
		// method arguments
		ArrayCreation arrCreation = ast.newArrayCreation();
		arrCreation.setType(ast.newArrayType(ast.newSimpleType(ast.newSimpleName("Object"))));
		ArrayInitializer arrInit = ast.newArrayInitializer();
		arrCreation.setInitializer(arrInit);
		callMethodCall.arguments().add(arrCreation);
		
		Integer  arg; // is either an oid or null
		for(int i = 0; i < methodArgs.length; i++)
		{
			arg = (Integer) methodArgs[i];
			if(arg == null)
			{
				arrInit.expressions().add(ast.newNullLiteral());
			}
			else
			{
				arrInit.expressions().add(ast.newSimpleName(this.oidToVarMapping.get(arg)));
			}
		}	
		
		
		// paramTypes
		arrCreation = ast.newArrayCreation();
		arrCreation.setType(ast.newArrayType(ast.newSimpleType(ast.newSimpleName("Class"))));
		arrInit = ast.newArrayInitializer();
		arrCreation.setInitializer(arrInit);
		callMethodCall.arguments().add(arrCreation);
		
		org.objectweb.asm.Type type;
		for(int i = 0; i < paramTypes.length; i++)
		{
			type = paramTypes[i];
			
			if(type.equals(org.objectweb.asm.Type.BOOLEAN_TYPE))
			{
				FieldAccess facc = ast.newFieldAccess();
				facc.setName(ast.newSimpleName("TYPE"));
				facc.setExpression(ast.newSimpleName("Boolean"));
				arrInit.expressions().add(facc);
			}
			else if(type.equals(org.objectweb.asm.Type.BYTE_TYPE))
			{
				FieldAccess facc = ast.newFieldAccess();
				facc.setName(ast.newSimpleName("TYPE"));
				facc.setExpression(ast.newSimpleName("Byte"));
				arrInit.expressions().add(facc);
			}
			else if(type.equals(org.objectweb.asm.Type.CHAR_TYPE))
			{
				FieldAccess facc = ast.newFieldAccess();
				facc.setName(ast.newSimpleName("TYPE"));
				facc.setExpression(ast.newSimpleName("Character"));
				arrInit.expressions().add(facc);
			}
			else if(type.equals(org.objectweb.asm.Type.DOUBLE_TYPE))
			{
				FieldAccess facc = ast.newFieldAccess();
				facc.setName(ast.newSimpleName("TYPE"));
				facc.setExpression(ast.newSimpleName("Double"));
				arrInit.expressions().add(facc);
			}
			else if(type.equals(org.objectweb.asm.Type.FLOAT_TYPE))
			{
				FieldAccess facc = ast.newFieldAccess();
				facc.setName(ast.newSimpleName("TYPE"));
				facc.setExpression(ast.newSimpleName("Float"));
				arrInit.expressions().add(facc);
			}
			else if(type.equals(org.objectweb.asm.Type.INT_TYPE))
			{
				FieldAccess facc = ast.newFieldAccess();
				facc.setName(ast.newSimpleName("TYPE"));
				facc.setExpression(ast.newSimpleName("Integer"));
				arrInit.expressions().add(facc);
			}
			else if(type.equals(org.objectweb.asm.Type.LONG_TYPE))
			{
				FieldAccess facc = ast.newFieldAccess();
				facc.setName(ast.newSimpleName("TYPE"));
				facc.setExpression(ast.newSimpleName("Long"));
				arrInit.expressions().add(facc);
			}
			else if(type.equals(org.objectweb.asm.Type.SHORT_TYPE))
			{
				FieldAccess facc = ast.newFieldAccess();
				facc.setName(ast.newSimpleName("TYPE"));
				facc.setExpression(ast.newSimpleName("Short"));
				arrInit.expressions().add(facc);
			}
			else
			{
				final TypeLiteral clazz = ast.newTypeLiteral();
				clazz.setType(ast.newSimpleType(ast.newName(type.getClassName())));

				arrInit.expressions().add(clazz);
			}
		}	
		
		return callMethodCall;
	}
	
	
	
	
	
	/* (non-Javadoc)
	 * @see org.evosuite.testcarver.codegen.ICodeGenerator#createMethodCallStmt(org.evosuite.testcarver.capture.CaptureLog, int)
	 */
	@SuppressWarnings("unchecked")
	@Override
	public void createMethodCallStmt(CaptureLog log, int logRecNo) 
	{
		PostProcessor.notifyRecentlyProcessedLogRecNo(logRecNo);
		
		// assumption: all necessary statements are created and there is one variable for reach referenced object
		final int      oid        = log.objectIds.get(logRecNo);
	    Object[] methodArgs = log.params.get(logRecNo);
		final String   methodName = log.methodNames.get(logRecNo);
		
		
		final  String                   methodDesc       = log.descList.get(logRecNo);
		org.objectweb.asm.Type[] methodParamTypes = org.objectweb.asm.Type.getArgumentTypes(methodDesc);
		
		Class<?>[] methodParamTypeClasses = new Class[methodParamTypes.length];
		for(int i = 0; i < methodParamTypes.length; i++)
		{
			methodParamTypeClasses[i] = getClassForName(methodParamTypes[i].getClassName());
		}
		
		final String  typeName  = log.oidClassNames.get(log.oidRecMapping.get(oid));
		Class<?> type = getClassForName(typeName);
		
		final boolean haveSamePackage = type.getPackage().getName().equals(packageName); // TODO might be nicer...
		
		
		final Statement finalStmt;
		
		@SuppressWarnings("rawtypes")
		final List arguments;
		if(CaptureLog.OBSERVED_INIT.equals(methodName))
		{
			/*
			 * Person var0 = null;
			 * {
			 *    var0 = new Person();
			 * }
			 * catch(Throwable t)
			 * {
			 *    org.uni.saarland.sw.prototype.capture.PostProcessor.captureException(<logRecNo>);
			 * }
			 */
			
			
			// e.g. Person var0 = null;
			final String varName = this.createNewVarName(oid, typeName);
			VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
			vd.setName(ast.newSimpleName(varName));			
			VariableDeclarationStatement stmt = ast.newVariableDeclarationStatement(vd);
			stmt.setType(this.createAstType(typeName, ast));
			vd.setInitializer(ast.newNullLiteral());
			methodBlock.statements().add(stmt);	
			
			//FIXME this does not make any sense
			try
			{
				this.getConstructorModifiers(type,methodParamTypeClasses);
			}
			catch(Exception e)
			{
				logger.error(""+e,e);
			}
			
			final int     constructorTypeModifiers = this.getConstructorModifiers(type,methodParamTypeClasses);
			final boolean isPublic                 = java.lang.reflect.Modifier.isPublic(constructorTypeModifiers);
			final boolean isReflectionAccessNeeded = ! isPublic && ! haveSamePackage;
			
			if(isReflectionAccessNeeded)
			{
				this.isNewInstanceMethodNeeded = true;
				final MethodInvocation mi	   = this.createCallMethodOrNewInstanceCallStmt(true, ast, varName, typeName, methodName, methodArgs, methodParamTypes);
				arguments 				  	   = null;
				
				final Assignment assignment = ast.newAssignment();
				assignment.setLeftHandSide(ast.newSimpleName(varName));
				assignment.setOperator(Operator.ASSIGN);
				
				final CastExpression cast = ast.newCastExpression();
				cast.setType(this.createAstType(typeName, ast));
				cast.setExpression(mi);
				assignment.setRightHandSide(cast);
				
				finalStmt = ast.newExpressionStatement(assignment);
			}
			else
			{
				// e.g. var0 = new Person();
				final ClassInstanceCreation ci = ast.newClassInstanceCreation();
								
				final int recNo         = log.oidRecMapping.get(oid);
				final int dependencyOID = log.dependencies.getQuick(recNo);
				
				if(dependencyOID == CaptureLog.NO_DEPENDENCY)
				{
					ci.setType(this.createAstType(typeName, ast));
				}
				else
				{
//					final String varTypeName = oidToVarMapping.get(dependencyOID) + "." + typeName.substring(typeName.indexOf('$') + 1);
//					ci.setType(this.createAstType(varTypeName, ast));
					/*
					 * e.g.
					 * OuterClass.InnerClass innerObject = outerObject.new InnerClass();
					 */
					ci.setType(this.createAstType(typeName.substring(typeName.indexOf('$') + 1), ast));
					ci.setExpression(ast.newSimpleName(oidToVarMapping.get(dependencyOID)));
										
					final int index = Arrays.binarySearch(methodArgs, dependencyOID);
					
					if(index > -1)
					{
						logger.debug(varName + " xxxx3 " + index);
						
						final Object[] newArgs = new Object[methodArgs.length - 1];
						System.arraycopy(methodArgs, 0,         newArgs, 0,     index);
						System.arraycopy(methodArgs, index + 1, newArgs, index, methodArgs.length - index - 1);
						methodArgs = newArgs;
						
						
						final Class<?>[] newParamTypeClasses = new Class<?>[methodParamTypeClasses.length - 1]; 
						System.arraycopy(methodParamTypeClasses, 0,         newParamTypeClasses, 0,     index);
						System.arraycopy(methodParamTypeClasses, index + 1, newParamTypeClasses, index, methodParamTypeClasses.length - index - 1);
						methodParamTypeClasses = newParamTypeClasses;
						
						
						final org.objectweb.asm.Type[] newParamTypes = new org.objectweb.asm.Type[methodParamTypes.length - 1]; 
						System.arraycopy(methodParamTypes, 0,         newParamTypes, 0,     index);
						System.arraycopy(methodParamTypes, index + 1, newParamTypes, index, methodParamTypes.length - index - 1);
						methodParamTypes = newParamTypes;
					}
				}
				
				final Assignment assignment = ast.newAssignment();
				assignment.setLeftHandSide(ast.newSimpleName(varName));
				assignment.setOperator(Operator.ASSIGN);
				assignment.setRightHandSide(ci);
				
				finalStmt = ast.newExpressionStatement(assignment);
				arguments = ci.arguments();
			}
		}
		else //------------------ handling for ordinary method calls e.g. var1 = var0.doSth();
		{
			String returnVarName = null;
			
			final String desc       = log.descList.get(logRecNo);
			final String returnType = org.objectweb.asm.Type.getReturnType(desc).getClassName();
			
			
			final Object returnValue = log.returnValues.get(logRecNo);
			if(! CaptureLog.RETURN_TYPE_VOID.equals(returnValue))
			{
				Integer returnValueOID = (Integer) returnValue;
				
				// e.g. Person var0 = null;
				returnVarName = this.createNewVarName(returnValueOID, returnType);

				
				VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
				vd.setName(ast.newSimpleName(returnVarName));			
				VariableDeclarationStatement stmt = ast.newVariableDeclarationStatement(vd);
				stmt.setType(this.createAstType(returnType, ast));
				vd.setInitializer(ast.newNullLiteral());
				methodBlock.statements().add(stmt);	
			}

			
			final String  varName                  = this.oidToVarMapping.get(oid);
			final int     methodTypeModifiers      = this.getMethodModifiers(type, methodName, methodParamTypeClasses);
			final boolean isPublic                 = java.lang.reflect.Modifier.isPublic(methodTypeModifiers);
			final boolean isReflectionAccessNeeded = ! isPublic && ! haveSamePackage;
			
			// e.g. Person var0 = var1.getPerson("Ben");
			
			final MethodInvocation mi;
			
			if(isReflectionAccessNeeded)
			{
				this.isCallMethodMethodNeeded = true;
				mi                            = this.createCallMethodOrNewInstanceCallStmt(false, ast, varName, typeName, methodName, methodArgs, methodParamTypes);
				arguments                     = null;
				
				if(returnVarName != null)
				{
					final Assignment assignment = ast.newAssignment();
					assignment.setLeftHandSide(ast.newSimpleName(returnVarName));
					assignment.setOperator(Operator.ASSIGN);
					
					final CastExpression cast = ast.newCastExpression();
					cast.setType(this.createAstType(returnType, ast));
					cast.setExpression(mi);
					assignment.setRightHandSide(cast);
					
					finalStmt = ast.newExpressionStatement(assignment);
				}
				else
				{
					finalStmt = ast.newExpressionStatement(mi);
				}
			}	
			else
			{
			    mi = ast.newMethodInvocation();
				 
				if( log.isStaticCallList.get(logRecNo)) 
				{
					// can only happen, if this is a static method call (because constructor statement has been reported)
					final String tmpType = log.oidClassNames.get(log.oidRecMapping.get(oid));
					mi.setExpression(ast.newName(tmpType.split("\\.")));
				}
				else
				{
					try
					{
						mi.setExpression(ast.newSimpleName(varName));	
					}
					catch(final IllegalArgumentException ex)
					{

						String msg = "";

						msg += "--recno-- " + logRecNo + "\n";
						msg += "--oid-- " + oid + "\n";
						msg += "--method-- " + methodName + "\n";
						msg += "--varName-- " + varName + "\n";
						msg += "--oidToVarMap-- " +  this.oidToVarMapping + "\n";										
						msg += (log) + "\n";
						
						logger.error(msg);
						throw new RuntimeException(msg);
					}
				}
				
				mi.setName(ast.newSimpleName(methodName));
				
				
				arguments = mi.arguments();
				
				if(returnVarName != null)
				{
					final Assignment assignment = ast.newAssignment();
					assignment.setLeftHandSide(ast.newSimpleName(returnVarName));
					assignment.setOperator(Operator.ASSIGN);
					assignment.setRightHandSide(mi);
					
					finalStmt = ast.newExpressionStatement(assignment);
				}
				else
				{
					finalStmt = ast.newExpressionStatement(mi);
				}
			}
		}
		
		if(postprocessing)
		{
			final TryStatement tryStmt = this.createTryStatementForPostProcessing(ast, finalStmt, logRecNo);
			methodBlock.statements().add(tryStmt);
		}
		else
		{
			if(this.failedRecords.contains(logRecNo))
			{
				// we just need an empty catch block to preserve program flow
				final TryStatement tryStmt = this.createTryStmtWithEmptyCatch(ast, finalStmt);
				methodBlock.statements().add(tryStmt);
			}
			else
			{
				 methodBlock.statements().add(finalStmt);	
			}
		}
		
		
		if(arguments != null)
		{
			Class<?> methodParamType;
			Class<?> argType;
			
			Integer  arg; // is either an oid or null
			for(int i = 0; i < methodArgs.length; i++)
			{
				arg = (Integer) methodArgs[i];
				if(arg == null)
				{
					arguments.add(ast.newNullLiteral());
				}
				else
				{
					methodParamType = CaptureUtil.getClassFromDesc(methodParamTypes[i].getDescriptor());
					argType			= this.oidToTypeMapping.get(arg);
							
					// TODO: Warten was Florian und Gordon dazu sagen. Siehe Mail 04.08.2012
					if(argType == null)
					{
						logger.error("Call within constructor needs instance of enclosing object as parameter -> ignored: " + arg);
						methodBlock.statements().remove(methodBlock.statements().size() - 1);
						return;
					}
					
					final CastExpression cast = ast.newCastExpression();
					
					if(methodParamType.isPrimitive())
					{
						// cast to ensure that right method is called
						// --> see doSth(int) and doSth(Integer)
						
						if(methodParamType.equals(boolean.class))
						{
							cast.setType(ast.newPrimitiveType(PrimitiveType.BOOLEAN));
						}
						else if(methodParamType.equals(byte.class))
						{
							cast.setType(ast.newPrimitiveType(PrimitiveType.BYTE));
						}
						else if(methodParamType.equals(char.class))
						{
							cast.setType(ast.newPrimitiveType(PrimitiveType.CHAR));
						}
						else if(methodParamType.equals(double.class))
						{
							cast.setType(ast.newPrimitiveType(PrimitiveType.DOUBLE));
						}
						else if(methodParamType.equals(float.class))
						{
							cast.setType(ast.newPrimitiveType(PrimitiveType.FLOAT));
						}
						else if(methodParamType.equals(int.class))
						{
							cast.setType(ast.newPrimitiveType(PrimitiveType.INT));
						}
						else if(methodParamType.equals(long.class))
						{
							cast.setType(ast.newPrimitiveType(PrimitiveType.LONG));
						}
						else if(methodParamType.equals(short.class))
						{
							cast.setType(ast.newPrimitiveType(PrimitiveType.SHORT));
						}
						else
						{
							throw new RuntimeException("unknown primitive type: " + methodParamType);
						}

					}
					else
					{
						// we need an up-cast
						if(methodParamType.getName().contains("."))
						{
							cast.setType(this.createAstType(methodParamType.getName(), ast));
						}
						else
						{
							cast.setType(createAstType(methodParamType.getName(), ast));
						}
					}
					
					cast.setExpression(ast.newSimpleName(this.oidToVarMapping.get(arg)));
					arguments.add(cast);
				}
			}
		}
	}
	
	@SuppressWarnings("unchecked")
	@Override
	public void createPlainInitStmt(CaptureLog log, int logRecNo) 
	{
		PostProcessor.notifyRecentlyProcessedLogRecNo(logRecNo);
		
		// NOTE: PLAIN INIT: has always one non-null param
		// TODO: use primitives
		final int    oid   = log.objectIds.get(logRecNo);
		
		if(this.oidToVarMapping.containsKey(oid))
		{
			// TODO this might happen because of Integer.valueOf o.ä. . Is this approach ok?
			return;
		}
		
		final String type  = log.oidClassNames.get(log.oidRecMapping.get(oid));
		final Object value = log.params.get(logRecNo)[0];
		
		
		final VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
		vd.setName(ast.newSimpleName(this.createNewVarName(oid, value.getClass().getName())));
		
		final VariableDeclarationStatement stmt = ast.newVariableDeclarationStatement(vd);

		if(value instanceof Class)
		{
			stmt.setType(ast.newSimpleType(ast.newSimpleName("Class")));
		}
		else
		{
			stmt.setType(this.createAstType(type, ast));
		}
		
		
		if(value instanceof Number)
		{
			if(value instanceof Long)
			{
				vd.setInitializer(ast.newNumberLiteral(String.valueOf(value) + 'l'));
			}
			else if(value instanceof Double)
			{
				vd.setInitializer(ast.newNumberLiteral(String.valueOf(value) + 'd'));
			}
			else
			{
				vd.setInitializer(ast.newNumberLiteral(String.valueOf(value)));
			}
			
		}
		else if(value instanceof String)
		{
			final StringLiteral literal = ast.newStringLiteral();
			literal.setLiteralValue((String) value);
			vd.setInitializer(literal);
			
		}
		else if(value instanceof Character)
		{
			final CharacterLiteral literal = ast.newCharacterLiteral();
			literal.setCharValue((Character) value);
			vd.setInitializer(literal);	
		}
		else if(value instanceof Boolean)
		{
			final BooleanLiteral literal = ast.newBooleanLiteral((Boolean)value);
			vd.setInitializer(literal);
		}
		else if(value instanceof Class)
		{
			final TypeLiteral clazz = ast.newTypeLiteral();
			clazz.setType(ast.newSimpleType(ast.newName(((Class<?>) value).getName())));
			vd.setInitializer(clazz);
		}
		else
		{
			throw new IllegalStateException("An error occurred while creating a plain statement: unsupported type: " + value.getClass().getName());
		}	
				
		methodBlock.statements().add(stmt);
	}
	
	
	@SuppressWarnings("unchecked")
	@Override
	public void createUnobservedInitStmt(CaptureLog log, int logRecNo) 
	{
		PostProcessor.notifyRecentlyProcessedLogRecNo(logRecNo);
		
		// NOTE: PLAIN INIT: has always one non-null param
		// TODO: use primitives
		final int    oid     = log.objectIds.get(logRecNo);
//		final String type    = log.oidClassNames.get(log.oidRecMapping.get(oid));
		final Object value   = log.params.get(logRecNo)[0];
		this.isXStreamNeeded = true;
		
		final VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
		// handling because there must always be a new instantiation statement for pseudo inits
		this.oidToVarMapping.remove(oid);
		vd.setName(ast.newSimpleName(this.createNewVarName(oid, log.oidClassNames.get(log.oidRecMapping.get(oid)), true)));
		
		final MethodInvocation methodInvocation = ast.newMethodInvocation();
		final Name name = ast.newSimpleName("XSTREAM");
		methodInvocation.setExpression(name);
		methodInvocation.setName(ast.newSimpleName("fromXML")); 
		
		final StringLiteral xmlParam = ast.newStringLiteral();
		xmlParam.setLiteralValue((String) value);
		methodInvocation.arguments().add(xmlParam);
		
//		final CastExpression castExpr = ast.newCastExpression();
//		castExpr.setType(this.createAstType(type, ast));
//		castExpr.setExpression(methodInvocation);
		
//		vd.setInitializer(castExpr);
		vd.setInitializer(methodInvocation);
		
		final VariableDeclarationStatement vs = ast.newVariableDeclarationStatement(vd);
		vs.setType(this.createAstType("Object", ast));
				
		methodBlock.statements().add(vs);
	}	
	
	
	
	@SuppressWarnings("unchecked")
	@Override
	public void createFieldWriteAccessStmt(CaptureLog log, int logRecNo) {

		// assumption: all necessary statements are created and there is one variable for reach referenced object
		
		final Object[] methodArgs = log.params.get(logRecNo);
		final String   methodName = log.methodNames.get(logRecNo);
		final int      oid        = log.objectIds.get(logRecNo);
		final int      captureId  = log.captureIds.get(logRecNo);
		
		final String  fieldName = log.namesOfAccessedFields.get(captureId);
		final String  typeName  = log.oidClassNames.get(log.oidRecMapping.get(oid));
		
		final Class<?> type                     = getClassForName(typeName);
		final int      fieldTypeModifiers       = this.getFieldModifiers(type, fieldName);
		final boolean  isPublic                 = java.lang.reflect.Modifier.isPublic(fieldTypeModifiers);
		final boolean  haveSamePackage          = type.getPackage().getName().equals(packageName); // TODO might be nicer...
		final boolean  isReflectionAccessNeeded = ! isPublic && ! haveSamePackage;
		
		
		if(isReflectionAccessNeeded)
		{
			this.isSetFieldMethodNeeded = true;
			final String varName        = this.oidToVarMapping.get(oid);
			
			final MethodInvocation setFieldCall = ast.newMethodInvocation();
			setFieldCall.setName(ast.newSimpleName("setField"));
			
			StringLiteral stringLiteral = ast.newStringLiteral();
			stringLiteral.setLiteralValue(typeName);
			setFieldCall.arguments().add(stringLiteral);              // class name
			
			stringLiteral = ast.newStringLiteral();
			stringLiteral.setLiteralValue(fieldName);
			setFieldCall.arguments().add(stringLiteral);              // field name
			
			setFieldCall.arguments().add(ast.newSimpleName(varName)); // receiver
			 
			final Integer arg = (Integer) methodArgs[0];
			if(arg == null)
			{
				setFieldCall.arguments().add(ast.newNullLiteral());  // value
			}
			else
			{
				setFieldCall.arguments().add(ast.newSimpleName(this.oidToVarMapping.get(arg))); // value
			}
			
			methodBlock.statements().add(ast.newExpressionStatement(setFieldCall));
		}
		else
		{
			FieldAccess fa = ast.newFieldAccess();
			if(CaptureLog.PUTSTATIC.equals(methodName))
			{
				fa.setExpression(ast.newName(typeName));
			}
			else
			{
				final String varName = this.oidToVarMapping.get(oid);
				fa.setExpression(ast.newSimpleName(varName));
			}
			
			fa.setName(ast.newSimpleName(fieldName));
			
			
			final Assignment assignment = ast.newAssignment();
			assignment.setLeftHandSide(fa);
			
			final Integer arg = (Integer) methodArgs[0];
			if(arg == null)
			{
				assignment.setRightHandSide(ast.newNullLiteral());
			}
			else
			{
				final Class<?> argType   = this.oidToTypeMapping.get(arg);
				final String   fieldDesc = log.descList.get(logRecNo);
				final Class<?> fieldType = CaptureUtil.getClassFromDesc(fieldDesc);
				
				if(fieldType.isAssignableFrom(argType) || fieldType.isPrimitive())
				{
					assignment.setRightHandSide(ast.newSimpleName(this.oidToVarMapping.get(arg)));
				}
				else
				{
					// we need an up-cast
					
					final CastExpression cast = ast.newCastExpression();
					cast.setType(ast.newSimpleType(ast.newName(fieldType.getName())));
					cast.setExpression(ast.newSimpleName(this.oidToVarMapping.get(arg)));
					assignment.setRightHandSide(cast);
				}
			}
			
			methodBlock.statements().add(ast.newExpressionStatement(assignment));
		}
	}	
	
	@SuppressWarnings("unchecked")
	@Override
	public void createFieldReadAccessStmt(CaptureLog log, int logRecNo) 
	{
		final String   methodName = log.methodNames.get(logRecNo);
		final int      oid        = log.objectIds.get(logRecNo);
		final int      captureId  = log.captureIds.get(logRecNo);
		
		String returnVarName = null;
		
		final Object returnValue = log.returnValues.get(logRecNo);
		if(! CaptureLog.RETURN_TYPE_VOID.equals(returnValue))
		{
			Integer 	  returnValueOID  = (Integer) returnValue;
			final String  descriptor 	  = log.descList.get(logRecNo);
			final String  fieldTypeName   = org.objectweb.asm.Type.getType(descriptor).getClassName();
			final String  typeName        = log.oidClassNames.get(log.oidRecMapping.get(oid));
			final String  fieldName       = log.namesOfAccessedFields.get(captureId);
			final String  receiverVarName = this.oidToVarMapping.get(oid);
			
			final Class<?> type = getClassForName(typeName);
			final int     fieldTypeModifiers       = this.getFieldModifiers(type, fieldName);
			final boolean isPublic                 = java.lang.reflect.Modifier.isPublic(fieldTypeModifiers);
			final boolean haveSamePackage          = type.getPackage().getName().equals(packageName); // TODO might be nicer...
			final boolean isReflectionAccessNeeded = ! isPublic && ! haveSamePackage;
			
			// e.g. Person var0 = Person.BEN;
			returnVarName                  = this.createNewVarName(returnValueOID, fieldTypeName);
			VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
			vd.setName(ast.newSimpleName(returnVarName));	
			
			if(isReflectionAccessNeeded)
			{
				this.isGetFieldMethodNeeded = true;
				
				//-- construct getField() call
				final MethodInvocation getFieldCall = ast.newMethodInvocation();
				getFieldCall.setName(ast.newSimpleName("getField"));
				
				StringLiteral stringLiteral = ast.newStringLiteral();
				stringLiteral.setLiteralValue(fieldTypeName);
				getFieldCall.arguments().add(stringLiteral);              // class name
				
				stringLiteral = ast.newStringLiteral();
				stringLiteral.setLiteralValue(fieldName);
				getFieldCall.arguments().add(stringLiteral);              // field name

				if(receiverVarName == null)
				{
					getFieldCall.arguments().add(ast.newNullLiteral()); // static call -> no receiver
				}
				else
				{
					getFieldCall.arguments().add(ast.newSimpleName(receiverVarName)); // receiver
				}
				
				// cast from object to field type
				final CastExpression cast = ast.newCastExpression();
				cast.setType(ast.newSimpleType(ast.newName(fieldTypeName)));
				cast.setExpression(getFieldCall);
				
				vd.setInitializer(cast);
			}
			else
			{
				FieldAccess fa = ast.newFieldAccess();
				if(CaptureLog.GETSTATIC.equals(methodName))
				{
					final String classType = log.oidClassNames.get(log.oidRecMapping.get(oid));
					fa.setExpression(ast.newName(classType.replace('$', '.').split("\\.")));
				}
				else
				{
					fa.setExpression(ast.newSimpleName(receiverVarName));
				}
				fa.setName(ast.newSimpleName(fieldName));
				
				vd.setInitializer(fa);
			}
			
			VariableDeclarationStatement stmt = ast.newVariableDeclarationStatement(vd);
			stmt.setType(this.createAstType(fieldTypeName, ast));
			
			methodBlock.statements().add(stmt);	
		}
	}	
	

	@Override
	public void createArrayInitStmt(final CaptureLog log, final int logRecNo) {
		final int  oid  = log.objectIds.get(logRecNo);
		
		final Object[] params      = log.params.get(logRecNo);
		final String   arrTypeName = log.oidClassNames.get(log.oidRecMapping.get(oid));
		final Class<?> arrType     = getClassForName(arrTypeName);
		
		// --- create array instance creation e.g. int[] var = new int[10];
		
		final ArrayType     arrAstType      = (ArrayType) createAstArrayType(arrTypeName, ast);
		final ArrayCreation arrCreationExpr = ast.newArrayCreation();
		arrCreationExpr.setType(arrAstType);
		arrCreationExpr.dimensions().add(ast.newNumberLiteral(String.valueOf(params.length)));
			
		final String 					  arrVarName = this.createNewVarName(oid, arrTypeName);
		final VariableDeclarationFragment vd         = ast.newVariableDeclarationFragment();
		final SimpleName arrVarNameExpr = ast.newSimpleName(arrVarName); 
		vd.setName(arrVarNameExpr);	
		vd.setInitializer(arrCreationExpr);
		
		final VariableDeclarationStatement varDeclStmt = ast.newVariableDeclarationStatement(vd);
		varDeclStmt.setType(this.createAstType(arrTypeName, ast));
		
		methodBlock.statements().add(varDeclStmt);	
		
		// create array access statements var[0] = var1;
		Integer paramOID;
		Assignment assign;
		ArrayAccess arrAccessExpr;
		
		for(int i = 0; i < params.length; i++)
		{
			assign       = ast.newAssignment();
			arrAccessExpr = ast.newArrayAccess();
			arrAccessExpr.setIndex(ast.newNumberLiteral(String.valueOf(i)));
			arrAccessExpr.setArray(arrVarNameExpr);
			
			assign.setLeftHandSide(arrAccessExpr);
			
			paramOID = (Integer) params[i];
			if(paramOID == null)
			{
			   assign.setRightHandSide(ast.newNullLiteral());
			}
			else
			{
				assign.setRightHandSide(ast.newSimpleName(this.oidToVarMapping.get(paramOID)));
			}
			
			methodBlock.statements().add(assign);	
		}
	}


	@SuppressWarnings("unchecked")
	@Override
	public void createCollectionInitStmt(final CaptureLog log, final int logRecNo) 
	{
		final int      oid          = log.objectIds.get(logRecNo);
		final Object[] params       = log.params.get(logRecNo);
		String         collTypeName = log.oidClassNames.get(log.oidRecMapping.get(oid));
		final Class<?> collType     = getClassForName(collTypeName);

		final String varName;
		
		// -- determine if an alternative collection must be used for code generation
		final boolean isPrivate = java.lang.reflect.Modifier.isPrivate(collType.getModifiers());
		if(isPrivate || ! hasDefaultConstructor(collType))
		{
			if(Set.class.isAssignableFrom(collType))
			{
				collTypeName = HashSet.class.getName();
			}
			else if (List.class.isAssignableFrom(collType))
			{
				collTypeName = ArrayList.class.getName();
			}
			else if(Queue.class.isAssignableFrom(collType))
			{
				collTypeName = ArrayDeque.class.getName();
			}
			else
			{
				throw new RuntimeException("Collection " + collType + " is not supported");
			}
		}

		// -- create code for instantiating collection
		varName = this.createNewVarName(oid, collTypeName);
		
		final VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
		final SimpleName varNameExpr = ast.newSimpleName(varName); 
		vd.setName(varNameExpr);	
		
		final ClassInstanceCreation ci = ast.newClassInstanceCreation();
 	    ci.setType(this.createAstType(collTypeName, ast));
 	    vd.setInitializer(ci);
		
		final VariableDeclarationStatement stmt = ast.newVariableDeclarationStatement(vd);
		stmt.setType(this.createAstType(collTypeName, ast));
		
		methodBlock.statements().add(stmt);	

		// --- create code for filling the collection
		Integer paramOID;
		MethodInvocation mi;
		for(int i = 0; i < params.length; i++)
		{
			mi = ast.newMethodInvocation();
			mi.setName(ast.newSimpleName("add"));
			
			paramOID = (Integer) params[i];
			if(paramOID == null)
			{
				mi.arguments().add(ast.newNullLiteral());
			}
			else
			{
				mi.arguments().add(ast.newSimpleName(this.oidToVarMapping.get(paramOID)));
			}
			
			methodBlock.statements().add(mi);	
		}
	}

	private boolean hasDefaultConstructor(final Class<?> clazz)
	{
		for(final Constructor<?> c : clazz.getConstructors())
		{
			if(c.getParameterTypes().length == 0)
			{
				return true;
			}
		}
		
		return false;
	}

	@Override
	public void createMapInitStmt(final CaptureLog log, final int logRecNo) {
		final int      oid          = log.objectIds.get(logRecNo);
		final Object[] params       = log.params.get(logRecNo);
		String         collTypeName = log.oidClassNames.get(log.oidRecMapping.get(oid));
		final Class<?> collType     = getClassForName(collTypeName);


		final String varName;
		
		// -- determine if an alternative collection must be used for code generation
		final boolean isPrivate = java.lang.reflect.Modifier.isPrivate(collType.getModifiers());
		if(isPrivate || ! hasDefaultConstructor(collType))
		{
			collTypeName = HashMap.class.getName();
		}

		// -- create code for instantiating collection
		varName = this.createNewVarName(oid, collTypeName);
		
		final VariableDeclarationFragment vd = ast.newVariableDeclarationFragment();
		final SimpleName varNameExpr = ast.newSimpleName(varName); 
		vd.setName(varNameExpr);	
		
		final ClassInstanceCreation ci = ast.newClassInstanceCreation();
 	    ci.setType(this.createAstType(collTypeName, ast));
 	    vd.setInitializer(ci);
		
		final VariableDeclarationStatement stmt = ast.newVariableDeclarationStatement(vd);
		stmt.setType(this.createAstType(collTypeName, ast));
		
		methodBlock.statements().add(stmt);	

		// --- create code for filling the collection
		Integer valueOID;
		Integer keyOID;
		
		MethodInvocation mi;
		for(int i = 0; i + 1< params.length; i+=2)
		{
			mi = ast.newMethodInvocation();
			mi.setName(ast.newSimpleName("put"));
			
			keyOID = (Integer) params[i];
		    mi.arguments().add(ast.newSimpleName(this.oidToVarMapping.get(keyOID)));
			
			valueOID = (Integer) params[i + 1];
			if(valueOID == null)
			{
				mi.arguments().add(ast.newNullLiteral());
			}
			else
			{
				mi.arguments().add(ast.newSimpleName(this.oidToVarMapping.get(valueOID)));
			}
			
			methodBlock.statements().add(mi);	
		}
	}
	
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	private void createSetFieldMethod(final TypeDeclaration td, final CompilationUnit cu, final AST ast)
	{
		//-- add necessary import statements
		List imports = cu.imports();
		ImportDeclaration id = ast.newImportDeclaration();
		id.setName(ast.newName(new String[] { "java", "lang", "reflect", "Field" }));
		imports.add(id);
		
		//-- create method frame: "public static void setProtectedField(final String clazzName, final String fieldName, final Object receiver, final Object value) throws Exception"
		final MethodDeclaration md = ast.newMethodDeclaration();
		td.bodyDeclarations().add(md);
		md.setName(ast.newSimpleName("setField"));
		
		List modifiers = md.modifiers();
		modifiers.add(ast.newModifier(Modifier.ModifierKeyword.PRIVATE_KEYWORD));
		modifiers.add(ast.newModifier(Modifier.ModifierKeyword.STATIC_KEYWORD));
			
		md.thrownExceptions().add(ast.newSimpleName("Exception"));
		
		List parameters = md.parameters();
		
		SingleVariableDeclaration svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newSimpleType(ast.newSimpleName("String")));
		svd.setName(ast.newSimpleName("clazzName"));
		parameters.add(svd);

		svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newSimpleType(ast.newSimpleName("String")));
		svd.setName(ast.newSimpleName("fieldName"));
		parameters.add(svd);
		
		svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newSimpleType(ast.newSimpleName("Object")));
		svd.setName(ast.newSimpleName("receiver"));
		parameters.add(svd);
		
		svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newSimpleType(ast.newSimpleName("Object")));
		svd.setName(ast.newSimpleName("value"));
		parameters.add(svd);
		
		//-- create method body
		//		final Class<?> clazz = Class.forName(clazzName);
		//		final Field    f     = clazz.getDeclaredField(fieldName);
		//		f.setAccessible(true);
		//		f.set(receiver, value);
		
		final Block methodBlock = ast.newBlock();
		md.setBody(methodBlock);
		final List methodStmts = methodBlock.statements();
		
		// final Class clazz = Class.forName(clazzName);		
		MethodInvocation init = ast.newMethodInvocation();
		init.setName(ast.newSimpleName("forName"));
		init.setExpression(ast.newSimpleName("Class"));
		init.arguments().add(ast.newSimpleName("clazzName"));
		VariableDeclarationFragment  varDeclFrag = ast.newVariableDeclarationFragment();
		varDeclFrag.setName(ast.newSimpleName("clazz"));
		varDeclFrag.setInitializer(init);
		VariableDeclarationStatement varDeclStmt = ast.newVariableDeclarationStatement(varDeclFrag);
		varDeclStmt.setType(ast.newSimpleType(ast.newSimpleName("Class")));
		methodStmts.add(varDeclStmt);
		
		// final Field f = clazz.getDeclaredField(fieldName);
		init = ast.newMethodInvocation();
		init.setName(ast.newSimpleName("getDeclaredField"));
		init.setExpression(ast.newSimpleName("clazz"));
		init.arguments().add(ast.newSimpleName("fieldName"));
		varDeclFrag = ast.newVariableDeclarationFragment();
		varDeclFrag.setName(ast.newSimpleName("f"));
		varDeclFrag.setInitializer(init);
		varDeclStmt = ast.newVariableDeclarationStatement(varDeclFrag);
		varDeclStmt.setType(ast.newSimpleType(ast.newSimpleName("Field")));
		methodStmts.add(varDeclStmt);		
		
		// f.setAccessible(true);
		MethodInvocation minv = ast.newMethodInvocation();
		minv.setName(ast.newSimpleName("setAccessible"));
		minv.setExpression(ast.newSimpleName("f"));
		minv.arguments().add(ast.newBooleanLiteral(true));
		methodStmts.add(ast.newExpressionStatement(minv));
		
		// f.set(receiver, value);
		minv = ast.newMethodInvocation();
		minv.setName(ast.newSimpleName("set"));
		minv.setExpression(ast.newSimpleName("f"));
		minv.arguments().add(ast.newSimpleName("receiver"));
		minv.arguments().add(ast.newSimpleName("value"));
		methodStmts.add(ast.newExpressionStatement(minv));
	}
	
	
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	private void createGetFieldMethod(final TypeDeclaration td, final CompilationUnit cu, final AST ast)
	{
//		public static void setField(final String clazzName, final String fieldName, final Object receiver, final Object value) throws Exception
//		{
//			final Class<?> clazz = Class.forName(clazzName);
//			final Field    f     = clazz.getDeclaredField(fieldName);
//			f.setAccessible(true);
//			f.set(receiver, value);
//		}
		
		//-- add necessary import statements
		List imports = cu.imports();
		ImportDeclaration id = ast.newImportDeclaration();
		id.setName(ast.newName(new String[] { "java", "lang", "reflect", "Field" }));
		imports.add(id);
		
		//-- create method frame: "public static Object setProtectedField(final String clazzName, final String fieldName, final Object receiver) throws Exception"
		final MethodDeclaration md = ast.newMethodDeclaration();
		td.bodyDeclarations().add(md);
		md.setName(ast.newSimpleName("getField"));
		
		List modifiers = md.modifiers();
		modifiers.add(ast.newModifier(Modifier.ModifierKeyword.PRIVATE_KEYWORD));
		modifiers.add(ast.newModifier(Modifier.ModifierKeyword.STATIC_KEYWORD));
			
		md.thrownExceptions().add(ast.newSimpleName("Exception"));
		
		List parameters = md.parameters();
		
		SingleVariableDeclaration svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newSimpleType(ast.newSimpleName("String")));
		svd.setName(ast.newSimpleName("clazzName"));
		parameters.add(svd);

		svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newSimpleType(ast.newSimpleName("String")));
		svd.setName(ast.newSimpleName("fieldName"));
		parameters.add(svd);
		
		svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newSimpleType(ast.newSimpleName("Object")));
		svd.setName(ast.newSimpleName("receiver"));
		parameters.add(svd);
		
		md.setReturnType2(ast.newSimpleType(ast.newSimpleName("Object")));
		
		//-- create method body
		//		final Class<?> clazz = Class.forName(clazzName);
		//		final Field    f     = clazz.getDeclaredField(fieldName);
		//		f.setAccessible(true);
		//		return f.get(receiver);
		
		final Block methodBlock = ast.newBlock();
		md.setBody(methodBlock);
		final List methodStmts = methodBlock.statements();
		
		// final Class clazz = Class.forName(clazzName);		
		MethodInvocation init = ast.newMethodInvocation();
		init.setName(ast.newSimpleName("forName"));
		init.setExpression(ast.newSimpleName("Class"));
		init.arguments().add(ast.newSimpleName("clazzName"));
		VariableDeclarationFragment  varDeclFrag = ast.newVariableDeclarationFragment();
		varDeclFrag.setName(ast.newSimpleName("clazz"));
		varDeclFrag.setInitializer(init);
		VariableDeclarationStatement varDeclStmt = ast.newVariableDeclarationStatement(varDeclFrag);
		varDeclStmt.setType(ast.newSimpleType(ast.newSimpleName("Class")));
		methodStmts.add(varDeclStmt);
		
		// final Field f = clazz.getDeclaredField(fieldName);
		init = ast.newMethodInvocation();
		init.setName(ast.newSimpleName("getDeclaredField"));
		init.setExpression(ast.newSimpleName("clazz"));
		init.arguments().add(ast.newSimpleName("fieldName"));
		varDeclFrag = ast.newVariableDeclarationFragment();
		varDeclFrag.setName(ast.newSimpleName("f"));
		varDeclFrag.setInitializer(init);
		varDeclStmt = ast.newVariableDeclarationStatement(varDeclFrag);
		varDeclStmt.setType(ast.newSimpleType(ast.newSimpleName("Field")));
		methodStmts.add(varDeclStmt);		
		
		// f.setAccessible(true);
		MethodInvocation minv = ast.newMethodInvocation();
		minv.setName(ast.newSimpleName("setAccessible"));
		minv.setExpression(ast.newSimpleName("f"));
		minv.arguments().add(ast.newBooleanLiteral(true));
		methodStmts.add(ast.newExpressionStatement(minv));
		
		// return f.get(receiver);
		minv = ast.newMethodInvocation();
		minv.setName(ast.newSimpleName("get"));
		minv.setExpression(ast.newSimpleName("f"));
		minv.arguments().add(ast.newSimpleName("receiver"));
		final ReturnStatement returnStmt = ast.newReturnStatement();
		returnStmt.setExpression(minv);
		methodStmts.add(returnStmt);
	}	
	
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	private void createCallMethod(final TypeDeclaration td, final CompilationUnit cu, final AST ast)
	{
//		public static Object callMethod(final String clazzName, final String methodName, final Object receiver, final Object...args) throws Exception
//		{
//			final Class<?> clazz = Class.forName(clazzName);
//			final Method   m     = clazz.getDeclaredMethod(methodName);
//			m.setAccessible(true);
//			return m.invoke(receiver, args);
//		}
		
		
		//-- add necessary import statements
		List imports = cu.imports();
		ImportDeclaration id = ast.newImportDeclaration();
		id.setName(ast.newName(new String[] { "java", "lang", "reflect", "Method" }));
		imports.add(id);
		
		//-- create method frame: "public static Object callMethod(final String clazzName, final String methodName, final Object receiver, final Object[] args, Class[] paramTypes) throws Exception"
		final MethodDeclaration md = ast.newMethodDeclaration();
		td.bodyDeclarations().add(md);
		md.setName(ast.newSimpleName("callMethod"));
		
		List modifiers = md.modifiers();
		modifiers.add(ast.newModifier(Modifier.ModifierKeyword.PRIVATE_KEYWORD));
		modifiers.add(ast.newModifier(Modifier.ModifierKeyword.STATIC_KEYWORD));
			
		md.thrownExceptions().add(ast.newSimpleName("Exception"));
		
		List parameters = md.parameters();
		
		SingleVariableDeclaration svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newSimpleType(ast.newSimpleName("String")));
		svd.setName(ast.newSimpleName("clazzName"));
		parameters.add(svd);

		svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newSimpleType(ast.newSimpleName("String")));
		svd.setName(ast.newSimpleName("methodName"));
		parameters.add(svd);
		
		svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newSimpleType(ast.newSimpleName("Object")));
		svd.setName(ast.newSimpleName("receiver"));
		parameters.add(svd);
		
		svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newArrayType(ast.newSimpleType(ast.newSimpleName("Object"))));
		svd.setName(ast.newSimpleName("args"));
		parameters.add(svd);
		
		svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newArrayType(ast.newSimpleType(ast.newSimpleName("Class"))));
		svd.setName(ast.newSimpleName("paramTypes"));
		parameters.add(svd);
		
		md.setReturnType2(ast.newSimpleType(ast.newSimpleName("Object")));
		
		
		
		//-- create method body
		//		final Class<?> clazz = Class.forName(clazzName);
		//		final Method   m     = clazz.getDeclaredMethod(methodName, paramTypes);
		//		m.setAccessible(true);
		//		return m.invoke(receiver, args);
		
		final Block methodBlock = ast.newBlock();
		md.setBody(methodBlock);
		final List methodStmts = methodBlock.statements();
		
		// final Class clazz = Class.forName(clazzName);		
		MethodInvocation init = ast.newMethodInvocation();
		init.setName(ast.newSimpleName("forName"));
		init.setExpression(ast.newSimpleName("Class"));
		init.arguments().add(ast.newSimpleName("clazzName"));
		VariableDeclarationFragment  varDeclFrag = ast.newVariableDeclarationFragment();
		varDeclFrag.setName(ast.newSimpleName("clazz"));
		varDeclFrag.setInitializer(init);
		VariableDeclarationStatement varDeclStmt = ast.newVariableDeclarationStatement(varDeclFrag);
		varDeclStmt.setType(ast.newSimpleType(ast.newSimpleName("Class")));
		methodStmts.add(varDeclStmt);
		
		// final Method m = clazz.getDeclaredMethod(methodName);
		init = ast.newMethodInvocation();
		init.setName(ast.newSimpleName("getDeclaredMethod"));
		init.setExpression(ast.newSimpleName("clazz"));
		init.arguments().add(ast.newSimpleName("methodName"));
		init.arguments().add(ast.newSimpleName("paramTypes"));
		varDeclFrag = ast.newVariableDeclarationFragment();
		varDeclFrag.setName(ast.newSimpleName("m"));
		varDeclFrag.setInitializer(init);
		varDeclStmt = ast.newVariableDeclarationStatement(varDeclFrag);
		varDeclStmt.setType(ast.newSimpleType(ast.newSimpleName("Method")));
		methodStmts.add(varDeclStmt);		
		
		// f.setAccessible(true);
		MethodInvocation minv = ast.newMethodInvocation();
		minv.setName(ast.newSimpleName("setAccessible"));
		minv.setExpression(ast.newSimpleName("m"));
		minv.arguments().add(ast.newBooleanLiteral(true));
		methodStmts.add(ast.newExpressionStatement(minv));
		
		// return m.invoke(receiver, args);
		minv = ast.newMethodInvocation();
		minv.setName(ast.newSimpleName("invoke"));
		minv.setExpression(ast.newSimpleName("m"));
		minv.arguments().add(ast.newSimpleName("receiver"));
		minv.arguments().add(ast.newSimpleName("args"));
		final ReturnStatement returnStmt = ast.newReturnStatement();
		returnStmt.setExpression(minv);
		methodStmts.add(returnStmt);
	}	
	
	
	
	
	@SuppressWarnings({ "rawtypes", "unchecked" })
	private void createNewInstanceMethod(final TypeDeclaration td, final CompilationUnit cu, final AST ast)
	{
//		public static Object newInstance(final String clazzName, final Object receiver, final Object[] args, final Class[] parameterTypes) throws Exception
//		{
//			final Class<?>     clazz = Class.forName(clazzName);
//			final Constructor   c    = clazz.getDeclaredConstructor(parameterTypes);
//			c.setAccessible(true);
//			
//			return c.newInstance(args);
//		}
		
		
		//-- add necessary import statements
		List imports = cu.imports();
		ImportDeclaration id = ast.newImportDeclaration();
		id.setName(ast.newName(new String[] { "java", "lang", "reflect", "Constructor" }));
		imports.add(id);
		
		//-- create method frame: "public static Object newInstance(final String clazzName, final Object[] args, Class[] paramTypes) throws Exception"
		final MethodDeclaration md = ast.newMethodDeclaration();
		td.bodyDeclarations().add(md);
		md.setName(ast.newSimpleName("newInstance"));
		
		List modifiers = md.modifiers();
		modifiers.add(ast.newModifier(Modifier.ModifierKeyword.PRIVATE_KEYWORD));
		modifiers.add(ast.newModifier(Modifier.ModifierKeyword.STATIC_KEYWORD));
			
		md.thrownExceptions().add(ast.newSimpleName("Exception"));
		
		List parameters = md.parameters();
		
		SingleVariableDeclaration svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newSimpleType(ast.newSimpleName("String")));
		svd.setName(ast.newSimpleName("clazzName"));
		parameters.add(svd);
		
		svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newArrayType(ast.newSimpleType(ast.newSimpleName("Object"))));
		svd.setName(ast.newSimpleName("args"));
		parameters.add(svd);
		
		svd = ast.newSingleVariableDeclaration();
		svd.setType(ast.newArrayType(ast.newSimpleType(ast.newSimpleName("Class"))));
		svd.setName(ast.newSimpleName("paramTypes"));
		parameters.add(svd);
		
		md.setReturnType2(ast.newSimpleType(ast.newSimpleName("Object")));
		
		//-- create method body
		//		final Class<?>     clazz = Class.forName(clazzName);
		//		final Constructor   c    = clazz.getDeclaredConstructor(parameterTypes);
		//		c.setAccessible(true);
		//		
		//		return c.newInstance(args);
		
		final Block methodBlock = ast.newBlock();
		md.setBody(methodBlock);
		final List methodStmts = methodBlock.statements();
		
		// final Class clazz = Class.forName(clazzName);		
		MethodInvocation init = ast.newMethodInvocation();
		init.setName(ast.newSimpleName("forName"));
		init.setExpression(ast.newSimpleName("Class"));
		init.arguments().add(ast.newSimpleName("clazzName"));
		VariableDeclarationFragment  varDeclFrag = ast.newVariableDeclarationFragment();
		varDeclFrag.setName(ast.newSimpleName("clazz"));
		varDeclFrag.setInitializer(init);
		VariableDeclarationStatement varDeclStmt = ast.newVariableDeclarationStatement(varDeclFrag);
		varDeclStmt.setType(ast.newSimpleType(ast.newSimpleName("Class")));
		methodStmts.add(varDeclStmt);
		
		// final Constructor c = clazz.getDeclaredConstructor(parameterTypes);
		init = ast.newMethodInvocation();
		init.setName(ast.newSimpleName("getDeclaredConstructor"));
		init.setExpression(ast.newSimpleName("clazz"));
		init.arguments().add(ast.newSimpleName("paramTypes"));
		varDeclFrag = ast.newVariableDeclarationFragment();
		varDeclFrag.setName(ast.newSimpleName("c"));
		varDeclFrag.setInitializer(init);
		varDeclStmt = ast.newVariableDeclarationStatement(varDeclFrag);
		varDeclStmt.setType(ast.newSimpleType(ast.newSimpleName("Constructor")));
		methodStmts.add(varDeclStmt);		
		
		// c.setAccessible(true);
		MethodInvocation minv = ast.newMethodInvocation();
		minv.setName(ast.newSimpleName("setAccessible"));
		minv.setExpression(ast.newSimpleName("c"));
		minv.arguments().add(ast.newBooleanLiteral(true));
		methodStmts.add(ast.newExpressionStatement(minv));
		
		// return c.newInstance(args);
		minv = ast.newMethodInvocation();
		minv.setName(ast.newSimpleName("newInstance"));
		minv.setExpression(ast.newSimpleName("c"));
		minv.arguments().add(ast.newSimpleName("args"));
		final ReturnStatement returnStmt = ast.newReturnStatement();
		returnStmt.setExpression(minv);
		methodStmts.add(returnStmt);
	}	
		
	
	private int getFieldModifiers(final Class<?> clazz, final String fieldName)
	{
		try
		{
			final Field    f     = clazz.getDeclaredField(fieldName);
			return f.getModifiers();
		}
		catch(final NoSuchFieldException e)
		{
			final Class<?> superClazz = clazz.getSuperclass();
			if(superClazz == null)
			{
				throw new RuntimeException(e);
			}
			else
			{
				return this.getFieldModifiers(superClazz, fieldName);
			}
		}
		catch(final Exception e)
		{
			throw new RuntimeException(e);
		}
	}
	
	
	private int getMethodModifiers(final Class<?> clazz, final String methodName, final Class<?>[] paramTypes)
	{
		try
		{
			final Method   m  = clazz.getDeclaredMethod(methodName, paramTypes);
			return m.getModifiers();
		}
		catch(final NoSuchMethodException e)
		{
			final Class<?> superClazz = clazz.getSuperclass();
			if(superClazz == null)
			{
				throw new RuntimeException(e);
			}
			else
			{
				return this.getMethodModifiers(superClazz, methodName, paramTypes);
			}
		}
		catch(final Exception e)
		{
			throw new RuntimeException(e);
		}
	}
	
	
	private int getConstructorModifiers(final Class<?> clazz, final Class<?>[] paramTypes)
	{
		try
		{
			final  Constructor<?> c  = clazz.getDeclaredConstructor(paramTypes);
			return c.getModifiers();
		}
		catch(final NoSuchMethodException e)
		{
			final Class<?> superClazz = clazz.getSuperclass();
			if(superClazz == null)
			{
				throw new RuntimeException(e);
			}
			else
			{
				return this.getConstructorModifiers(superClazz, paramTypes);
			}
		}
		catch(final Exception e)
		{
			throw new RuntimeException(e);
		}
	}
	
	
	private final Class<?> getClassForName(String type)
	{
		try 
		{
			if( type.equals("boolean"))
			{
				return Boolean.TYPE;
			}
			else if(type.equals("byte"))
			{
				return Byte.TYPE;
			}
			else if( type.equals("char"))
			{
				return Character.TYPE;
			}
			else if( type.equals("double"))
			{
				return Double.TYPE;
			}
			else if(type.equals("float"))
			{
				return Float.TYPE;
			}
			else if(type.equals("int"))
			{
				return Integer.TYPE;
			}
			else if( type.equals("long"))
			{
				return Long.TYPE;
			}
			else if(type.equals("short"))
			{
				return Short.TYPE;
			}
			else if(type.equals("String") ||type.equals("Boolean") ||type.equals("Boolean") || type.equals("Short") ||type.equals("Long") ||
					type.equals("Integer") || type.equals("Float") || type.equals("Double") ||type.equals("Byte") || 
					type.equals("Character") )
			{
				return Class.forName("java.lang." + type);
			}
		
			if(type.endsWith("[]"))
			{
				type = type.replace("[]", "");
				final Class<?> baseClass = getClassForName(type);
				if(baseClass.isPrimitive())
				{
					if(int.class.equals(baseClass))
					{
						return int[].class;
					}
					else if(byte.class.equals(baseClass))
					{
						return byte[].class;
					}
					else if(char.class.equals(baseClass))
					{
						return char[].class;
					}
					else if(double.class.equals(baseClass))
					{
						return double[].class;
					}
					else if(boolean.class.equals(baseClass))
					{
						return boolean[].class;
					}
					else if(float.class.equals(baseClass))
					{
						return float[].class;
					}
					else if(short.class.equals(baseClass))
					{
						return short[].class;
					}
					else
					{
						return long[].class;
					}
				}
				else if(baseClass.isArray()) 
				{
					return Class.forName("[" + type);
				}
				else
				{
					return Class.forName("[L" + type + ";");
				}
				
				
			}
			else
			{
				return Class.forName(Utils.getClassNameFromResourcePath(type));
			}
		} 
		catch (final ClassNotFoundException e) 
		{
			throw new RuntimeException(e);
		}
	}
	
	

}