Java 类org.apache.commons.lang3.reflect.FieldUtils 实例源码

public static Object createProxy(Object realObject) {
    try {
        MethodInterceptor interceptor = new HammerKiller();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(realObject.getClass());
        enhancer.setCallbackType(interceptor.getClass());
        Class classForProxy = enhancer.createClass();
        Enhancer.registerCallbacks(classForProxy, new Callback[]{interceptor});
        Object createdProxy = classForProxy.newInstance();

        for (Field realField : FieldUtils.getAllFieldsList(realObject.getClass())) {
            if (Modifier.isStatic(realField.getModifiers()))
                continue;
            realField.setAccessible(true);

            realField.set(createdProxy, realField.get(realObject));
        }
        CreeperKiller.LOG.info("Removed HammerCore main menu hook, ads will no longer be displayed.");
        return createdProxy;
    } catch (Exception e) {
        CreeperKiller.LOG.error("Failed to create a proxy for HammerCore ads, they will not be removed.", e);
    }
    return realObject;
}

@Override
public Map<Field, Object> contributeMocks() {
    injectMocks(testInstance);
    return stream(FieldUtils.getAllFields(testInstance.getClass()))
            .filter(this::isMockField)
            .collect(Collectors.toMap(
                    it -> it,
                    it -> {
                        try {
                            it.setAccessible(true);
                            return it.get(testInstance);
                        } catch (IllegalAccessException e) {
                            throw new TestEEfiException("Failed to retrieve mock from test instance", e);
                        }
                    }
            ));
}

private void validate(Object object, Class<?> clazz) throws Exception {
    for (Field field : FieldUtils.getAllFields(clazz)) {
        int modifiers = field.getModifiers();

        // Ignore static fields
        if (Modifier.isStatic(modifiers)) {
            continue;
        }

        assertTrue("Field is private", Modifier.isPrivate(modifiers));
        assertTrue("Field is final", Modifier.isFinal(modifiers));

        Method getter = clazz.getMethod(getterName(field.getName()));
        assertNotNull("Getter exists", getter);
        assertTrue("Getter is public", Modifier.isPublic(getter.getModifiers()));
    }

    // Check that hashCode, toString and equals are defined
    assertNotNull(clazz.getDeclaredMethod("hashCode").invoke(object));
    assertNotNull(clazz.getDeclaredMethod("toString").invoke(object));
    assertTrue((Boolean) clazz.getDeclaredMethod("equals", Object.class).invoke(object, object));
}

private Field getIdField(Class<?> domainClass) {
    Field idField = null;

    final List<Field> fields = FieldUtils.getFieldsListWithAnnotation(domainClass, Id.class);

    if (fields.isEmpty()) {
        idField = ReflectionUtils.findField(getJavaType(), "id");
    } else if (fields.size() == 1) {
        idField = fields.get(0);
    } else {
        throw new IllegalArgumentException("only one field with @Id annotation!");
    }

    if (idField != null && idField.getType() != String.class) {
        throw new IllegalArgumentException("type of id field must be String");
    }
    return idField;
}

private Field getPartitionKeyField(Class<?> domainClass) {
    Field partitionKeyField = null;

    final List<Field> fields = FieldUtils.getFieldsListWithAnnotation(domainClass, PartitionKey.class);

    if (fields.size() == 1) {
        partitionKeyField = fields.get(0);
    } else if (fields.size() > 1) {
        throw new IllegalArgumentException("Azure Cosmos DB supports only one partition key, " +
                "only one field with @PartitionKey annotation!");
    }

    if (partitionKeyField != null && partitionKeyField.getType() != String.class) {
        throw new IllegalArgumentException("type of PartitionKey field must be String");
    }
    return partitionKeyField;
}

@Override
@Nullable
public final List<ObjectTreeAware> traceObjectPath(@NonNull final Object _objectToFind) {
    for (final Field field : FieldUtils.getAllFieldsList(getClass())) {
        try {
            final List<ObjectTreeAware> result = findValue(FieldUtils.readField(this, field.getName(), true), _objectToFind);

            if (result != null) {
                return result;
            }
       } catch (IllegalAccessException _e) {
            // safe to ignore
        }
    }

    return null;
}

/**
 * Given an {@link Element}, {@link #some} filter's its fields using the given predicate, creates
 * a property key and value for each field, flattens them, and returns it as a {@link List}.
 *
 * @throws IllegalArgumentException, if it finds a property that doesn't have a value, and that
 *                                   property corresponds to a {@link org.apache.tinkerpop.gremlin.object.model.PrimaryKey}
 *                                   or {@link org.apache.tinkerpop.gremlin.object.model.OrderingKey}
 *                                   field.
 */
