code: def _validate(self, array_type, test_shape, dtype, s, kwargs):
      input_array = self.munge_input_array(
          array_type(test_shape, dtype), kwargs
      )
  
      orig_input_array = input_array
  
      np_input_array = numpy.asarray(input_array)
  
      if np_input_array.dtype == "clongdouble":
          np_input_array = numpy.complex128(input_array)
  
      elif np_input_array.dtype == "longdouble":
          np_input_array = numpy.float64(input_array)
  
      da_input_array = da.from_array(
          np_input_array, chunks=np_input_array.shape
      )
  
      with warnings.catch_warnings(record=True) as w:
          # We catch the warnings so as to pick up on when
          # a complex array is turned into a real array
  
          if "axes" in kwargs:
              validator_kwargs = {"axes": kwargs["axes"]}
          elif "axis" in kwargs:
              validator_kwargs = {"axis": kwargs["axis"]}
          else:
              validator_kwargs = {}
  
          if self.has_norm_kwarg and "norm" in kwargs:
              validator_kwargs["norm"] = kwargs["norm"]
  
          try:
              test_out_array = getattr(
                  self.validator_module, self.func
              )(da_input_array, s, **validator_kwargs)
  
          except Exception as e:
              interface_exception = None
              try:
                  getattr(self.test_interface, self.func)(
                      input_array, s, **kwargs
                  )
              except Exception as _interface_exception:
                  # It's necessary to assign the exception to the
                  # already defined variable in Python 3.
                  # See http://www.python.org/dev/peps/pep-3110/#semantic-changes
                  interface_exception = _interface_exception
  
              # If the test interface raised, so must this.
              self.assertEqual(
                  type(interface_exception),
                  type(e),
                  msg="Interface exception raised. "
                  + "Testing for: "
                  + repr(e),
              )
              return
  
          output_array = getattr(self.test_interface, self.func)(
              input_array, s, **kwargs
          )
  
          if functions[self.func] == "r2c":
              if input_array.dtype.kind == "c":
                  if len(w) > 0:
                      # Make sure a warning is raised
                      self.assertIs(
                          w[-1].category, numpy.ComplexWarning
                      )
  
      # convert dask arrays to NumPy ones prior to calling allclose
      output_np = output_array.compute()
      input_np = input_array.compute()
      test_out_array = test_out_array.compute()
  
      self.assertTrue(
          numpy.allclose(
              output_np, test_out_array, rtol=1e-2, atol=1e-4
          )
      )
  
      if input_np.real.dtype == numpy.float16:
          # FFTW output will never be single precision for half precision
          # inputs as there is no half-precision FFTW routine
          input_precision_dtype = numpy.float32
      else:
          input_precision_dtype = input_np.real.dtype
  
      self.assertEqual(input_precision_dtype, output_array.real.dtype)
  
      self.assertTrue(numpy.allclose(input_array, orig_input_array))
  
      return output_array
  
imports: from pyfftw import interfaces
  from .test_pyfftw_base import run_test_suites
  from .test_pyfftw_numpy_interface import complex_dtypes, real_dtypes
  from ._get_default_args import get_default_args
  import unittest
  import numpy
  import warnings
  import copy
label_desc: Use image node_id 5 for calling the InterfacesDaskFFTTestFFT obj's underlying member method code with example usage: obj._validate(array_type, test_shape, dtype, s, kwargs) and returns: output_array