Example usage for org.springframework.util ReflectionUtils makeAccessible

Introduction

In this page you can find the example usage for org.springframework.util ReflectionUtils makeAccessible.

Prototype

@SuppressWarnings("deprecation") 
public static void makeAccessible(Field field)

Source Link

Document

Make the given field accessible, explicitly setting it accessible if necessary.

Usage

From source file:com.ciphertool.genetics.algorithms.crossover.LiberalCrossoverAlgorithmTest.java

@Test
public void testSetMutateDuringCrossover() {
    boolean mutateDuringCrossoverToSet = true;

    LiberalCrossoverAlgorithm liberalCrossoverAlgorithm = new LiberalCrossoverAlgorithm();
    liberalCrossoverAlgorithm.setMutateDuringCrossover(mutateDuringCrossoverToSet);

    Field mutateDuringCrossoverField = ReflectionUtils.findField(LiberalCrossoverAlgorithm.class,
            "mutateDuringCrossover");
    ReflectionUtils.makeAccessible(mutateDuringCrossoverField);
    boolean mutateDuringCrossoverFromObject = (boolean) ReflectionUtils.getField(mutateDuringCrossoverField,
            liberalCrossoverAlgorithm);// w w w  . j a v  a  2s .  c  om

    assertEquals(mutateDuringCrossoverToSet, mutateDuringCrossoverFromObject);
}

From source file:com.ciphertool.genetics.PopulationTest.java

@Test
public void testSetFitnessComparator() {
    Population population = new Population();

    AscendingFitnessComparator ascendingFitnessComparator = new AscendingFitnessComparator();
    population.setFitnessComparator(ascendingFitnessComparator);

    Field fitnessComparatorField = ReflectionUtils.findField(Population.class, "fitnessComparator");
    ReflectionUtils.makeAccessible(fitnessComparatorField);
    AscendingFitnessComparator fitnessComparatorFromObject = (AscendingFitnessComparator) ReflectionUtils
            .getField(fitnessComparatorField, population);

    assertSame(ascendingFitnessComparator, fitnessComparatorFromObject);
}

From source file:com.alibaba.otter.shared.common.utils.zookeeper.ZooKeeperx.java

public void configMutliCluster(ZooKeeper zk) {
    if (_servers.size() == 1) {
        return;//w  ww  .  jav a 2s  .  co m
    }
    String cluster1 = _servers.get(0);
    try {
        if (_servers.size() > 1) {
            // accessible
            ReflectionUtils.makeAccessible(clientCnxnField);
            ReflectionUtils.makeAccessible(hostProviderField);
            ReflectionUtils.makeAccessible(serverAddressesField);

            // 
            for (int i = 1; i < _servers.size(); i++) {
                String cluster = _servers.get(i);
                // ?zk??
                ClientCnxn cnxn = (ClientCnxn) ReflectionUtils.getField(clientCnxnField, zk);
                HostProvider hostProvider = (HostProvider) ReflectionUtils.getField(hostProviderField, cnxn);
                List<InetSocketAddress> serverAddrs = (List<InetSocketAddress>) ReflectionUtils
                        .getField(serverAddressesField, hostProvider);
                // 
                serverAddrs.addAll(new ConnectStringParser(cluster).getServerAddresses());
            }
        }
    } catch (Exception e) {
        try {
            if (zk != null) {
                zk.close();
            }
        } catch (InterruptedException ie) {
            // ignore interrupt
        }
        throw new ZkException("zookeeper_create_error, serveraddrs=" + cluster1, e);
    }

}

From source file:com.ciphertool.genetics.algorithms.crossover.LiberalUnevaluatedCrossoverAlgorithmTest.java

@Test
public void testSetCoin() {
    Coin coinToSet = mock(Coin.class);
    LiberalUnevaluatedCrossoverAlgorithm liberalUnevaluatedCrossoverAlgorithm = new LiberalUnevaluatedCrossoverAlgorithm();
    liberalUnevaluatedCrossoverAlgorithm.setCoin(coinToSet);

    Field coinField = ReflectionUtils.findField(LiberalUnevaluatedCrossoverAlgorithm.class, "coin");
    ReflectionUtils.makeAccessible(coinField);
    Coin coinFromObject = (Coin) ReflectionUtils.getField(coinField, liberalUnevaluatedCrossoverAlgorithm);

    assertSame(coinToSet, coinFromObject);
}

