@Creatable
class A {
  @Inject private B someField; 

  @Inject private C someOtherField;
}

@Creatable
class B {
  @Inject C thirdField;
}

@Creatable
class C {
  @Inject /*qualifier*/ A fourthField;
}

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class MockInjector {
	
	public Object getInstance(Class<?> testClass) {
		Object instance = null;
		try {
			instance = testClass.newInstance();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		
		if (instance == null) {
			Constructor<?>[] constructs = testClass.getDeclaredConstructors();
			// choose a constructor
			
			Class<?>[] params = constructs[0].getParameterTypes();
			Object[] paramInstances = new Object[params.length];
			// need to create logic to provide parameters for desired constructor
			
			try {
				instance = constructs[0].newInstance(paramInstances);
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.printStackTrace();
			}
		}
		
		return instance;		
	}
	
	public void mockInject(Object testClassInstance, String fieldName, Object fieldValue) {
		Class<?> clazz = testClassInstance.getClass();
		Field testField = null;
		try {
			testField = clazz.getDeclaredField(fieldName);
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		}
		
		/*
		 * It doesn't matter if the field is private or public, by
		 * invoking setAccessible(true) it removes the accessibility 
		 * checks performed by the JVM by setting a flag.  It does not
		 * remove the security checks.  Effectively this eliminates 
		 * encapsulation.
		 */
		testField.setAccessible(true);
		try {
			testField.set(testClassInstance, fieldValue);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}
	
}

IEclipseContext context = EclipseContextFactory.create("test context");
context.set(C.class, new C(...));
A a = ContextInjectionFactory.make(A.class, context);
// test a