@SneakyThrows
public static <E extends Element> List<Object> some(E element, Predicate<Field> predicate) {
  List<Object> properties = new ArrayList<>();
  for (Field field : fields(element, predicate)) {
    Object propertyValue = FieldUtils.readField(field, element);
    if (isMissing(propertyValue)) {
      if (isKey(field)) {
        throw Element.Exceptions.requiredKeysMissing(element.getClass(), propertyKey(field));
      }
      continue;
    }
    String propertyName = propertyKey(field);
    properties.add(propertyName);
    if (isPrimitive(field)) {
      if (field.getType().isEnum()) {
        properties.add(((Enum) propertyValue).name());
      } else {
        properties.add(propertyValue);
      }
    } else {
      properties.add(propertyValue);
    }
  }
  return properties;
}

/**
 * Update the parameters for the transformTask
 *
 * @param transformTask
 * @param consumedInputStreams
 * @param referencedInputStreams
 * @param outputStream
 */
private void updateTransformTaskConfig(TransformTask transformTask,
                                       @NonNull Collection<TransformStream> consumedInputStreams,
                                       @NonNull Collection<TransformStream> referencedInputStreams,
                                       @Nullable IntermediateStream outputStream) throws IllegalAccessException {
    Field consumedInputStreamsField = FieldUtils.getDeclaredField(StreamBasedTask.class,
                                                                  "consumedInputStreams",
                                                                  true);
    Field referencedInputStreamsField = FieldUtils.getDeclaredField(StreamBasedTask.class,
                                                                    "referencedInputStreams",
                                                                    true);
    Field outputStreamField = FieldUtils.getDeclaredField(StreamBasedTask.class,
                                                          "outputStream",
                                                          true);

    if (null == consumedInputStreamsField ||
            null == referencedInputStreamsField ||
            null == outputStreamField) {
        throw new StopExecutionException(
                "The TransformTask does not has field with name: consumedInputStreams or referencedInputStreams or outputStream! Plugin version does not support!");
    }
    consumedInputStreamsField.set(transformTask, consumedInputStreams);
    referencedInputStreamsField.set(transformTask, referencedInputStreams);
    outputStreamField.set(transformTask, outputStream);
}

/**
 * Gets the parameters of a transformTask
 *
 * @param transformTask
 * @return
 * @throws IllegalAccessException
 */
private TransformTaskParam getTransformParam(TransformTask transformTask) throws IllegalAccessException {
    TransformTaskParam transformTaskParam = new TransformTaskParam();
    Field consumedInputStreamsField = FieldUtils.getDeclaredField(StreamBasedTask.class,
                                                                  "consumedInputStreams",
                                                                  true);
    Field referencedInputStreamsField = FieldUtils.getDeclaredField(StreamBasedTask.class,
                                                                    "referencedInputStreams",
                                                                    true);
    Field outputStreamField = FieldUtils.getDeclaredField(StreamBasedTask.class,
                                                          "outputStream",
                                                          true);

    if (null == consumedInputStreamsField ||
            null == referencedInputStreamsField ||
            null == outputStreamField) {
        throw new StopExecutionException(
                "The TransformTask does not has field with name: consumedInputStreams or referencedInputStreams or outputStream! Plugin version does not support!");
    }
    transformTaskParam.consumedInputStreams = (Collection<TransformStream>) consumedInputStreamsField
            .get(transformTask);
    transformTaskParam.referencedInputStreams = (Collection<TransformStream>) referencedInputStreamsField
            .get(transformTask);
    transformTaskParam.outputStream = (IntermediateStream) outputStreamField.get(transformTask);
    return transformTaskParam;
}

private void checkCommands(final String os, final String... command) throws ReflectiveOperationException {
    final URL[] urLs = ((URLClassLoader) Main.class.getClassLoader()).getURLs();
    ThreadClassLoaderScope scope = null;
    try {
        System.setProperty("os.name", os);
        final URLClassLoader urlClassLoader = new URLClassLoader(urLs, null);
        scope = new ThreadClassLoaderScope(urlClassLoader);
        final Object terra = urlClassLoader.loadClass("org.ligoj.app.plugin.prov.terraform.TerraformUtils").newInstance();
        final Object mock = MethodUtils.invokeStaticMethod(urlClassLoader.loadClass("org.mockito.Mockito"), "mock",
                urlClassLoader.loadClass("org.ligoj.bootstrap.resource.system.configuration.ConfigurationResource"));
        FieldUtils.writeField(terra, "configuration", mock, true);
        Assert.assertEquals(Arrays.asList(command),
                ((ProcessBuilder) MethodUtils.invokeMethod(terra, true, "newBuilder", new Object[] { new String[] { "terraform" } }))
                        .command());
    } finally {
        IOUtils.closeQuietly(scope);
    }
}