From source file:ru.anr.base.BaseParent.java

/**
 * Injection of a private field into the given object. Of course, we are
 * against such a technique :-). But still in tests this is a very
 * convenient approach.//from   w  w w.j  av  a 2  s.c om
 *
 * @param target
 *            The target object
 * @param fieldName
 *            The name of the field to inject
 * @param field
 *            The field's value
 */
public static void inject(Object target, String fieldName, Object field) {

    Field f = ReflectionUtils.findField(target.getClass(), fieldName);
    Assert.notNull(f);

    ReflectionUtils.makeAccessible(f);
    ReflectionUtils.setField(f, target, field);
}

From source file:com.ciphertool.genetics.algorithms.mutation.LiberalMutationAlgorithmTest.java

@Test
public void testSetMaxMutationsPerChromosome() {
    Integer maxMutationsPerChromosomeToSet = 3;

    LiberalMutationAlgorithm liberalMutationAlgorithm = new LiberalMutationAlgorithm();
    liberalMutationAlgorithm.setMaxMutationsPerChromosome(maxMutationsPerChromosomeToSet);

    Field maxMutationsPerChromosomeField = ReflectionUtils.findField(LiberalMutationAlgorithm.class,
            "maxMutationsPerChromosome");
    ReflectionUtils.makeAccessible(maxMutationsPerChromosomeField);
    Integer maxMutationsPerChromosomeFromObject = (Integer) ReflectionUtils
            .getField(maxMutationsPerChromosomeField, liberalMutationAlgorithm);

    assertSame(maxMutationsPerChromosomeToSet, maxMutationsPerChromosomeFromObject);
}

From source file:org.cleverbus.test.AbstractTest.java

/**
 * Sets value of private field./*from   w w  w  .  j  a  va2  s  .c om*/
 *
 * @param target the target object
 * @param name   the field name
 * @param value  the value for setting to the field
 */
public static void setPrivateField(Object target, String name, Object value) {
    Field countField = ReflectionUtils.findField(target.getClass(), name);
    ReflectionUtils.makeAccessible(countField);
    ReflectionUtils.setField(countField, target, value);
}

From source file:com.ciphertool.zodiacengine.fitness.AbstractSolutionEvaluatorBaseTest.java

@Test
public void testClearHasMatchValues() {
    ConcreteSolutionEvaluatorBase abstractSolutionEvaluatorBase = new ConcreteSolutionEvaluatorBase();

    Field logField = ReflectionUtils.findField(ConcreteSolutionEvaluatorBase.class, "log");
    Logger mockLogger = mock(Logger.class);
    ReflectionUtils.makeAccessible(logField);
    ReflectionUtils.setField(logField, abstractSolutionEvaluatorBase, mockLogger);

    for (PlaintextSequence plaintextSequence : simpleSolution.getPlaintextCharacters()) {
        plaintextSequence.setHasMatch(true);
        assertTrue(plaintextSequence.getHasMatch());
    }//from   w w w.j  a  v  a 2s.c  om

    abstractSolutionEvaluatorBase.clearHasMatchValues(simpleSolution);

    for (PlaintextSequence plaintextSequence : simpleSolution.getPlaintextCharacters()) {
        assertFalse(plaintextSequence.getHasMatch());
    }

    verifyZeroInteractions(mockLogger);
}

From source file:com.ciphertool.genetics.algorithms.ConcurrentMultigenerationalGeneticAlgorithmTest.java

