Example usage for org.springframework.util ReflectionUtils setField

Introduction

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

Prototype

public static void setField(Field field, @Nullable Object target, @Nullable Object value) 

Source Link

Document

Set the field represented by the supplied Field field object on the specified Object target object to the specified value .

Usage

From source file:fragment.web.TasksControllerTest.java

@Test
public void testActOnPendingActionRejectWithoutMemo() {
    try {/*www.ja  v  a2 s.  com*/
        Tenant tenant = tenantService.get("dfc84388-d44d-4d8e-9d6a-a62c1c16b7e4");
        BusinessTransaction bt = new TenantStateChangeTransaction();
        bt.setUuid(UUID.randomUUID().toString());
        bt.setWorkflowId("1e42822b-cad6-4dc0-bb77-99abb9395f1a");

        Field field = ReflectionUtils.findField(BusinessTransaction.class, "id");
        field.setAccessible(true);
        ReflectionUtils.setField(field, bt, 1l);

        Task task = new Task();
        task.setActorRole(authorityService.findByAuthority("ROLE_FINANCE_CRUD"));
        task.setCreatedAt(new Date());
        task.setState(com.citrix.cpbm.core.workflow.model.Task.State.PENDING);
        task.setTenant(tenant);
        task.setUser(tenant.getOwner());
        task.setUpdatedBy(getRootUser());
        task.setBusinessTransaction(bt);
        task.setType("FINANCE_APPROVAL");
        task.setDisplayMode(DisplayMode.POPUP);
        task = taskService.save(task);
        String memo = "";
        tasksController.actOnApprovalTask(task.getUuid(), Task.State.FAILURE.toString(), memo, request);
    } catch (Exception e) {

        Assert.assertEquals("Memo is required in case of Rejection", e.getMessage());
    }
}

---

From source file:com.ciphertool.zodiacengine.service.GeneticCipherSolutionServiceTest.java

@Test
public void testResume_ExceptionThrown() throws IOException {
    GeneticCipherSolutionService geneticCipherSolutionService = new GeneticCipherSolutionService();
    geneticCipherSolutionService.toggleRunning();

    GeneticAlgorithm geneticAlgorithm = mock(GeneticAlgorithm.class);
    doThrow(IllegalStateException.class).when(geneticAlgorithm).proceedWithNextGeneration();

    Population population = new Population();
    SolutionChromosome solutionChromosome = new SolutionChromosome();
    solutionChromosome.setEvaluationNeeded(false);
    population.addIndividual(solutionChromosome);
    when(geneticAlgorithm.getPopulation()).thenReturn(population);

    geneticCipherSolutionService.setGeneticAlgorithm(geneticAlgorithm);

    Runtime runtimeMock = mock(Runtime.class);

    Field runtimeField = ReflectionUtils.findField(GeneticCipherSolutionService.class, "runtime");
    ReflectionUtils.makeAccessible(runtimeField);
    ReflectionUtils.setField(runtimeField, geneticCipherSolutionService, runtimeMock);

    String[] commandsAfter = { "command1", "command2" };
    geneticCipherSolutionService.setCommandsAfter(commandsAfter);

    SolutionDao solutionDaoMock = mock(SolutionDao.class);
    geneticCipherSolutionService.setSolutionDao(solutionDaoMock);

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

    doNothing().when(mockLogger).error(anyString(), any(Throwable.class));

    assertTrue(geneticCipherSolutionService.isRunning());
    geneticCipherSolutionService.resume();
    assertFalse(geneticCipherSolutionService.isRunning());

    verify(solutionDaoMock, times(1)).insert(same(solutionChromosome));

    verify(mockLogger, times(1)).error(anyString(), any(Throwable.class));

    /*/*from ww w  . ja va 2  s . c o m*/
     * These commands should still get called even though an exception was
     * caught
     */
    verify(runtimeMock, times(1)).exec(eq("command1"));
    verify(runtimeMock, times(1)).exec(eq("command2"));
    verifyNoMoreInteractions(runtimeMock);
}

---

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