@Override
public boolean isValid(Object value, ConstraintValidatorContext context) {
    try {
        String typeKey = (String) FieldUtils.readField(value, typeKeyField, true);
        if (value instanceof XmEntity) {
            return xmEntitySpecService.getAllKeys().containsKey(typeKey);
        } else {
            XmEntity entity = (XmEntity) FieldUtils.readField(value, entityField, true);
            if (entity == null) {
                return true;
            }
            String entityTypeKey = entity.getTypeKey();
            Map<String, Set<String>> keysByEntityType = xmEntitySpecService.getAllKeys().get(entityTypeKey);
            return !(keysByEntityType == null || keysByEntityType.get(getClassName(value)) == null)
                            && keysByEntityType.get(getClassName(value)).contains(typeKey);
        }
    } catch (IllegalAccessException e) {
        log.debug("Could not get keys for validation", e);
        return false;
    }
}

/**
 * Saves (persists) the options in the OptionsObject that are marked with the
 * PreferencesField annotation.
 */
public static void save() {
    OptionsObject oo = OptionsObject.getInstance();
    Field[] fields = FieldUtils.getFieldsWithAnnotation(OptionsObject.class, PreferencesField.class);
    for (Field field : fields) {
        field.setAccessible(true);
        Object value;
        try {
            value = field.get(oo);
        } catch (IllegalArgumentException | IllegalAccessException e) {
            throw new IllegalStateException(e);
        }
        if (value != null) {
            if (!field.getType().isPrimitive()) {
                log.debug("Non primitive field found {}", field.getName());
            }
            preferences.put(field.getName(), value.toString());
        }
    }
}

public static <T> void writeAllFieldsOfType(Object o, T t, Class<T> c) throws IllegalAccessException
{
    boolean wroteSomething = false;

       for (Field f : FieldUtils.getAllFields(o.getClass()))
    {
        if (!Modifier.isStatic(f.getModifiers()) && f.getType().equals(c))
        {
            FieldUtils.writeField(f, o, t, true);
            wroteSomething = true;
        }
    }

       if (!wroteSomething)
        throw new IllegalAccessException();
}

@SuppressWarnings({ "rawtypes" })
public static <T> void writeAllStaticFieldsOfType(Class d, T t, Class c) throws IllegalAccessException
{
    boolean wroteSomething = false;

       for (Field f : FieldUtils.getAllFields(d))
    {
        if (Modifier.isStatic(f.getModifiers()) && f.getType().equals(c))
        {
            FieldUtils.writeStaticField(f, t, true);
            wroteSomething = true;
        }
    }

       if (!wroteSomething)
        throw new IllegalAccessException();
}

@Override
public void handle(Connection connection, ChatMessagePacket packet)
{
    Field connectionsField = FieldUtils.getField(Server.class, "connections", true);

    Connection[] connections;
    try
    {
        connections = (Connection[])FieldUtils.readField(connectionsField, server, true);
    } catch (IllegalAccessException e)
    {
        throw new RuntimeException(e);
    }
    ChatMessageReplyPacket newPacket = new ChatMessageReplyPacket();
    Character sender = gameData.getUserCharacterByConnectionId(connection.getID());
    String nickname = sender.getNickname();
    newPacket.setMessage(packet.getMessage());
    newPacket.setNickname(nickname);
    Character character;
    for(Connection client : connections)        
        if((character = gameData.getUserCharacterByConnectionId(client.getID())) != null)
        {
            newPacket.setSourceCharacterId(character.getId());
            server.sendToTCP(client.getID(), newPacket);
        }
}

@Test
public void configureMessage() throws IllegalArgumentException, IllegalAccessException {
    final ServerProviderFactory instance = ServerProviderFactory.getInstance();
    @SuppressWarnings("unchecked")
    final List<ProviderInfo<ExceptionMapper<?>>> object = (List<ProviderInfo<ExceptionMapper<?>>>) FieldUtils
            .getField(ServerProviderFactory.class, "exceptionMappers", true).get(instance);
    final FailSafeExceptionMapper provider = new FailSafeExceptionMapper();
    object.add(new ProviderInfo<>(provider, null, true));
    final JacksonJsonProvider jacksonJsonProvider = new JacksonJsonProvider();
    FieldUtils.getField(FailSafeExceptionMapper.class, "jacksonJsonProvider", true).set(provider, jacksonJsonProvider);

    final UserImportEntry entry = Mockito.mock(UserImportEntry.class);
    Mockito.when(entry.getId()).thenThrow(new RuntimeException());
    final BatchTaskVo<UserImportEntry> importTask = new BatchTaskVo<>();
    importTask.setEntries(Collections.singletonList(entry));
    task.configure(importTask);
    task.jaxrsFactory = instance;
    task.run();
    Assert.assertEquals(Boolean.TRUE, importTask.getStatus().getStatus());
    Assert.assertEquals(1, importTask.getStatus().getDone());
    Assert.assertEquals(1, importTask.getStatus().getEntries());
}

