class_docstr: A base test class for all optimisers on Euclidean domains. 
docstr: Testing random optimiser with ask tell interface. 
docstr_tok: ["Testing","random","optimiser","with","ask","tell","interface","."]
code: def test_ask_tell(self):
      """Testing random optimiser with ask tell interface."""
      self.report(
          "Testing %s using the ask-tell interface." % (type(self))
      )
      domain = domains.EuclideanDomain(
          [[0, 2.3], [3.4, 8.9], [0.12, 1.0]]
      )
      fidel_bounds = [[0, 1]]
      fidel_space = domains.EuclideanDomain(fidel_bounds)
      fidel_to_opt = [0.5]
      fidel_cost = get_mf_cost_function(fidel_bounds)
      func_caller = EuclideanFunctionCaller(
          None,
          domain,
          raw_fidel_space=fidel_space,
          fidel_cost_func=fidel_cost,
          raw_fidel_to_opt=fidel_to_opt,
      )
      opt = random_optimiser.MFEuclideanRandomOptimiser(
          func_caller, ask_tell_mode=True
      )
      opt.initialise()
  
      def evaluate(z, x):
          return get_syn_func_caller(
              "hartmann3",
              noise_type="gauss",
              noise_scale=0.1,
              fidel_dim=1,
          ).func(z, x)
  
      best_z, best_x, best_y = None, None, float("-inf")
      for _ in range(60):
          point = opt.ask()
          z, x = point[0], point[1]
          y = evaluate(z, x)
          opt.tell([(z, x, y)])
          self.report("z: %s, x: %s, y: %s" % (z, x, y))
          if y > best_y:
              best_z, best_x, best_y = z, x, y
      self.report(
          "-----------------------------------------------------"
      )
      self.report(
          "Optimal Value: %s, Optimal Point: %s (Fidel: %s)"
          % (best_y, best_x, best_z)
      )
  
      self.report(
          "-----------------------------------------------------"
      )
      self.report(
          "Regular optimisation using maximise_multifidelity_function"
      )
      val, pt, _ = maximise_multifidelity_function(
          evaluate,
          fidel_space,
          domain,
          fidel_to_opt,
          fidel_cost,
          60,
          opt_method="rand",
      )
      self.report("Optimal Value: %s, Optimal Point: %s" % (val, pt))
  
imports: import numpy
  from ..exd import domains
  from .None import random_optimiser
  from ..exd.experiment_caller import EuclideanFunctionCaller
  from ..exd.worker_manager import SyntheticWorkerManager
  from ..apis.opt import maximise_function, maximise_multifidelity_function
  from ..utils.ancillary_utils import is_nondecreasing, get_list_of_floats_as_str, get_rounded_list
  from ..utils.base_test_class import BaseTestClass, execute_tests
  from ..utils.euclidean_synthetic_functions import get_syn_func_caller, get_mf_cost_function
  from ..utils import reporters
label_desc: Use image node_id 4 for calling the MFEuclideanOptimisersBaseTestCase obj's underlying member method code with example usage: obj.test_ask_tell() and returns: get_syn_func_caller