@Test
public void testProceedWithNextGeneration() {
    MultigenerationalGeneticAlgorithm multigenerationalGeneticAlgorithm = new MultigenerationalGeneticAlgorithm();

    int initialPopulationSize = 100;
    int populationSize = 100;
    int index = 0;
    double survivalRate = 0.9;
    double mutationRate = 0.1;
    double crossoverRate = 0.1;

    Population populationMock = mock(Population.class);

    List<Chromosome> individuals = new ArrayList<Chromosome>();
    for (int i = 0; i < initialPopulationSize; i++) {
        individuals.add(new MockKeylessChromosome());
    }// ww  w. jav a2s .c o  m

    when(populationMock.selectIndex()).thenReturn(index);
    when(populationMock.getIndividuals()).thenReturn(individuals);
    when(populationMock.size()).thenReturn(initialPopulationSize);
    when(populationMock.selectIndex()).thenReturn(0);
    multigenerationalGeneticAlgorithm.setPopulation(populationMock);

    GeneticAlgorithmStrategy strategyToSet = new GeneticAlgorithmStrategy();
    strategyToSet.setPopulationSize(populationSize);
    strategyToSet.setSurvivalRate(survivalRate);
    strategyToSet.setMutationRate(mutationRate);
    strategyToSet.setCrossoverRate(crossoverRate);

    Field strategyField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class, "strategy");
    ReflectionUtils.makeAccessible(strategyField);
    ReflectionUtils.setField(strategyField, multigenerationalGeneticAlgorithm, strategyToSet);

    SelectionAlgorithm selectionAlgorithmMock = mock(SelectionAlgorithm.class);

    Field selectionAlgorithmField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class,
            "selectionAlgorithm");
    ReflectionUtils.makeAccessible(selectionAlgorithmField);
    ReflectionUtils.setField(selectionAlgorithmField, multigenerationalGeneticAlgorithm,
            selectionAlgorithmMock);

    Field generationCountField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class,
            "generationCount");
    ReflectionUtils.makeAccessible(generationCountField);
    ReflectionUtils.setField(generationCountField, multigenerationalGeneticAlgorithm, 0);

    MutationAlgorithm mutationAlgorithmMock = mock(MutationAlgorithm.class);
    Field mutationAlgorithmField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class,
            "mutationAlgorithm");
    ReflectionUtils.makeAccessible(mutationAlgorithmField);
    ReflectionUtils.setField(mutationAlgorithmField, multigenerationalGeneticAlgorithm, mutationAlgorithmMock);

    CrossoverAlgorithm crossoverAlgorithmMock = mock(CrossoverAlgorithm.class);

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

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

    ExecutionStatistics executionStatistics = new ExecutionStatistics();
    Field executionStatisticsField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class,
            "executionStatistics");
    ReflectionUtils.makeAccessible(executionStatisticsField);
    ReflectionUtils.setField(executionStatisticsField, multigenerationalGeneticAlgorithm, executionStatistics);

    assertEquals(0, executionStatistics.getGenerationStatisticsList().size());

    multigenerationalGeneticAlgorithm.proceedWithNextGeneration();

    assertEquals(1, executionStatistics.getGenerationStatisticsList().size());

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

    int generationCountFromObject = (int) ReflectionUtils.getField(generationCountField,
            multigenerationalGeneticAlgorithm);
    assertEquals(1, generationCountFromObject);

    verify(selectionAlgorithmMock, times(1)).select(same(populationMock), eq(populationSize), eq(survivalRate));
    verifyNoMoreInteractions(selectionAlgorithmMock);

    verify(populationMock, times(30)).selectIndex();
    verify(populationMock, times(30)).getIndividuals();
    verify(populationMock, times(30)).makeIneligibleForReproduction(index);
    verify(populationMock, times(20)).addIndividualAsIneligible(any(Chromosome.class));
    verify(populationMock, times(5)).size();
    verify(populationMock, times(1)).increaseAge();
    verify(populationMock, times(1)).resetEligibility();
    verify(populationMock, times(1)).breed(populationSize);
    verify(populationMock, times(1)).evaluateFitness(any(GenerationStatistics.class));
    verifyNoMoreInteractions(populationMock);

    verify(mutationAlgorithmMock, times(10)).mutateChromosome(any(Chromosome.class));
    verifyNoMoreInteractions(mutationAlgorithmMock);

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

---

From source file:com.ciphertool.zodiacengine.service.GeneticCipherSolutionServiceTest.java

