Square wave
_https://en.wikipedia.org/wiki/Square_wave

Analogue signal is continuous, and digital signal is discrete.
The simplest example of discrete signals is, perhaps, square waves.
Because of "jump discontinuity", square waves don't like resampling.
It doesn't matter  which resampler was used, the result is always a sort of Gibbs phenomenon.

Square waves can be easily created with Audacity.

sudo apt install audacity

1. Open Audacity.

2. Go to Edit > Preferences > Quality

3. Set the project defaults:
Default Sample Rate: 384000 Hz
Default Sample Format: 32-bit float
Sample Rate Converter: Best Quality (Slowest)
And click "OK".

On the bottom left corner of Audacity's main window, you will see Project Rate (Hz) menu. It should be "384000". If not, click on it and select "384000".

Go to Generate > Tone
Waveform: Square
Frequency (Hz): 440
Amplitude: 0.8
Duration: 000,040,000 samples

Click "Generate", and you will see a nice square wave.
On the left side of the audio track, you should see:
Mono, 384000Hz
32-bit float

Now, we can downsample the square wave to 48kHz 16bit (default).
It seems that, in Audacity, the standard Linux resampler (libsamplerate) was already replaced with SoX resampler. Therefore, the result might be a nice Gibbs phenomenon, and not a kind of strange artefact.

Downsampling:

