def METHOD_NAME():
    recording, sorting = generate_ground_truth_recording(num_channels=10, num_units=10, durations=[10.0])
    job_kwargs = dict(chunk_duration="0.5s", n_jobs=2, progress_bar=False)
    spikes = sorting.to_spike_vector()
    # create peaks from spikes
    we = extract_waveforms(recording, sorting, mode="memory", **job_kwargs)
    extremum_channel_inds = get_template_extremum_channel(we, peak_sign="neg", outputs="index")
    # print(extremum_channel_inds)
    ext_channel_inds = np.array([extremum_channel_inds[unit_id] for unit_id in sorting.unit_ids])
    # print(ext_channel_inds)
    peaks = np.zeros(spikes.size, dtype=base_peak_dtype)
    peaks["sample_index"] = spikes["sample_index"]
    peaks["channel_index"] = ext_channel_inds[spikes["unit_index"]]
    peaks["amplitude"] = 0.0
    peaks["segment_index"] = 0
    # one step only : squeeze output
    peak_retriever = PeakRetriever(recording, peaks)
    nodes = [
        peak_retriever,
        AmplitudeExtractionNode(recording, parents=[peak_retriever], param0=6.6),
    ]
    step_one = run_node_pipeline(recording, nodes, job_kwargs, squeeze_output=True)
    assert np.allclose(np.abs(peaks["amplitude"]), step_one["abs_amplitude"])
    # 3 nodes two have outputs
    ms_before = 0.5
    ms_after = 1.0
    peak_retriever = PeakRetriever(recording, peaks)
    dense_waveforms = ExtractDenseWaveforms(
        recording, parents=[peak_retriever], ms_before=ms_before, ms_after=ms_after, return_output=False
    )
    waveform_denoiser = WaveformDenoiser(recording, parents=[peak_retriever, dense_waveforms], return_output=False)
    amplitue_extraction = AmplitudeExtractionNode(recording, parents=[peak_retriever], param0=6.6, return_output=True)
    waveforms_rms = WaveformsRootMeanSquare(recording, parents=[peak_retriever, dense_waveforms], return_output=True)
    denoised_waveforms_rms = WaveformsRootMeanSquare(
        recording, parents=[peak_retriever, waveform_denoiser], return_output=True
    )
    nodes = [
        peak_retriever,
        dense_waveforms,
        waveform_denoiser,
        amplitue_extraction,
        waveforms_rms,
        denoised_waveforms_rms,
    ]
    # gather memory mode
    output = run_node_pipeline(recording, nodes, job_kwargs, gather_mode="memory")
    amplitudes, waveforms_rms, denoised_waveforms_rms = output
    assert np.allclose(np.abs(peaks["amplitude"]), amplitudes["abs_amplitude"])
    num_peaks = peaks.shape[0]
    num_channels = recording.get_num_channels()
    assert waveforms_rms.shape[0] == num_peaks
    assert waveforms_rms.shape[1] == num_channels
    assert waveforms_rms.shape[0] == num_peaks
    assert waveforms_rms.shape[1] == num_channels
    # gather npy mode
    folder = cache_folder / "pipeline_folder"
    if folder.is_dir():
        shutil.rmtree(folder)
    output = run_node_pipeline(
        recording,
        nodes,
        job_kwargs,
        gather_mode="npy",
        folder=folder,
        names=["amplitudes", "waveforms_rms", "denoised_waveforms_rms"],
    )
    amplitudes2, waveforms_rms2, denoised_waveforms_rms2 = output
    amplitudes_file = folder / "amplitudes.npy"
    assert amplitudes_file.is_file()
    amplitudes3 = np.load(amplitudes_file)
    assert np.array_equal(amplitudes, amplitudes2)
    assert np.array_equal(amplitudes2, amplitudes3)
    waveforms_rms_file = folder / "waveforms_rms.npy"
    assert waveforms_rms_file.is_file()
    waveforms_rms3 = np.load(waveforms_rms_file)
    assert np.array_equal(waveforms_rms, waveforms_rms2)
    assert np.array_equal(waveforms_rms2, waveforms_rms3)
    denoised_waveforms_rms_file = folder / "denoised_waveforms_rms.npy"
    assert denoised_waveforms_rms_file.is_file()
    denoised_waveforms_rms3 = np.load(denoised_waveforms_rms_file)
    assert np.array_equal(denoised_waveforms_rms, denoised_waveforms_rms2)
    assert np.array_equal(denoised_waveforms_rms2, denoised_waveforms_rms3)
    # Test pickle mechanism
    for node in nodes:
        import pickle
        pickled_node = pickle.dumps(node)
        unpickled_node = pickle.loads(pickled_node)