@Test
public void testRunAlgorithmAutonomously() throws IOException {
    GeneticCipherSolutionService geneticCipherSolutionService = new GeneticCipherSolutionService();
    geneticCipherSolutionService.toggleRunning();

    GeneticAlgorithm geneticAlgorithm = mock(GeneticAlgorithm.class);

    Population population = new Population();
    SolutionChromosome solutionChromosome = new SolutionChromosome();
    solutionChromosome.setEvaluationNeeded(false);
    population.addIndividual(solutionChromosome);
    when(geneticAlgorithm.getPopulation()).thenReturn(population);

    geneticCipherSolutionService.setGeneticAlgorithm(geneticAlgorithm);

    SolutionDao solutionDaoMock = mock(SolutionDao.class);
    geneticCipherSolutionService.setSolutionDao(solutionDaoMock);

    GenericCallback genericCallbackMock = mock(GenericCallback.class);

    Runtime runtimeMock = mock(Runtime.class);

    Field runtimeField = ReflectionUtils.findField(GeneticCipherSolutionService.class, "runtime");
    ReflectionUtils.makeAccessible(runtimeField);
    ReflectionUtils.setField(runtimeField, geneticCipherSolutionService, runtimeMock);

    String[] commandsAfter = { "command1", "command2" };
    geneticCipherSolutionService.setCommandsAfter(commandsAfter);

    assertTrue(geneticCipherSolutionService.isRunning());
    geneticCipherSolutionService.runAlgorithmAutonomously(genericCallbackMock);
    assertFalse(geneticCipherSolutionService.isRunning());

    verify(solutionDaoMock, times(1)).insert(same(solutionChromosome));

    verify(genericCallbackMock, times(1)).doCallback();

    /*//w ww  . j  a v a 2  s  .  c  om
     * These commands should still get called even though an exception was
     * caught
     */
    verify(runtimeMock, times(1)).exec(eq("command1"));
    verify(runtimeMock, times(1)).exec(eq("command2"));
    verifyNoMoreInteractions(runtimeMock);

    verify(geneticAlgorithm, times(1)).evolveAutonomously();
}

---

From source file:com.ciphertool.zodiacengine.service.GeneticCipherSolutionServiceTest.java

@Test
public void testRunAlgorithmAutonomously_ExceptionThrown() throws IOException {
    GeneticCipherSolutionService geneticCipherSolutionService = new GeneticCipherSolutionService();
    geneticCipherSolutionService.toggleRunning();

    GeneticAlgorithm geneticAlgorithm = mock(GeneticAlgorithm.class);

    Population population = new Population();
    SolutionChromosome solutionChromosome = new SolutionChromosome();
    solutionChromosome.setEvaluationNeeded(false);
    population.addIndividual(solutionChromosome);
    when(geneticAlgorithm.getPopulation()).thenReturn(population);

    doThrow(new IllegalStateException()).when(geneticAlgorithm).evolveAutonomously();

    geneticCipherSolutionService.setGeneticAlgorithm(geneticAlgorithm);

    SolutionDao solutionDaoMock = mock(SolutionDao.class);
    geneticCipherSolutionService.setSolutionDao(solutionDaoMock);

    GenericCallback genericCallbackMock = mock(GenericCallback.class);

    Runtime runtimeMock = mock(Runtime.class);

    Field runtimeField = ReflectionUtils.findField(GeneticCipherSolutionService.class, "runtime");
    ReflectionUtils.makeAccessible(runtimeField);
    ReflectionUtils.setField(runtimeField, geneticCipherSolutionService, runtimeMock);

    String[] commandsAfter = { "command1", "command2" };
    geneticCipherSolutionService.setCommandsAfter(commandsAfter);

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

    doNothing().when(mockLogger).error(anyString(), any(Throwable.class));

    assertTrue(geneticCipherSolutionService.isRunning());
    geneticCipherSolutionService.runAlgorithmAutonomously(genericCallbackMock);
    assertFalse(geneticCipherSolutionService.isRunning());

    verify(solutionDaoMock, times(1)).insert(same(solutionChromosome));

    verify(genericCallbackMock, times(1)).doCallback();

    verify(mockLogger, times(1)).error(anyString(), any(Throwable.class));

    /*/*from  w ww . ja va  2s  .c  o m*/
     * These commands should still get called even though an exception was
     * caught
     */
    verify(runtimeMock, times(1)).exec(eq("command1"));
    verify(runtimeMock, times(1)).exec(eq("command2"));
    verifyNoMoreInteractions(runtimeMock);

    verify(geneticAlgorithm, times(1)).evolveAutonomously();
}

---

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