@Before
public void setup() throws IllegalAccessException {
    servletContext = Mockito.mock(ServletContext.class);
    servlet = new BackendProxyServlet() {
        /**
         * 
         */
        private static final long serialVersionUID = 1L;

        {
            _log = Log.getLogger("junit");
        }

        @Override
        public ServletContext getServletContext() {
            return servletContext;
        }
    };

    FieldUtils.writeField(servlet, "_log", Mockito.mock(Logger.class), true);
    callback = Mockito.mock(Callback.class);
}

private void cleanSpy() throws ClassNotFoundException, IllegalAccessException {
    // 清理Spy中的所有方法
    final Class<?> classOfSpy = getClass().getClassLoader()
            .loadClass("java.com.alibaba.jvm.sandbox.spy.Spy");
    for (final Field waitingCleanField : classOfSpy.getDeclaredFields()) {
        if (Method.class.isAssignableFrom(waitingCleanField.getType())) {
            FieldUtils.writeDeclaredStaticField(
                    classOfSpy,
                    waitingCleanField.getName(),
                    null,
                    true
            );
        }
    }
    logger.info("clean Spy's method success, for jvm-sandbox shutdown.");
}

@Before
public void setup() throws IllegalAccessException {
  MockitoAnnotations.initMocks(this);
  List<String> yamlExtensions = new ArrayList<>();
  yamlExtensions.add(".yaml");
  yamlExtensions.add(".yml");
  FieldUtils.writeField(seed, "yamlExtensions", yamlExtensions, true);
  FieldUtils.writeField(seed, "protocol", CONSUL_PROTOCOL, true);
  FieldUtils.writeField(seed, "host", CONSUL_HOST, true);
  FieldUtils.writeField(seed, "port", CONSUL_PORT, true);
  FieldUtils.writeField(seed, "globalPrefix", CONSUL_GLOBAL_PREFIX, true);
  FieldUtils.writeField(seed, "failLimit", FAIL_LIMIT, true);
  FieldUtils.writeField(seed, "waitTimeBetweenFails", WAIT_TIME, true);
  FieldUtils.writeField(seed, "configPath", CONFIG_PATH, true);
  List<String> acceptableFileExtenstions = new ArrayList<>();
  acceptableFileExtenstions.addAll(yamlExtensions);
  acceptableFileExtenstions.add(".properties");
  FieldUtils.writeField(seed, "acceptablePropertyExtensions", acceptableFileExtenstions, true);
  consul = seed.getConsul();
  assertNotNull("Unable to get Consul instance for testing (check that Consul is running).",
      consul);
  kvClient = consul.keyValueClient();
  assertNotNull("Key Value Client is null.  Can't run tests", kvClient);
}

private Retrofit getModifiedRetrofit(boolean isEnabled) {
    MockableCallAdapterFactory factory = MockableCallAdapterFactory.getInstance(context, isEnabled);

    List<CallAdapter.Factory> factories = new ArrayList<>();
    factories.add(factory);
    factories.addAll(retrofit.callAdapterFactories());

    try {
        FieldUtils.writeField(retrofitBuilder, "adapterFactories", factories, true);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }

    factory.setFactory(retrofit.callFactory());

    retrofit = retrofitBuilder.build();

    return retrofit;
}

@SuppressWarnings("unchecked")
private void closeWebDriverPool() {
  try {
    Runtime runtime = (Runtime) FieldUtils.readField(this, "runtime", true);
    Collection<? extends Backend> backends =
        (Collection<? extends Backend>) FieldUtils.readField(runtime, "backends", true);
    for (Backend backend : backends) {
      if (backend instanceof JavaBackend) {
        GuiceFactory factory =
            (GuiceFactory) FieldUtils.readField(backend, "objectFactory", true);
        WebDriverRegistry webDriverRegistry = factory.getInstance(WebDriverRegistry.class);
        webDriverRegistry.shutdown();
      }
    }
  } catch (IllegalAccessException e) {
    LOG.error("unable to close web driver pool", e);
  }
}