@SuppressWarnings("unchecked")
@Test/*from  w w  w . j  a  va  2s  .c  o m*/
public void testCrossover() {
    ConcurrentMultigenerationalGeneticAlgorithm concurrentMultigenerationalGeneticAlgorithm = new ConcurrentMultigenerationalGeneticAlgorithm();
    concurrentMultigenerationalGeneticAlgorithm.setTaskExecutor(taskExecutor);

    Population population = new Population();
    FitnessEvaluator fitnessEvaluatorMock = mock(FitnessEvaluator.class);
    when(fitnessEvaluatorMock.evaluate(any(Chromosome.class))).thenReturn(DEFAULT_FITNESS_VALUE);
    population.setFitnessEvaluator(fitnessEvaluatorMock);

    Selector selectorMock = mock(Selector.class);
    population.setSelector(selectorMock);
    when(selectorMock.getNextIndex(anyListOf(Chromosome.class), any(Double.class))).thenReturn(0, 1, 2, 3, 4);

    int initialPopulationSize = 50;

    for (int i = 0; i < initialPopulationSize; i++) {
        population.addIndividual(new MockKeylessChromosome());
    }

    concurrentMultigenerationalGeneticAlgorithm.setPopulation(population);

    CrossoverAlgorithm crossoverAlgorithmMock = mock(CrossoverAlgorithm.class);

    Field crossoverAlgorithmField = ReflectionUtils.findField(ConcurrentMultigenerationalGeneticAlgorithm.class,
            "crossoverAlgorithm");
    ReflectionUtils.makeAccessible(crossoverAlgorithmField);
    ReflectionUtils.setField(crossoverAlgorithmField, concurrentMultigenerationalGeneticAlgorithm,
            crossoverAlgorithmMock);

    Chromosome chromosomeToReturn = new MockKeylessChromosome();
    when(crossoverAlgorithmMock.crossover(any(Chromosome.class), any(Chromosome.class)))
            .thenReturn(Arrays.asList(chromosomeToReturn));

    GeneticAlgorithmStrategy strategy = new GeneticAlgorithmStrategy();
    strategy.setCrossoverRate(0.1);

    Field strategyField = ReflectionUtils.findField(ConcurrentMultigenerationalGeneticAlgorithm.class,
            "strategy");
    ReflectionUtils.makeAccessible(strategyField);
    ReflectionUtils.setField(strategyField, concurrentMultigenerationalGeneticAlgorithm, strategy);

    Field ineligibleForReproductionField = ReflectionUtils.findField(Population.class,
            "ineligibleForReproduction");
    ReflectionUtils.makeAccessible(ineligibleForReproductionField);
    List<Chromosome> ineligibleForReproductionFromObject = (List<Chromosome>) ReflectionUtils
            .getField(ineligibleForReproductionField, population);

    assertEquals(0, ineligibleForReproductionFromObject.size());

    int childrenProduced = concurrentMultigenerationalGeneticAlgorithm.crossover(initialPopulationSize);

    ineligibleForReproductionFromObject = (List<Chromosome>) ReflectionUtils
            .getField(ineligibleForReproductionField, population);

    /*
     * The population size should be reduced by the number of parents used
     * during crossover.
     */
    assertEquals(40, population.size());

    assertEquals(5, childrenProduced);

    // There should be 10 ineligible parents, along with the 5 children
    assertEquals(15, ineligibleForReproductionFromObject.size());

    verify(selectorMock, times(10)).getNextIndex(anyListOf(Chromosome.class), any(Double.class));

    verify(crossoverAlgorithmMock, times(5)).crossover(any(Chromosome.class), any(Chromosome.class));
}

From source file:at.ac.tuwien.infosys.jcloudscale.test.integration.base.TestFieldHandling.java

@Test
public void testPrivateFieldGetViaReflection() throws Exception {

    assertEquals(0, cs.countCloudObjects());
    FieldCloudObject ob = new FieldCloudObject();
    assertEquals(1, cs.countCloudObjects());

    ob.setPrivateField("private_changed");

    // we need to go to the superclass as this is in fact a dynamic proxy generated
    // by CGLib//from w  w  w. ja v  a 2s  . c  o  m
    Field field = ob.getClass().getSuperclass().getDeclaredField("privateField");
    ReflectionUtils.makeAccessible(field);
    String val = (String) field.get(ob);

    assertEquals(val, "private_changed");

}