@Test
public void testValidateParameters_NoErrors() {
    MultigenerationalGeneticAlgorithm multigenerationalGeneticAlgorithm = new MultigenerationalGeneticAlgorithm();

    GeneticAlgorithmStrategy strategyToSet = new GeneticAlgorithmStrategy();
    strategyToSet.setGeneticStructure(new Object());
    strategyToSet.setPopulationSize(1);/*from w w w . ja va2  s.c o m*/
    strategyToSet.setLifespan(0);
    strategyToSet.setSurvivalRate(0.1);
    strategyToSet.setMutationRate(0.0);
    strategyToSet.setMaxMutationsPerIndividual(0);
    strategyToSet.setCrossoverRate(0.0);
    strategyToSet.setMutateDuringCrossover(false);
    strategyToSet.setMaxGenerations(-1);
    strategyToSet.setCrossoverAlgorithm(mock(CrossoverAlgorithm.class));
    strategyToSet.setFitnessEvaluator(mock(FitnessEvaluator.class));
    strategyToSet.setMutationAlgorithm(mock(MutationAlgorithm.class));
    strategyToSet.setSelectionAlgorithm(mock(SelectionAlgorithm.class));
    strategyToSet.setSelector(mock(Selector.class));

    Field strategyField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class, "strategy");
    ReflectionUtils.makeAccessible(strategyField);
    ReflectionUtils.setField(strategyField, multigenerationalGeneticAlgorithm, strategyToSet);
}

---

From source file:com.ciphertool.zodiacengine.service.GeneticCipherSolutionServiceTest.java

@Test
public void testRunAlgorithmStepwise_ExceptionThrown() throws IOException {
    GeneticCipherSolutionService geneticCipherSolutionService = new GeneticCipherSolutionService();
    geneticCipherSolutionService.toggleRunning();

    GeneticAlgorithm geneticAlgorithm = mock(GeneticAlgorithm.class);
    doThrow(IllegalStateException.class).when(geneticAlgorithm).initialize();

    Population population = new Population();
    SolutionChromosome solutionChromosome = new SolutionChromosome();
    solutionChromosome.setEvaluationNeeded(false);
    population.addIndividual(solutionChromosome);
    when(geneticAlgorithm.getPopulation()).thenReturn(population);

    geneticCipherSolutionService.setGeneticAlgorithm(geneticAlgorithm);

    Runtime runtimeMock = mock(Runtime.class);

    Field runtimeField = ReflectionUtils.findField(GeneticCipherSolutionService.class, "runtime");
    ReflectionUtils.makeAccessible(runtimeField);
    ReflectionUtils.setField(runtimeField, geneticCipherSolutionService, runtimeMock);

    String[] commandsAfter = { "command1", "command2" };
    geneticCipherSolutionService.setCommandsAfter(commandsAfter);

    SolutionDao solutionDaoMock = mock(SolutionDao.class);
    geneticCipherSolutionService.setSolutionDao(solutionDaoMock);

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

    doNothing().when(mockLogger).error(anyString(), any(Throwable.class));

    assertTrue(geneticCipherSolutionService.isRunning());
    geneticCipherSolutionService.runAlgorithmStepwise();
    assertFalse(geneticCipherSolutionService.isRunning());

    verify(solutionDaoMock, times(1)).insert(same(solutionChromosome));

    verify(mockLogger, times(1)).error(anyString(), any(Throwable.class));

    /*//from w w  w  . ja v  a2 s.  c o  m
     * These commands should still get called even though an exception was
     * caught
     */
    verify(runtimeMock, times(1)).exec(eq("command1"));
    verify(runtimeMock, times(1)).exec(eq("command2"));
    verifyNoMoreInteractions(runtimeMock);
}

---

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