@Test
public void testCheckException() throws Exception {
    TestCassandraHealthCheck testCassandraHealthCheck = new TestCassandraHealthCheck(TEST_SERVER);
    testCassandraHealthCheck.cluster = testCluster;
    FieldUtils.writeField(testCassandraHealthCheck, "logger", loggerMock, true);
    Mockito.when(session.execute(Matchers.anyString())).thenThrow(new RuntimeException("crap"));
    Result result = testCassandraHealthCheck.check();

    Assert.assertFalse(result.isHealthy());
    Mockito.verify(session).close();
    Mockito.verify(session).execute(Matchers.anyString());
    Assert.assertEquals(1, testCluster.nbrTimesCloseCalled);

    ArgumentCaptor<ContextedRuntimeException> exCaptor = ArgumentCaptor.forClass(ContextedRuntimeException.class);
    Mockito.verify(loggerMock).error(Matchers.anyString(), exCaptor.capture());
    Assert.assertEquals(3, exCaptor.getValue().getContextLabels().size());
    Assert.assertEquals(result.getError(), exCaptor.getValue());
}

public static Field getTargetField(Class<?> targetClass, String fieldName) {  
    Field field = null;  

    try {  
        if (targetClass == null) {  
            return field;  
        }  

        if (Object.class.equals(targetClass)) {  
            return field;  
        }  

        field = FieldUtils.getDeclaredField(targetClass, fieldName, true);  
        if (field == null) {  
            field = getTargetField(targetClass.getSuperclass(), fieldName);  
        }  
    } catch (Exception e) {  
    }  

    return field;  
}

protected String getResourcePath() {

        String id = getObjectId();
        String account_id = getAccountId();
        String resourcePath = null;

        try {

            String resource = (String) FieldUtils.readField(resourceObject, "RESOURCE", true);
            String resourceCollection = (String) FieldUtils.readField(resourceObject, "RESOURCE_COLLECTION", true);

            if (null != resourceCollection) {

                resourcePath =  (id != null) ? resource.replace("{account_id}", account_id).replace("{id}", id)
                        : resourceCollection.replace("{account_id}", account_id);
            }

        } catch (Exception e) {
            log.warn("unable to read 'RESOURCE' or 'RESOURCE_COLLECTION', errror : {}", e.toString());
            // return null;
        }
        log.info("resource path = "+resourcePath);
        return resourcePath;
    }

public MotorControllerImpl(PWMOutput output,
        MotorControllerConfiguration configuration) {

    this.output = output;
    this.configuration = configuration;
    this.gpio = GpioFactory.getInstance();

    try {
        Pin myGPIOMotorPin = (Pin) FieldUtils.readDeclaredStaticField(
                RaspiPin.class, configuration.gpioPin());

        motorPin = gpio.provisionDigitalOutputPin(myGPIOMotorPin,
                configuration.name(), PinState.LOW);
        motorPin.setShutdownOptions(true, PinState.LOW);

    } catch (IllegalAccessException e) {
        LOGGER.error("Error on construct MotorControllerImpl", e);
    }

}

/**
 * Creates a new sharded DAO. The number of managed shards and bucketing is controlled by the {@link ShardManager}.
 *
 * @param sessionFactories a session provider for each shard
 */
public LookupDao(List<SessionFactory> sessionFactories,
                 Class<T> entityClass,
                 ShardManager shardManager,
                 BucketIdExtractor<String> bucketIdExtractor) {
    this.shardManager = shardManager;
    this.bucketIdExtractor = bucketIdExtractor;
    this.daos = sessionFactories.stream().map(LookupDaoPriv::new).collect(Collectors.toList());
    this.entityClass = entityClass;

    Field fields[] = FieldUtils.getFieldsWithAnnotation(entityClass, LookupKey.class);
    Preconditions.checkArgument(fields.length != 0, "At least one field needs to be sharding key");
    Preconditions.checkArgument(fields.length == 1, "Only one field can be sharding key");
    keyField = fields[0];
    if(!keyField.isAccessible()) {
        try {
            keyField.setAccessible(true);
        } catch (SecurityException e) {
            log.error("Error making key field accessible please use a public method and mark that as LookupKey", e);
            throw new IllegalArgumentException("Invalid class, DAO cannot be created.", e);
        }
    }
    Preconditions.checkArgument(ClassUtils.isAssignable(keyField.getType(), String.class), "Key field must be a string");
}

/**
 * Create a relational DAO.
 * @param sessionFactories List of session factories. One for each shard.
 * @param entityClass The class for which the dao will be used.
 * @param shardManager The {@link ShardManager} used to manage the bucket to shard mapping.
 */