1. Change the sample rate of the project to 48000 Hz (on the bottom left corner of Audacity's main window).

2. Go to File > Export > Export as WAV
Click "Save", then click "OK".
It will be downsampled to 48kHz 16bit (default) and exported as wave.

Check it with "file" command:

$ file 16bit_48kHz.wav
16bit_48kHz.wav: RIFF (little-endian) data, WAVE audio, Microsoft PCM, 16 bit, mono 48000 Hz 

Now, you can open this wave with Audacity and see a sort of Gibbs phenomenon.
You can zoom into it:
Go to View > Zoom > "Zoom in"

Since the public has already complained that all this is "not even remotely scientific", it makes sense, perhaps, to make it more scientific with math.

sudo apt install maxima gnuplot 

Let us take a very simple mathematical function

tanh(20*sin(x)) 

If you plot it with Maxima

$ maxima
(%i1) plot2d([tanh(20*sin(x))], [x,-10*%pi,10*%pi], [y,-1.1,1.1], [plot_format, gnuplot])$ 

you will see a square wave with "jump discontinuities".
If you zoom into it

$ maxima
(%i2) plot2d([tanh(20*sin(x))], [x,-1.2*%pi,1.2*%pi], [y,-1.1,1.1], [plot_format, gnuplot])$ 

you will see a continuous function.
It depends on the resolution (that is, sample rate).

If the original wave is 32bit Float 384kHz DXD, and it is a sort of music recording, it is not likely to have very big "jump discontinuities", and, therefore, the Gibbs phenomenon may not produce audible sound distortions with downsampling. It depends, of course, on the quality of resampler as well.

EDIT: To avoid confusion, it might be necessary to provide a sort of mathematical explanation.

Because of "jump discontinuities", Fourier series cannot converge uniformly
_https://en.wikipedia.org/wiki/Convergence_of_Fourier_series
It should be obvious that a series of continuous functions cannot converge uniformly to a function with "jump discontinuities".  This is the reason why any sort of interpolation (and any sort of resamplers) fails. That is why you get the Gibbs phenomenon, and, that is why the square wave is not a sum of harmonics (in terms of physics).
_https://en.wikipedia.org/wiki/Harmonic

Digital to audio conversion (DAC) means that a digital signal (that is, a discrete signal of finite sample rate) is converted to analog signal (that is, a continuous signal of infinite sample rate). It might be obvious, therefore, that, when you are playing a square wave through your DAC, you get the same Gibbs phenomenon.
Notice that "the Gibbs phenomenon was observed by experimental physicists and was believed to be due to imperfections in the measuring apparatus, but it is in fact a mathematical result."
_https://en.wikipedia.org/wiki/Gibbs_phenomenon

This also means sound distortions, when you are playing a digital music crap of CD format through your DAC.

If you do not believe that your DAC is playing crap, you can create a square wave of 48kHz 16bit format with Audacity, upsample it to 384kHz 32bit Float DXD format, zoom into it, and you will see the same Gibbs phenomenon.

It doesn't matter whether resampling of a square wave is performed in software or in hardware. The result is always a sort of Gibbs phenomenon. You cannot fool the nature, as it was discovered by experimental physicists and explained by mathematicians.

In short, square waves are used to visualize the effect of "jump discontinuities". It helps to understand why and how resampling produces sound distortions. Since "jump discontinuities" are a natural feature of low resolution formats, such as 48kHz 16bit, it does not make much sense to measure sound quality of this particular sort of digital crap in "blind tests".

NOTE: If it is not obvious that the square wave is not a sum of harmonics, you may try a very simple "imaginary experiment".
Since harmonics, or sinusoidal waves, are continuous functions, you may try to imagine a continuous function.
The sum of two continuous functions is a continuous function. This can be taken for granted.
3 = 2 + 1
4 = 3 + 1
...
100 = 99 + 1
Thus the sum of 100 continuous functions is also a continuous function.
However, the square wave is not a continuous function. It has "jump discontinuities".
What is more, the square wave is not even approximately equal to a sum of harmonics. That is why you get the Gibbs phenomenon, when you are trying to approximate it with a sum of harmonics.

Free DXD samples are available here:
What We Hear With DXD 32-bit Files (Free Sample Downloads)
_https://positive-feedback.com/reviews/music-reviews/what-we-hear-with-dxd-32-bit-files/

If you do not know how to play DXD waves and flacs (and dsf files) on Devuan, it may mean, perhaps, that your freedom is somehow restricted by your knowledge. They can be easily played with Audacious through the help of the fftrate resampler.

The DXD samples were provided as a sort of "material artefacts" for a theological discussion about 32bit format:

See also: "What Is 32-Bit Float Audio, and Should You Record In It?"
_https://www.wired.com/story/32-bit-float-audio-explained/

Since Intel HDA codecs support 32bit format, you can play 32bit audio files with OSS4 or ALSA, without thinking "how can this be?" Although, of course, Intel HDA codecs do not support "32bit Float" audio format.

1. DXD and vinyl

If you know what the Gibbs phenomenon is, you may think that analogue recordings might be better than digital ones.

However, when sample rate 🡪 infinity, digital recordings may eventually converge to analogue ones.
The goal of the "never-ending quest for the ultimate sound quality" seems to be a sort of extreme freedom.

2. Digital eXtreme Definition (DXD) with OSS4

There is a Petrov's fftrate plugin for Audacious, but it works only with a very old version of Audacious. Therefore, if you want to play DXD waves (or dsf files) with OSS4 in "exclusive mode", you may better convert them to an audio format, which is supported by your sound card.

For example, Intel HDA codecs support 32bit 192kHz format:

$ ossinfo -v9 | grep "Output formats" -A8
    Output formats (0x00001010):
      AFMT_S16_LE	- 16 bit signed little endian
      AFMT_S32_LE	- 32 bit signed little endian
    Device handle: PCIa0021458-0000:00:1b.0-au01
    Related mixer dev: 0
    Sample rate source: 0
    Preferred channel configuration: Not indicated
    Supported number of channels (min - max): 2 - 8
    Native sample rates (min - max): 44100 - 192000 (44100,48000,96000,192000) 

DXD waves can be converted to 192kHz 32bit format with Petrov's pcm_conv. Notice that the original DXD wave is 32bit float:

$ pcm_conv -f 192000 -b 32 -T fft -v "08-Faust - Funeral March Of A Marionette - 32bit.wav" output_Faust_192kHz_32bit.wav
Input file : 08-Faust - Funeral March Of A Marionette - 32bit.wav
 Samples rate    = 352800 Hz
 Channels        = 2
 Bits per sample = 32 (actual: 32, float)

Output file: output_Faust_192kHz_32bit.wav
 Samples rate    = 192000 Hz
 Channels        = 2
 Bits per sample = 32 (actual: 32, fixed)

        FL      FR      
FL      1.000   -----   
FR      -----   1.000   

Windows : "Vorbis" (37632 => 20480)
Delay   : 107 ms
Sync.   : ON
Trans.  : "FFT"

[|||||||||||||||||||||||||||||||||||||||||||||||||||]  99.0 %
Ok.

File duration  : 275.906667 sec
Processing time: 14.542000 sec ( 5.27% of real time) 

Now you can play it with OSS4 in "exclusive mode":

ossplay -R -d0 -s192000 -c2 -fS32_LE output_Faust_192kHz_32bit.wav 

You can also play 192kHz waves with Audacious in "exclusive mode", if OSS4 plugin is enabled.

dsf files can be easily converted to waves with Audacious:
File → Settings → Audio
(1) set "Bit depth" to "Floating point"
(2) "Output plugin": "FileWriter Plugin" (then "Settings")
(3) "FileWriter Plugin Settings" - Output file format: WAV
Now, you can simply "play" a dsf file with Audacious, and it will be converted to a wave.
Notice, however, that the wave might be very big:

$ mediainfo '08-Faust - Funeral March Of A Marionette - DSD256.dsf.wav'
General
Complete name                            : 08-Faust - Funeral March Of A Marionette - DSD256.dsf-1.wav
Format                                   : Wave
Format settings                          : PcmWaveformat
File size                                : 2.90 GiB
Duration                                 : 4 min 35 s
Overall bit rate mode                    : Constant
Overall bit rate                         : 90.3 Mb/s

Audio
Format                                   : PCM
Format profile                           : Float
Codec ID                                 : 3
Codec ID/Hint                            : IEEE 
Duration                                 : 4 min 35 s
Bit rate mode                            : Constant
Bit rate                                 : 90.3 Mb/s
Channel(s)                               : 2 channels
Sampling rate                            : 1 411 kHz
Bit depth                                : 32 bits
Stream size                              : 2.90 GiB (100%) 

It can be converted to 32bit 192kHz with pcm_conv:

$ pcm_conv -f 192000 -b 32 -T fft -v *DSD256.dsf.wav output_Faust_192kHz_32bit.dsf.wav
Input file : 08-Faust - Funeral March Of A Marionette - DSD256.dsf.wav
 Samples rate    = 1411200 Hz
 Channels        = 2
 Bits per sample = 32 (actual: 32, float)

Output file: output_Faust_192kHz_32bit.dsf.wav
 Samples rate    = 192000 Hz
 Channels        = 2
 Bits per sample = 32 (actual: 32, fixed)

        FL      FR      
FL      1.000   -----   
FR      -----   1.000   

Windows : "Vorbis" (150528 => 20480)
Delay   : 107 ms
Sync.   : ON
Trans.  : "FFT"

[|||||||||||||||||||||||||||||||||||||||||||||||||||]  99.0 %
Ok.

File duration  : 275.906667 sec
Processing time: 61.711000 sec (22.37% of real time) 

Now, it can be played in "exclusive mode":

ossplay -R -d0 -s192000 -c2 -fS32_LE output_Faust_192kHz_32bit.dsf.wav 

3. DXD and dsf with ALSA

DXD waves and flacs (as well as dsf files) can be easily played with Audacious, if Petrov's fftrate ALSA plugin is installed (and configured).

It is also possible to output a sort of "debug" to terminal or a text file. This is how it looks with iMic USB sound card (16bit 48kHz):

$ audacious 2>&1 *.dsf
Input:  1411200 Hz, 2 ch, 's32_le' (0xa): dummy = 0, period = 56448
Output: 48000 Hz, 2 ch, 's16_le' (0x2): dummy = 0, period = 1920
Rates:  1411200 --> 48000 (J: 0.00%, T: FFT, W: Vorbis)
Ok. 

$ audacious 2>&1 *32bit.wav
Input:  352800 Hz, 2 ch, 's32_le' (0xa): dummy = 0, period = 14112
Output: 48000 Hz, 2 ch, 's16_le' (0x2): dummy = 0, period = 1920
Rates:  352800 --> 48000 (J: 0.00%, T: FFT, W: Vorbis)
Ok. 

You may also try FLAC (encoding and decoding) with "32bit fixed" audio format.