code: def test_regression():
      """Test Ordinary Least Squares Regression."""
      tmin, tmax = -0.2, 0.5
      event_id = dict(aud_l=1, aud_r=2)
  
      # Setup for reading the raw data
      raw = mne.io.read_raw_fif(raw_fname)
      events = mne.read_events(event_fname)[:10]
      epochs = mne.Epochs(
          raw,
          events,
          event_id,
          tmin,
          tmax,
          proj=True,
          baseline=(None, 0),
      )
      picks = np.arange(len(epochs.ch_names))
      evoked = epochs.average(picks=picks)
      design_matrix = epochs.events[:, 1:].astype(np.float64)
      # makes the intercept
      design_matrix[:, 0] = 1
      # creates contrast: aud_l=0, aud_r=1
      design_matrix[:, 1] -= 1
      with pytest.warns(RuntimeWarning, match="non-data"):
          lm = linear_regression(
              epochs, design_matrix, ["intercept", "aud"]
          )
  
      for predictor, parameters in lm.items():
          for value in parameters:
              assert_equal(value.data.shape, evoked.data.shape)
  
      pytest.raises(
          ValueError, linear_regression, [epochs, epochs], design_matrix
      )
  
      stc = read_source_estimate(stc_fname).crop(0, 0.02)
      stc_list = [stc, stc, stc]
      stc_gen = (s for s in stc_list)
      with np.errstate(invalid="ignore"):  # divide by zero
          lm1 = linear_regression(
              stc_list, design_matrix[: len(stc_list)]
          )
      lm2 = linear_regression(stc_gen, design_matrix[: len(stc_list)])
      for val in lm2.values():
          # all p values are 0 < p <= 1 to start, but get stored in float32
          # data, so can actually be truncated to 0. Thus the mlog10_p_val
          # actually maintains better precision for tiny p-values.
          assert np.isfinite(val.p_val.data).all()
          assert (val.p_val.data <= 1).all()
          assert (val.p_val.data >= 0).all()
          # all -log10(p) are non-negative
          assert np.isfinite(val.mlog10_p_val.data).all()
          assert (val.mlog10_p_val.data >= 0).all()
          assert (val.mlog10_p_val.data >= 0).all()
  
      for k in lm1:
          for v1, v2 in zip(lm1[k], lm2[k]):
              assert_array_equal(v1.data, v2.data)
  
      # Smoke test for fitting on epochs
      epochs.load_data()
      with pytest.warns(RuntimeWarning, match="non-data"):
          linear_regression(epochs, design_matrix)
      linear_regression(epochs.copy().pick("eeg"), design_matrix)
  
file_path: mne-python/mne/stats/tests/test_regression.py
imports: import numpy
  import pytest
  from numpy.testing import assert_allclose, assert_array_equal, assert_equal
  from scipy.signal.windows import hann
  import mne
  from mne import read_source_estimate
  from mne.datasets import testing
  from mne.io import RawArray
  from mne.stats.regression import linear_regression, linear_regression_raw
label_desc: Use image node_id 1 for calling a global function with example usage: test_regression() without return types