public RelationalDao(List<SessionFactory> sessionFactories, Class<T> entityClass,
                     ShardManager shardManager, BucketIdExtractor<String> bucketIdExtractor) {
    this.shardManager = shardManager;
    this.bucketIdExtractor = bucketIdExtractor;
    this.daos = sessionFactories.stream().map(RelationalDaoPriv::new).collect(Collectors.toList());
    this.entityClass = entityClass;

    Field fields[] = FieldUtils.getFieldsWithAnnotation(entityClass, Id.class);
    Preconditions.checkArgument(fields.length != 0, "A field needs to be designated as @Id");
    Preconditions.checkArgument(fields.length == 1, "Only one field can be designated as @Id");
    keyField = fields[0];
    if(!keyField.isAccessible()) {
        try {
            keyField.setAccessible(true);
        } catch (SecurityException e) {
            log.error("Error making key field accessible please use a public method and mark that as @Id", e);
            throw new IllegalArgumentException("Invalid class, DAO cannot be created.", e);
        }
    }
}

private void injectContainers() {
  List<Field> fields = FieldUtils.getFieldsListWithAnnotation(testClass, InjectContainer.class);
  for (Field field : fields) {
    if (!Container.class.isAssignableFrom(field.getType())) {
      continue;
    }

    InjectContainer container = field.getAnnotation(InjectContainer.class);
    Container instance = controller.getContainer(container.name(), field.getType().asSubclass(Container.class));
    LOG.info("Binding [{}] -> [{}]", container.name(), instance.getName());
    try {
      FieldUtils.writeField(field, target, instance, true);
    } catch (IllegalAccessException e) {
      throw new IllegalStateException("Could not set field:" + field.getName());
    }
  }
}

private void buildFieldMap(Map<String, MappingBean> fieldMap, Set<String> fields, Class<?> sourceClass, Class<?> destinationClass){
    for(Field field: FieldUtils.getAllFields(sourceClass)){
        fields.add(field.getName());
        Optional<FieldMapping> optional = this.getFieldMapping(field, this.destinationClass);
        if(optional.isPresent()){
            FieldMapping fieldMapping = optional.get();
            MappingBean bean = new MappingBean();
            bean.setSourceField(field.getName());
            bean.setMappedField(Strings.isNullOrEmpty(fieldMapping.value())?field.getName():fieldMapping.value());
            bean.setMappedIn(fieldMapping.mappedIn());
            bean.setMappedOut(fieldMapping.mappedOut());
            bean.setIgnore(fieldMapping.ignore());
            fieldMap.put(field.getName(),bean);
        }
    }
}

/**
 * This is temporary workaround to bypass the validation stage of the
 * compiler while *still* doing the additional_validate stage. We are
 * bypassing the validation stage because it does a deep validation that we
 * don't have all the parts for yet in the offline compiler. Rather than
 * stop all work on that, we bypass it so that we can still do useful things
 * like find all your types, find all your methods, etc.
 * 
 */
@SuppressWarnings("unchecked")
private void callAdditionalPassVisitor(ApexCompiler compiler) {
    try {
        List<CodeUnit> allUnits = (List<CodeUnit>) FieldUtils.readDeclaredField(compiler, "allUnits", true);
        CompilerContext compilerContext = (CompilerContext) FieldUtils.readDeclaredField(compiler,
                "compilerContext", true);

        for (CodeUnit unit : allUnits) {
            Method getOperation = CompilerStage.ADDITIONAL_VALIDATE.getDeclaringClass()
                    .getDeclaredMethod("getOperation");
            getOperation.setAccessible(true);
            CompilerOperation operation = (CompilerOperation) getOperation
                    .invoke(CompilerStage.ADDITIONAL_VALIDATE);
            operation.invoke(compilerContext, unit);
        }
    } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
    }
}

@Test
public void testNetworkFluctuation() throws Exception {
    SuperMarket superMarket = new SuperMarket();
    HttpDiscountService mockedHttpDiscountService = mock(HttpDiscountService.class);
    FieldUtils.writeField(superMarket, "httpDiscountService", mockedHttpDiscountService, true);

    when(mockedHttpDiscountService.getDiscountFromRemoteService())
            .thenThrow(new SocketTimeoutException())
            .thenCallRealMethod();

    float price = superMarket.checkout(10);

    // 10 * 3.5 * 0.5 = 17.5
    assertEquals(price, 17.5f);
    verify(mockedHttpDiscountService, times(2)).getDiscountFromRemoteService();
}