@Test
public void testValidateParameters_AllErrors() {
    MultigenerationalGeneticAlgorithm multigenerationalGeneticAlgorithm = new MultigenerationalGeneticAlgorithm();

    GeneticAlgorithmStrategy strategyToSet = new GeneticAlgorithmStrategy();
    strategyToSet.setGeneticStructure(null);
    strategyToSet.setPopulationSize(0);// w w w.j a  va2s  .c  o  m
    strategyToSet.setLifespan(null);

    /*
     * This must be set via reflection because the setter method does its
     * own validation
     */
    Field survivalRateField = ReflectionUtils.findField(GeneticAlgorithmStrategy.class, "survivalRate");
    ReflectionUtils.makeAccessible(survivalRateField);
    ReflectionUtils.setField(survivalRateField, strategyToSet, -0.1);

    /*
     * This must be set via reflection because the setter method does its
     * own validation
     */
    Field mutationRateField = ReflectionUtils.findField(GeneticAlgorithmStrategy.class, "mutationRate");
    ReflectionUtils.makeAccessible(mutationRateField);
    ReflectionUtils.setField(mutationRateField, strategyToSet, -0.1);

    strategyToSet.setMaxMutationsPerIndividual(-1);

    /*
     * This must be set via reflection because the setter method does its
     * own validation
     */
    Field crossoverRateField = ReflectionUtils.findField(GeneticAlgorithmStrategy.class, "crossoverRate");
    ReflectionUtils.makeAccessible(crossoverRateField);
    ReflectionUtils.setField(crossoverRateField, strategyToSet, -0.1);

    strategyToSet.setMutateDuringCrossover(null);
    strategyToSet.setMaxGenerations(0);
    strategyToSet.setCrossoverAlgorithm(null);
    strategyToSet.setFitnessEvaluator(null);
    strategyToSet.setMutationAlgorithm(null);
    strategyToSet.setSelectionAlgorithm(null);
    strategyToSet.setSelector(null);

    Field strategyField = ReflectionUtils.findField(MultigenerationalGeneticAlgorithm.class, "strategy");
    ReflectionUtils.makeAccessible(strategyField);
    ReflectionUtils.setField(strategyField, multigenerationalGeneticAlgorithm, strategyToSet);

    boolean exceptionCaught = false;

    try {
        multigenerationalGeneticAlgorithm.validateParameters();
    } catch (IllegalStateException ise) {
        String expectedMessage = "Unable to execute genetic algorithm because one or more of the required parameters are missing.  The validation errors are:";
        expectedMessage += "\n\t-Parameter 'geneticStructure' cannot be null.";
        expectedMessage += "\n\t-Parameter 'populationSize' must be greater than zero.";
        expectedMessage += "\n\t-Parameter 'lifespan' cannot be null.";
        expectedMessage += "\n\t-Parameter 'survivalRate' must be greater than zero.";
        expectedMessage += "\n\t-Parameter 'mutationRate' must be greater than or equal to zero.";
        expectedMessage += "\n\t-Parameter 'maxMutationsPerIndividual' must be greater than or equal to zero.";
        expectedMessage += "\n\t-Parameter 'crossoverRate' must be greater than or equal to zero.";
        expectedMessage += "\n\t-Parameter 'mutateDuringCrossover' cannot be null.";
        expectedMessage += "\n\t-Parameter 'maxGenerations' cannot be null and must not equal zero.";
        expectedMessage += "\n\t-Parameter 'crossoverAlgorithm' cannot be null.";
        expectedMessage += "\n\t-Parameter 'fitnessEvaluator' cannot be null.";
        expectedMessage += "\n\t-Parameter 'mutationAlgorithm' cannot be null.";
        expectedMessage += "\n\t-Parameter 'selectionAlgorithm' cannot be null.";
        expectedMessage += "\n\t-Parameter 'selectorMethod' cannot be null.";

        assertEquals(expectedMessage, ise.getMessage());

        exceptionCaught = true;
    }

    assertTrue(exceptionCaught);
}

---

From source file:com.ciphertool.zodiacengine.service.GeneticCipherSolutionServiceTest.java

@Test
public void testEnd() throws IOException {
    GeneticCipherSolutionService geneticCipherSolutionService = new GeneticCipherSolutionService();
    geneticCipherSolutionService.toggleRunning();

    GeneticAlgorithm geneticAlgorithm = mock(GeneticAlgorithm.class);
    Population population = new Population();

    SolutionChromosome solutionChromosome = new SolutionChromosome();
    solutionChromosome.setEvaluationNeeded(false);
    population.addIndividual(solutionChromosome);
    when(geneticAlgorithm.getPopulation()).thenReturn(population);
    geneticCipherSolutionService.setGeneticAlgorithm(geneticAlgorithm);

    Runtime runtimeMock = mock(Runtime.class);

    Field runtimeField = ReflectionUtils.findField(GeneticCipherSolutionService.class, "runtime");
    ReflectionUtils.makeAccessible(runtimeField);
    ReflectionUtils.setField(runtimeField, geneticCipherSolutionService, runtimeMock);

    String[] commandsAfter = { "command1", "command2" };
    geneticCipherSolutionService.setCommandsAfter(commandsAfter);

    SolutionDao solutionDaoMock = mock(SolutionDao.class);
    geneticCipherSolutionService.setSolutionDao(solutionDaoMock);

    assertTrue(geneticCipherSolutionService.isRunning());
    geneticCipherSolutionService.end();/*from  w  ww  .ja  v a2  s .c om*/
    assertFalse(geneticCipherSolutionService.isRunning());

    verify(solutionDaoMock, times(1)).insert(same(solutionChromosome));

    verify(runtimeMock, times(1)).exec(eq("command1"));
    verify(runtimeMock, times(1)).exec(eq("command2"));
    verifyNoMoreInteractions(runtimeMock);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• »