code: def test_customized_mutate_population(
      space1: Space, rung_3: RungDict, budgets: list[BudgetTuple]
  ):
      """Verify customized mutated candidates is generated correctly."""
      customerized_dict = {
          "function": "orion.testing.algo.customized_mutate_example",
          "multiply_factor": 2.0,
          "add_factor": 1,
      }
      population_range = len(rung_3["results"])
      algo = EvolutionES(
          space1,
          repetitions=1,
          nums_population=population_range,
          mutate=customerized_dict,
      )
      algo.brackets[0] = BracketEVES(algo, budgets, 1)
  
      red_team = [0, 2]
      blue_team = [1, 3]
      rung_trials = list(rung_3["results"].values())
      for trial_index in range(population_range):
          objective, trial = rung_trials[trial_index]
          algo.performance[trial_index] = objective
          for ith_dim in [1, 2]:
              algo.population[ith_dim][trial_index] = trial.params[
                  algo.space[ith_dim].name
              ]
  
      org_data = np.stack(
          (
              list(algo.brackets[0].owner.population.values())[0],
              list(algo.brackets[0].owner.population.values())[1],
          ),
          axis=0,
      ).T
  
      org_data = copy.deepcopy(org_data)
  
      algo.brackets[0]._mutate_population(
          red_team,
          blue_team,
          rung_3["results"],
          population_range,
          fidelity=2,
      )
  
      mutated_data = np.stack(
          (
              list(algo.brackets[0].owner.population.values())[0],
              list(algo.brackets[0].owner.population.values())[1],
          ),
          axis=0,
      ).T
  
      # Winner team will be [0, 2], so [0, 2] will be remained, [1, 3] will be mutated.
      assert org_data.shape == mutated_data.shape
      assert (mutated_data[0] == org_data[0]).all()
      assert (mutated_data[2] == org_data[2]).all()
      assert (mutated_data[1] != org_data[1]).any()
      assert (mutated_data[3] != org_data[3]).any()
      assert (mutated_data[1] != org_data[0]).any()
      assert (mutated_data[3] != org_data[2]).any()
  
      # For each individual, mutation occurs in only one dimension chosen from two.
      # Customized test mutation function is divided by 2 for real type.
      if (
          mutated_data[1][0]
          == org_data[0][0] / customerized_dict["multiply_factor"]
      ):
          assert mutated_data[1][1] == org_data[0][1]
      else:
          assert (
              mutated_data[1][1]
              == org_data[0][1] / customerized_dict["multiply_factor"]
          )
  
      if (
          mutated_data[3][0]
          == org_data[2][0] / customerized_dict["multiply_factor"]
      ):
          assert mutated_data[3][1] == org_data[2][1]
      else:
          assert (
              mutated_data[3][1]
              == org_data[2][1] / customerized_dict["multiply_factor"]
          )
  
imports: from __future__ import annotations
  import copy
  from typing import ClassVar
  import numpy
  import pytest
  from test_hyperband import create_rung_from_points, create_trial_for_hb
  from orion.algo.evolution_es import BracketEVES, BudgetTuple, EvolutionES, compute_budgets
  from orion.algo.hyperband import RungDict
  from orion.algo.space import Fidelity, Real, Space
  from orion.core.utils import backward
  from orion.core.worker.trial import Trial
  from orion.testing.algo import BaseAlgoTests, TestPhase, _are_equal
  from orion.testing.trial import create_trial
label_desc: Use image node_id 14 for calling a global function with example usage: test_customized_mutate_population(space1, rung_3, budgets) without return types