private void injectValueInFirstArg(List<SlimAssertion> assertions, boolean not, Object contentToCheck) {
    SlimAssertion.getInstructions(assertions).forEach(instruction -> {
        try {
            String valueToInject = FitnesseMarkup.SELECTOR_VALUE_SEPARATOR + (not ? FitnesseMarkup.SELECTOR_VALUE_DENY_INDICATOR : StringUtils.EMPTY) + contentToCheck;
            Object args = FieldUtils.readField(instruction, SeleniumScriptTable.CALL_INSTRUCTION_ARGS_FIELD, true);
            Object[] argsToInject;
            if (args instanceof Object[] && ArrayUtils.getLength(args) > NumberUtils.INTEGER_ZERO) {
                argsToInject = (Object[]) args;
                argsToInject[NumberUtils.INTEGER_ZERO] += valueToInject;
            } else {
                argsToInject = ArrayUtils.toArray(valueToInject);
            }
            String methodName = Objects.toString(FieldUtils.readField(instruction, SeleniumScriptTable.CALL_INSTRUCTION_METHODNAME_FIELD, true));
            if (Objects.isNull(MethodUtils.getAccessibleMethod(SeleniumFixture.class, Objects.toString(methodName), ClassUtils.toClass(argsToInject)))) {
                SeleniumScriptTable.LOGGER.fine("Method for instruction not found on SeleniumFixture, injection aborted: " + instruction);
                return;
            }
            FieldUtils.writeField(instruction, SeleniumScriptTable.CALL_INSTRUCTION_ARGS_FIELD, argsToInject, true);
        } catch (IllegalArgumentException | ReflectiveOperationException e) {
            SeleniumScriptTable.LOGGER.log(Level.FINE, "Failed to inject check value using reflection", e);
        }
    });
}

@Override
public Analyzer getAnalyzer(Class<?> entityType) {
    if (jpaPropertiesProvider.isHibernateSearchElasticSearchEnabled()) {
        ExtendedSearchIntegrator searchIntegrator = Search.getFullTextEntityManager(getEntityManager())
                .getSearchFactory().unwrap(ExtendedSearchIntegrator.class);
        ScopedElasticsearchAnalyzer scopedAnalyzer = (ScopedElasticsearchAnalyzer) searchIntegrator.getAnalyzerReference(entityType).getAnalyzer();

        try {
            // these properties are package protected !
            ElasticsearchAnalyzer globalAnalyzer = (ElasticsearchAnalyzer) FieldUtils.getField(ScopedElasticsearchAnalyzer.class, "globalAnalyzer", true).get(scopedAnalyzer);
            @SuppressWarnings("unchecked")
            Map<String, ElasticsearchAnalyzer> analyzers = (Map<String, ElasticsearchAnalyzer>) FieldUtils.getField(ScopedElasticsearchAnalyzer.class, "scopedAnalyzers", true).get(scopedAnalyzer);

            Map<String, Analyzer> luceneAnalyzers = Maps.newHashMap();
            for (Entry<String, ElasticsearchAnalyzer> analyzer : analyzers.entrySet()) {
                luceneAnalyzers.put(analyzer.getKey(), getAnalyzer(analyzer.getValue().getName(null)));
            }
            return new ScopedLuceneAnalyzer(getAnalyzer(globalAnalyzer.getName(null)) /* parameter is not used */, luceneAnalyzers);
        } catch (IllegalAccessException e) {
            throw new RuntimeException("illegal access on scoped analyzer", e);
        }
    } else {
        return Search.getFullTextEntityManager(getEntityManager()).getSearchFactory().unwrap(SearchIntegrator.class).getAnalyzer(entityType);
    }
}

private void prepareFields() {
    viewsForInjection = new ArrayList<>();
    for (Field field : FieldUtils.getAllFields(this.getClass())) {
        if (field.isAnnotationPresent(InjectView.class)) {
            viewsForInjection.add(new ViewMembersInjector(field, field.getAnnotation(InjectView.class)));
        }
    }
}

@Override
public boolean sqlMapGenerated(GeneratedXmlFile sqlMap, IntrospectedTable introspectedTable) {
  try {
    // use reflect to fix the root comment
    Document document = (Document) FieldUtils.readDeclaredField(sqlMap, "document", true);
    ExtendedDocument extendedDocument = new ExtendedDocument(document);
    FieldUtils.writeDeclaredField(sqlMap, "document", extendedDocument, true);
    if (context.getCommentGenerator() instanceof CommentGenerator) {
      CommentGenerator cg = (CommentGenerator) context.getCommentGenerator();
      cg.addSqlMapFileComment(extendedDocument);
    }
  } catch (IllegalAccessException e) {
    e.printStackTrace();
  }
  return true;
}

