code: def test_make_regression(
      n_samples,
      n_features,
      n_informative,
      n_targets,
      bias,
      effective_rank,
      tail_strength,
      noise,
      shuffle,
      coef,
      n_parts,
      order,
      use_full_low_rank,
      client,
  ):
      c = client
      from cuml.dask.datasets import make_regression
  
      result = make_regression(
          n_samples=n_samples,
          n_features=n_features,
          n_informative=n_informative,
          n_targets=n_targets,
          bias=bias,
          effective_rank=effective_rank,
          noise=noise,
          shuffle=shuffle,
          coef=coef,
          n_parts=n_parts,
          use_full_low_rank=use_full_low_rank,
          order=order,
      )
  
      if coef:
          out, values, coefs = result
      else:
          out, values = result
  
      assert out.shape == (n_samples, n_features), "out shape mismatch"
  
      if n_targets > 1:
          assert values.shape == (
              n_samples,
              n_targets,
          ), "values shape mismatch"
      else:
          assert values.shape == (n_samples,), "values shape mismatch"
  
      assert len(out.chunks[0]) == n_parts
      assert len(out.chunks[1]) == 1
  
      if coef:
          if n_targets > 1:
              assert coefs.shape == (
                  n_features,
                  n_targets,
              ), "coefs shape mismatch"
              assert len(coefs.chunks[1]) == 1
          else:
              assert coefs.shape == (
                  n_features,
              ), "coefs shape mismatch"
              assert len(coefs.chunks[0]) == 1
  
          test1 = da.all(da.sum(coefs != 0.0, axis=0) == n_informative)
  
          std_test2 = da.std(
              values - (da.dot(out, coefs) + bias), axis=0
          )
  
          test1, std_test2 = da.compute(test1, std_test2)
  
          diff = cp.abs(1.0 - std_test2)
          test2 = cp.all(diff < 1.5 * 10 ** (-1.0))
  
          assert test1, "Unexpected number of informative features"
  
          assert test2, "Unexpectedly incongruent outputs"
  
      data_ddh = DistributedDataHandler.create(
          data=(out, values), client=c
      )
      out_part, value_part = data_ddh.gpu_futures[0][1].result()
  
      if coef:
          coefs_ddh = DistributedDataHandler.create(
              data=coefs, client=c
          )
          coefs_part = coefs_ddh.gpu_futures[0][1].result()
      if order == "F":
          assert out_part.flags["F_CONTIGUOUS"]
          if n_targets > 1:
              assert value_part.flags["F_CONTIGUOUS"]
              if coef:
                  assert coefs_part.flags["F_CONTIGUOUS"]
      elif order == "C":
          assert out_part.flags["C_CONTIGUOUS"]
          if n_targets > 1:
              assert value_part.flags["C_CONTIGUOUS"]
              if coef:
                  assert coefs_part.flags["C_CONTIGUOUS"]
  
file_path: cuml/python/cuml/tests/dask/test_dask_datasets.py
imports: from cuml.dask.common.part_utils import _extract_partitions
  from cuml.testing.utils import unit_param, quality_param, stress_param
  from cuml.dask.common.input_utils import DistributedDataHandler
  from cuml.dask.datasets.blobs import make_blobs
  from cuml.internals.safe_imports import gpu_only_import
  import pytest
  import dask.array
  from cuml.internals.safe_imports import cpu_only_import
label_desc: Use image node_id 2 for calling a global function with example usage: test_make_regression(n_samples, n_features, n_informative, n_targets, bias, effective_rank, tail_strength, noise, shuffle, coef, n_parts, order, use_full_low_rank, client) without return types