@SuppressWarnings("unchecked")
protected void convertUseReflect(IntrospectedTable introspectedTable) {
  if (baseColumnsField == null || blobColumnsField == null) {
    baseColumnsField = FieldUtils.getField(IntrospectedTable.class, "baseColumns", true);
    blobColumnsField = FieldUtils.getField(IntrospectedTable.class, "blobColumns", true);
  }
  List<IntrospectedColumn> introspectedColumns = null;
  try {
    introspectedColumns = (List<IntrospectedColumn>) baseColumnsField.get(introspectedTable);
    convertForAll(introspectedColumns);
    //print("after calculate for base", introspectedColumns);
    baseColumnsField.set(introspectedTable, introspectedColumns);
    introspectedColumns = (List<IntrospectedColumn>) blobColumnsField.get(introspectedTable);
    convertForAll(introspectedColumns);
    //print("after calculate for blob", introspectedColumns);
    blobColumnsField.set(introspectedTable, introspectedColumns);

  } catch (IllegalArgumentException | IllegalAccessException e) {
    e.printStackTrace();
  }
}

@Override
public boolean validate(List<String> warnings) {
    boolean valid = true;
    srid = properties.getProperty(SRID_NAME);
    if(StringUtils.isEmpty(srid)){
        srid = "3857";
    }
    if(connection == null){
        try {
            connection = ConnectionFactory.getInstance().getConnection(context.getJdbcConnectionConfiguration());
        } catch (SQLException e) {
            e.printStackTrace();
            valid = false;
        }   
    }
    elementsList = FieldUtils.getField(XmlElement.class, "elements", true);
    return valid;
}

protected void checkAndReplaceInput(List<IntrospectedColumn> columns, TextElement te) {
  String sql = te.getContent();
  for(IntrospectedColumn column : columns){
    if(column.getFullyQualifiedJavaType().getShortName().equals("Geometry")){
        String paramStr = MyBatis3FormattingUtilities.getParameterClause(column);
        sql = StringUtils.replace(sql, paramStr, "ST_GeomFromText(" + paramStr + ","+srid+")"); //replace no prefix geo relate column
        paramStr = MyBatis3FormattingUtilities.getParameterClause(column, "record.");
        sql = StringUtils.replace(sql, paramStr, "ST_GeomFromText(" + paramStr + ","+srid+")"); //replace mbg generate prefix geo relate column
        paramStr = MyBatis3FormattingUtilities.getParameterClause(column, "item.");
        sql = StringUtils.replace(sql, paramStr, "ST_GeomFromText(" + paramStr + ","+srid+")"); //replace mbg batch plugin generate prefix geo relate column                
//              System.out.println();
//              System.out.println(sql);
    }
  }
  try {
    FieldUtils.writeDeclaredField(te, "content", sql, true);
  } catch (IllegalAccessException e) {
    e.printStackTrace();
  }
}

protected void checkAndReplaceOutput(List<IntrospectedColumn> columns, TextElement te) {
    String sql = te.getContent();
        for(IntrospectedColumn column : columns){
            if(column.getFullyQualifiedJavaType().getShortName().equals("Geometry")){
                String columnStr = null;
                if(column.isColumnNameDelimited()){
                    columnStr = "\""+column.getActualColumnName()+"\"";
                }else{
                    columnStr = column.getActualColumnName();
                }
                sql = StringUtils.replaceOnce(sql, columnStr, "ST_AsText("+columnStr+") as " + columnStr);
                //sql = sql.replace(column.getActualColumnName(), "ST_AsText("+column.getActualColumnName()+")");
//              System.out.println();
//              System.out.println(sql);
            }
        }
    try {
      FieldUtils.writeDeclaredField(te, "content", sql, true);
    } catch (IllegalAccessException e) {
      e.printStackTrace();
    }       
  }

/**
 * Gets the property.
 *
 * @param obj the obj
 * @param name the name
 * @param defaultValue the default value
 * @param forced whether or not to force access to the field
 * @return the property
 */
protected Object getProperty(Object obj, String name, Object defaultValue, boolean forced) {
  try {
    if (forced) {
      return FieldUtils.readField(obj, name, forced);
    } else {
      return PropertyUtils.isReadable(obj, name) ? PropertyUtils.getProperty(obj, name)
          : defaultValue;
    }
  } catch (IllegalArgumentException | IllegalAccessException | InvocationTargetException
      | NoSuchMethodException e) {
    logger.error("", e);
  }
  logger.debug("Could not access property '{}' of object '{}'", name, obj);
  return defaultValue;
}