From 66a67188fe4abfea676203be8ce60c49e0a80e48 Mon Sep 17 00:00:00 2001
From: Alessandro Ros <aler9.dev@gmail.com>
Date: Wed, 29 Apr 2026 22:47:47 +0200
Subject: [PATCH] tests: use testing.T.TempDir rather than os.TempDir (#5709)

---
 internal/api/api_recordings_test.go           |  30 ++---
 internal/api/api_test.go                      |   5 +-
 internal/certloader/certloader_test.go        |   9 +-
 internal/conf/conf_test.go                    |  86 +++++-------
 internal/confwatcher/confwatcher_test.go      |  21 ++-
 internal/core/api_test.go                     | 126 +++++++-----------
 internal/core/core_test.go                    |  16 +--
 internal/core/metrics_test.go                 |  34 ++---
 internal/core/path_manager_test.go            |   6 +-
 internal/core/path_test.go                    | 118 +++++++---------
 internal/logger/logger_test.go                |   3 +-
 internal/packetdumper/conn_test.go            |  70 +++++-----
 internal/packetdumper/packet_conn_test.go     |  73 +++++-----
 internal/playback/on_get_test.go              |  24 ++--
 internal/playback/on_list_test.go             |  18 +--
 internal/playback/segment_fmp4_test.go        |   3 +-
 internal/protocols/unix/listener_test.go      |   3 +-
 internal/recordcleaner/cleaner_test.go        |  12 +-
 internal/recorder/recorder_test.go            |  28 +---
 internal/recordstore/segment_test.go          |  18 +--
 internal/servers/hls/server_test.go           |   6 +-
 internal/servers/rtmp/server_test.go          |  21 +--
 internal/staticsources/mpegts/source_test.go  |   2 +-
 internal/staticsources/rtmp/source_test.go    |  12 +-
 internal/staticsources/rtp/source_test.go     |   2 +-
 internal/staticsources/rtsp/source_test.go    |  12 +-
 .../stream/stream_alwaysavailable_test.go     |   3 +-
 internal/test/temp_file.go                    |  21 +--
 internal/teste2e/hls_manager_test.go          |   4 +-
 internal/teste2e/rtsp_server_test.go          |  52 ++++----
 internal/teste2e/tests_test.go                |   9 +-
 31 files changed, 324 insertions(+), 523 deletions(-)

diff --git a/internal/api/api_recordings_test.go b/internal/api/api_recordings_test.go
index aadd737d..7f0a1bcb 100644
--- a/internal/api/api_recordings_test.go
+++ b/internal/api/api_recordings_test.go
@@ -14,9 +14,7 @@ import (
 )
 
 func TestRecordingsList(t *testing.T) {
-	dir, err := os.MkdirTemp("", "mediamtx-playback")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	cnf := tempConf(t, "pathDefaults:\n"+
 		"  recordPath: "+filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")+"\n"+
@@ -32,7 +30,7 @@ func TestRecordingsList(t *testing.T) {
 		AuthManager:  test.NilAuthManager,
 		Parent:       &testParent{},
 	}
-	err = api.Initialize()
+	err := api.Initialize()
 	require.NoError(t, err)
 	defer api.Close()
 
@@ -85,9 +83,7 @@ func TestRecordingsList(t *testing.T) {
 }
 
 func TestRecordingsGet(t *testing.T) {
-	dir, err := os.MkdirTemp("", "mediamtx-playback")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	cnf := tempConf(t, "pathDefaults:\n"+
 		"  recordPath: "+filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")+"\n"+
@@ -102,7 +98,7 @@ func TestRecordingsGet(t *testing.T) {
 		AuthManager:  test.NilAuthManager,
 		Parent:       &testParent{},
 	}
-	err = api.Initialize()
+	err := api.Initialize()
 	require.NoError(t, err)
 	defer api.Close()
 
@@ -135,9 +131,7 @@ func TestRecordingsGet(t *testing.T) {
 }
 
 func TestRecordingsDeleteSegment(t *testing.T) {
-	dir, err := os.MkdirTemp("", "mediamtx-playback")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	cnf := tempConf(t, "pathDefaults:\n"+
 		"  recordPath: "+filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")+"\n"+
@@ -152,7 +146,7 @@ func TestRecordingsDeleteSegment(t *testing.T) {
 		AuthManager:  test.NilAuthManager,
 		Parent:       &testParent{},
 	}
-	err = api.Initialize()
+	err := api.Initialize()
 	require.NoError(t, err)
 	defer api.Close()
 
@@ -189,9 +183,7 @@ func TestRecordingsDeleteSegment(t *testing.T) {
 }
 
 func TestRecordingsDeleteSegmentInvalidPath(t *testing.T) {
-	dir, err := os.MkdirTemp("", "mediamtx-playback")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	cnf := tempConf(t, "pathDefaults:\n"+
 		"  recordPath: "+filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")+"\n"+
@@ -206,7 +198,7 @@ func TestRecordingsDeleteSegmentInvalidPath(t *testing.T) {
 		AuthManager:  test.NilAuthManager,
 		Parent:       &testParent{},
 	}
-	err = api.Initialize()
+	err := api.Initialize()
 	require.NoError(t, err)
 	defer api.Close()
 
@@ -242,9 +234,7 @@ func TestRecordingsDeleteSegmentInvalidPath(t *testing.T) {
 }
 
 func TestRecordingsSegmentGetInvalidPath(t *testing.T) {
-	dir, err := os.MkdirTemp("", "mediamtx-playback")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	cnf := tempConf(t, "pathDefaults:\n"+
 		"  recordPath: "+filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")+"\n"+
@@ -259,7 +249,7 @@ func TestRecordingsSegmentGetInvalidPath(t *testing.T) {
 		AuthManager:  test.NilAuthManager,
 		Parent:       &testParent{},
 	}
-	err = api.Initialize()
+	err := api.Initialize()
 	require.NoError(t, err)
 	defer api.Close()
 
diff --git a/internal/api/api_test.go b/internal/api/api_test.go
index 70074618..40f6eec2 100644
--- a/internal/api/api_test.go
+++ b/internal/api/api_test.go
@@ -7,7 +7,6 @@ import (
 	"io"
 	"net/http"
 	"net/url"
-	"os"
 	"testing"
 	"time"
 
@@ -31,9 +30,7 @@ func (p testParent) Log(l logger.Level, s string, a ...any) {
 func (testParent) APIConfigSet(_ *conf.Conf) {}
 
 func tempConf(t *testing.T, cnt string) *conf.Conf {
-	fi, err := test.CreateTempFile([]byte(cnt))
-	require.NoError(t, err)
-	defer os.Remove(fi)
+	fi := test.CreateTempFile(t, []byte(cnt))
 
 	cnf, _, err := conf.Load(fi, nil, nil)
 	require.NoError(t, err)
diff --git a/internal/certloader/certloader_test.go b/internal/certloader/certloader_test.go
index 1e39cc5e..f85864bc 100644
--- a/internal/certloader/certloader_test.go
+++ b/internal/certloader/certloader_test.go
@@ -14,13 +14,8 @@ func TestCertReload(t *testing.T) {
 	testData, err := tls.X509KeyPair(test.TLSCertPub, test.TLSCertKey)
 	require.NoError(t, err)
 
-	serverCertPath, err := test.CreateTempFile(test.TLSCertPub)
-	require.NoError(t, err)
-	defer os.Remove(serverCertPath)
-
-	serverKeyPath, err := test.CreateTempFile(test.TLSCertKey)
-	require.NoError(t, err)
-	defer os.Remove(serverKeyPath)
+	serverCertPath := test.CreateTempFile(t, test.TLSCertPub)
+	serverKeyPath := test.CreateTempFile(t, test.TLSCertKey)
 
 	loader := &CertLoader{
 		CertPath: serverCertPath,
diff --git a/internal/conf/conf_test.go b/internal/conf/conf_test.go
index 1a4dd199..3248b3d4 100644
--- a/internal/conf/conf_test.go
+++ b/internal/conf/conf_test.go
@@ -15,29 +15,23 @@ import (
 	"github.com/bluenviron/mediamtx/internal/logger"
 )
 
-func createTempFile(byts []byte) (string, error) {
-	tmpf, err := os.CreateTemp(os.TempDir(), "rtsp-")
-	if err != nil {
-		return "", err
-	}
+func createTempFile(t *testing.T, byts []byte) string {
+	tmpf, err := os.CreateTemp(t.TempDir(), "rtsp-")
+	require.NoError(t, err)
 	defer tmpf.Close()
 
 	_, err = tmpf.Write(byts)
-	if err != nil {
-		return "", err
-	}
+	require.NoError(t, err)
 
-	return tmpf.Name(), nil
+	return tmpf.Name()
 }
 
 func TestConfFromFile(t *testing.T) {
 	func() {
-		tmpf, err := createTempFile([]byte("logLevel: debug\n" +
-			"paths:\n" +
-			"  cam1:\n" +
+		tmpf := createTempFile(t, []byte("logLevel: debug\n"+
+			"paths:\n"+
+			"  cam1:\n"+
 			"    runOnDemandStartTimeout: 5s\n"))
-		require.NoError(t, err)
-		defer os.Remove(tmpf)
 
 		conf, confPath, err := Load(tmpf, nil, nil)
 		require.NoError(t, err)
@@ -93,31 +87,25 @@ func TestConfFromFile(t *testing.T) {
 	}()
 
 	func() {
-		tmpf, err := createTempFile([]byte(``))
-		require.NoError(t, err)
-		defer os.Remove(tmpf)
+		tmpf := createTempFile(t, []byte(``))
 
-		_, _, err = Load(tmpf, nil, nil)
+		_, _, err := Load(tmpf, nil, nil)
 		require.NoError(t, err)
 	}()
 
 	func() {
-		tmpf, err := createTempFile([]byte(`paths:`))
-		require.NoError(t, err)
-		defer os.Remove(tmpf)
+		tmpf := createTempFile(t, []byte(`paths:`))
 
-		_, _, err = Load(tmpf, nil, nil)
+		_, _, err := Load(tmpf, nil, nil)
 		require.NoError(t, err)
 	}()
 
 	func() {
-		tmpf, err := createTempFile([]byte(
-			"paths:\n" +
+		tmpf := createTempFile(t, []byte(
+			"paths:\n"+
 				"  mypath:\n"))
-		require.NoError(t, err)
-		defer os.Remove(tmpf)
 
-		_, _, err = Load(tmpf, nil, nil)
+		_, _, err := Load(tmpf, nil, nil)
 		require.NoError(t, err)
 	}()
 }
@@ -135,9 +123,7 @@ func TestConfFromFileAndEnv(t *testing.T) {
 	// deprecated path parameter
 	t.Setenv("MTX_PATHS_CAM2_DISABLEPUBLISHEROVERRIDE", "yes")
 
-	tmpf, err := createTempFile([]byte("{}"))
-	require.NoError(t, err)
-	defer os.Remove(tmpf)
+	tmpf := createTempFile(t, []byte("{}"))
 
 	conf, confPath, err := Load(tmpf, nil, nil)
 	require.NoError(t, err)
@@ -187,9 +173,7 @@ func TestConfEncryption(t *testing.T) {
 
 	t.Setenv("RTSP_CONFKEY", key)
 
-	tmpf, err := createTempFile([]byte(encryptedConf))
-	require.NoError(t, err)
-	defer os.Remove(tmpf)
+	tmpf := createTempFile(t, []byte(encryptedConf))
 
 	conf, confPath, err := Load(tmpf, nil, nil)
 	require.NoError(t, err)
@@ -203,13 +187,11 @@ func TestConfEncryption(t *testing.T) {
 }
 
 func TestConfDeprecatedAuth(t *testing.T) {
-	tmpf, err := createTempFile([]byte(
-		"paths:\n" +
-			"  cam:\n" +
-			"    readUser: myuser\n" +
+	tmpf := createTempFile(t, []byte(
+		"paths:\n"+
+			"  cam:\n"+
+			"    readUser: myuser\n"+
 			"    readPass: mypass\n"))
-	require.NoError(t, err)
-	defer os.Remove(tmpf)
 
 	conf, _, err := Load(tmpf, nil, nil)
 	require.NoError(t, err)
@@ -749,29 +731,23 @@ func TestConfErrors(t *testing.T) {
 		},
 	} {
 		t.Run(ca.name, func(t *testing.T) {
-			tmpf, err := createTempFile([]byte(ca.conf))
-			require.NoError(t, err)
-			defer os.Remove(tmpf)
+			tmpf := createTempFile(t, []byte(ca.conf))
 
-			_, _, err = Load(tmpf, nil, nil)
+			_, _, err := Load(tmpf, nil, nil)
 			require.EqualError(t, err, ca.err)
 		})
 	}
 }
 
 func TestAlwaysAvailableFileErrorMagicBytes(t *testing.T) {
-	tmpf, err := createTempFile([]byte("ABCDEFGHI"))
-	require.NoError(t, err)
-	defer os.Remove(tmpf)
+	tmpf := createTempFile(t, []byte("ABCDEFGHI"))
 
-	tmpConf, err := createTempFile([]byte("paths:\n" +
-		"  mypath:\n" +
-		"    alwaysAvailable: yes\n" +
-		"    alwaysAvailableFile: " + tmpf + "\n"))
-	require.NoError(t, err)
-	defer os.Remove(tmpConf)
+	tmpConf := createTempFile(t, []byte("paths:\n"+
+		"  mypath:\n"+
+		"    alwaysAvailable: yes\n"+
+		"    alwaysAvailableFile: "+tmpf+"\n"))
 
-	_, _, err = Load(tmpConf, nil, nil)
+	_, _, err := Load(tmpConf, nil, nil)
 	require.EqualError(t, err, "invalid 'alwaysAvailableFile': file is not MP4, magic bytes are [69 70 71 72]")
 }
 
@@ -795,9 +771,7 @@ func TestSampleConfFile(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, "../../mediamtx.yml", confPath1)
 
-		tmpf, err := createTempFile([]byte("paths:\n  all_others:"))
-		require.NoError(t, err)
-		defer os.Remove(tmpf)
+		tmpf := createTempFile(t, []byte("paths:\n  all_others:"))
 
 		conf2, confPath2, err := Load(tmpf, nil, nil)
 		require.NoError(t, err)
diff --git a/internal/confwatcher/confwatcher_test.go b/internal/confwatcher/confwatcher_test.go
index f6c46386..3f5dc8c8 100644
--- a/internal/confwatcher/confwatcher_test.go
+++ b/internal/confwatcher/confwatcher_test.go
@@ -16,11 +16,10 @@ func TestNoFile(t *testing.T) {
 }
 
 func TestWrite(t *testing.T) {
-	fpath, err := test.CreateTempFile([]byte("{}"))
-	require.NoError(t, err)
+	fpath := test.CreateTempFile(t, []byte("{}"))
 
 	w := &ConfWatcher{FilePath: fpath}
-	err = w.Initialize()
+	err := w.Initialize()
 	require.NoError(t, err)
 	defer w.Close()
 
@@ -43,11 +42,10 @@ func TestWrite(t *testing.T) {
 }
 
 func TestWriteMultipleTimes(t *testing.T) {
-	fpath, err := test.CreateTempFile([]byte("{}"))
-	require.NoError(t, err)
+	fpath := test.CreateTempFile(t, []byte("{}"))
 
 	w := &ConfWatcher{FilePath: fpath}
-	err = w.Initialize()
+	err := w.Initialize()
 	require.NoError(t, err)
 	defer w.Close()
 
@@ -87,15 +85,15 @@ func TestWriteMultipleTimes(t *testing.T) {
 }
 
 func TestDeleteCreate(t *testing.T) {
-	fpath, err := test.CreateTempFile([]byte("{}"))
-	require.NoError(t, err)
+	fpath := test.CreateTempFile(t, []byte("{}"))
 
 	w := &ConfWatcher{FilePath: fpath}
-	err = w.Initialize()
+	err := w.Initialize()
 	require.NoError(t, err)
 	defer w.Close()
 
 	os.Remove(fpath)
+
 	time.Sleep(10 * time.Millisecond)
 
 	func() {
@@ -117,10 +115,9 @@ func TestDeleteCreate(t *testing.T) {
 }
 
 func TestSymlinkDeleteCreate(t *testing.T) {
-	fpath, err := test.CreateTempFile([]byte("{}"))
-	require.NoError(t, err)
+	fpath := test.CreateTempFile(t, []byte("{}"))
 
-	err = os.Symlink(fpath, fpath+"-sym")
+	err := os.Symlink(fpath, fpath+"-sym")
 	require.NoError(t, err)
 
 	w := &ConfWatcher{FilePath: fpath + "-sym"}
diff --git a/internal/core/api_test.go b/internal/core/api_test.go
index 998a12ed..2ea9bf08 100644
--- a/internal/core/api_test.go
+++ b/internal/core/api_test.go
@@ -10,7 +10,6 @@ import (
 	"io"
 	"net/http"
 	"net/url"
-	"os"
 	"testing"
 	"time"
 
@@ -102,8 +101,8 @@ func TestAPIPathsList(t *testing.T) {
 	}
 
 	t.Run("rtsp session", func(t *testing.T) {
-		p, ok := newInstance("api: yes\n" +
-			"paths:\n" +
+		p, ok := newInstance(t, "api: yes\n"+
+			"paths:\n"+
 			"  mypath:\n")
 		require.Equal(t, true, ok)
 		defer p.Close()
@@ -153,19 +152,14 @@ func TestAPIPathsList(t *testing.T) {
 	})
 
 	t.Run("rtsps session", func(t *testing.T) {
-		serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
-		require.NoError(t, err)
-		defer os.Remove(serverCertFpath)
+		serverCertFpath := test.CreateTempFile(t, test.TLSCertPub)
+		serverKeyFpath := test.CreateTempFile(t, test.TLSCertKey)
 
-		serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
-		require.NoError(t, err)
-		defer os.Remove(serverKeyFpath)
-
-		p, ok := newInstance("api: yes\n" +
-			"rtspEncryption: optional\n" +
-			"rtspServerCert: " + serverCertFpath + "\n" +
-			"rtspServerKey: " + serverKeyFpath + "\n" +
-			"paths:\n" +
+		p, ok := newInstance(t, "api: yes\n"+
+			"rtspEncryption: optional\n"+
+			"rtspServerCert: "+serverCertFpath+"\n"+
+			"rtspServerKey: "+serverKeyFpath+"\n"+
+			"paths:\n"+
 			"  mypath:\n")
 		require.Equal(t, true, ok)
 		defer p.Close()
@@ -175,7 +169,7 @@ func TestAPIPathsList(t *testing.T) {
 		hc := &http.Client{Transport: tr}
 
 		source := gortsplib.Client{TLSConfig: &tls.Config{InsecureSkipVerify: true}}
-		err = source.StartRecording("rtsps://localhost:8322/mypath",
+		err := source.StartRecording("rtsps://localhost:8322/mypath",
 			&description.Session{Medias: []*description.Media{
 				test.UniqueMediaH264(),
 				test.UniqueMediaMPEG4Audio(),
@@ -200,10 +194,10 @@ func TestAPIPathsList(t *testing.T) {
 	})
 
 	t.Run("rtsp source", func(t *testing.T) {
-		p, ok := newInstance("api: yes\n" +
-			"paths:\n" +
-			"  mypath:\n" +
-			"    source: rtsp://127.0.0.1:1234/mypath\n" +
+		p, ok := newInstance(t, "api: yes\n"+
+			"paths:\n"+
+			"  mypath:\n"+
+			"    source: rtsp://127.0.0.1:1234/mypath\n"+
 			"    sourceOnDemand: yes\n")
 		require.Equal(t, true, ok)
 		defer p.Close()
@@ -229,10 +223,10 @@ func TestAPIPathsList(t *testing.T) {
 	})
 
 	t.Run("rtmp source", func(t *testing.T) {
-		p, ok := newInstance("api: yes\n" +
-			"paths:\n" +
-			"  mypath:\n" +
-			"    source: rtmp://127.0.0.1:1234/mypath\n" +
+		p, ok := newInstance(t, "api: yes\n"+
+			"paths:\n"+
+			"  mypath:\n"+
+			"    source: rtmp://127.0.0.1:1234/mypath\n"+
 			"    sourceOnDemand: yes\n")
 		require.Equal(t, true, ok)
 		defer p.Close()
@@ -258,10 +252,10 @@ func TestAPIPathsList(t *testing.T) {
 	})
 
 	t.Run("hls source", func(t *testing.T) {
-		p, ok := newInstance("api: yes\n" +
-			"paths:\n" +
-			"  mypath:\n" +
-			"    source: http://127.0.0.1:1234/mypath\n" +
+		p, ok := newInstance(t, "api: yes\n"+
+			"paths:\n"+
+			"  mypath:\n"+
+			"    source: http://127.0.0.1:1234/mypath\n"+
 			"    sourceOnDemand: yes\n")
 		require.Equal(t, true, ok)
 		defer p.Close()
@@ -288,8 +282,8 @@ func TestAPIPathsList(t *testing.T) {
 }
 
 func TestAPIPathsGet(t *testing.T) {
-	p, ok := newInstance("api: yes\n" +
-		"paths:\n" +
+	p, ok := newInstance(t, "api: yes\n"+
+		"paths:\n"+
 		"  all_others:\n")
 	require.Equal(t, true, ok)
 	defer p.Close()
@@ -357,13 +351,8 @@ func TestAPIPathsGet(t *testing.T) {
 }
 
 func TestAPIProtocolListGet(t *testing.T) {
-	serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
-	require.NoError(t, err)
-	defer os.Remove(serverCertFpath)
-
-	serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
-	require.NoError(t, err)
-	defer os.Remove(serverKeyFpath)
+	serverCertFpath := test.CreateTempFile(t, test.TLSCertPub)
+	serverKeyFpath := test.CreateTempFile(t, test.TLSCertKey)
 
 	for _, ca := range []string{
 		"rtsp conns",
@@ -395,7 +384,7 @@ func TestAPIProtocolListGet(t *testing.T) {
 			cnf += "paths:\n" +
 				"  all_others:\n"
 
-			p, ok := newInstance(cnf)
+			p, ok := newInstance(t, cnf)
 			require.Equal(t, true, ok)
 			defer p.Close()
 
@@ -409,7 +398,7 @@ func TestAPIProtocolListGet(t *testing.T) {
 			case "rtsp conns", "rtsp sessions":
 				source := gortsplib.Client{}
 
-				err = source.StartRecording("rtsp://localhost:8554/mypath?key=val",
+				err := source.StartRecording("rtsp://localhost:8554/mypath?key=val",
 					&description.Session{Medias: []*description.Media{medi}})
 				require.NoError(t, err)
 				defer source.Close()
@@ -419,7 +408,7 @@ func TestAPIProtocolListGet(t *testing.T) {
 					TLSConfig: &tls.Config{InsecureSkipVerify: true},
 				}
 
-				err = source.StartRecording("rtsps://localhost:8322/mypath?key=val",
+				err := source.StartRecording("rtsps://localhost:8322/mypath?key=val",
 					&description.Session{Medias: []*description.Media{medi}})
 				require.NoError(t, err)
 				defer source.Close()
@@ -443,7 +432,7 @@ func TestAPIProtocolListGet(t *testing.T) {
 				rawURL += "127.0.0.1:" + port + "/mypath?key=val"
 
 				var u *url.URL
-				u, err = url.Parse(rawURL)
+				u, err := url.Parse(rawURL)
 				require.NoError(t, err)
 
 				conn := &gortmplib.Client{
@@ -476,7 +465,7 @@ func TestAPIProtocolListGet(t *testing.T) {
 
 			case "hls sessions", "hls muxers":
 				source := gortsplib.Client{}
-				err = source.StartRecording("rtsp://localhost:8554/mypath",
+				err := source.StartRecording("rtsp://localhost:8554/mypath",
 					&description.Session{Medias: []*description.Media{medi}})
 				require.NoError(t, err)
 				defer source.Close()
@@ -533,7 +522,7 @@ func TestAPIProtocolListGet(t *testing.T) {
 
 			case "webrtc":
 				source := gortsplib.Client{}
-				err = source.StartRecording("rtsp://localhost:8554/mypath",
+				err := source.StartRecording("rtsp://localhost:8554/mypath",
 					&description.Session{Medias: []*description.Media{medi}})
 				require.NoError(t, err)
 				defer source.Close()
@@ -574,7 +563,7 @@ func TestAPIProtocolListGet(t *testing.T) {
 				conf.StreamId = "publish:mypath:::key=val"
 
 				var conn srt.Conn
-				conn, err = srt.Dial("srt", "localhost:8890", conf)
+				conn, err := srt.Dial("srt", "localhost:8890", conf)
 				require.NoError(t, err)
 				defer conn.Close()
 
@@ -1013,13 +1002,8 @@ func TestAPIProtocolListGet(t *testing.T) {
 }
 
 func TestAPIProtocolGetNotFound(t *testing.T) {
-	serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
-	require.NoError(t, err)
-	defer os.Remove(serverCertFpath)
-
-	serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
-	require.NoError(t, err)
-	defer os.Remove(serverKeyFpath)
+	serverCertFpath := test.CreateTempFile(t, test.TLSCertPub)
+	serverKeyFpath := test.CreateTempFile(t, test.TLSCertKey)
 
 	for _, ca := range []string{
 		"rtsp conns",
@@ -1052,7 +1036,7 @@ func TestAPIProtocolGetNotFound(t *testing.T) {
 			cnf += "paths:\n" +
 				"  all_others:\n"
 
-			p, ok := newInstance(cnf)
+			p, ok := newInstance(t, cnf)
 			require.Equal(t, true, ok)
 			defer p.Close()
 
@@ -1095,7 +1079,7 @@ func TestAPIProtocolGetNotFound(t *testing.T) {
 
 			func() {
 				var req *http.Request
-				req, err = http.NewRequest(http.MethodGet, "http://localhost:9997/v3/"+pa+"/get/"+uuid.New().String(), nil)
+				req, err := http.NewRequest(http.MethodGet, "http://localhost:9997/v3/"+pa+"/get/"+uuid.New().String(), nil)
 				require.NoError(t, err)
 
 				var res *http.Response
@@ -1121,13 +1105,8 @@ func TestAPIProtocolGetNotFound(t *testing.T) {
 }
 
 func TestAPIProtocolKick(t *testing.T) {
-	serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
-	require.NoError(t, err)
-	defer os.Remove(serverCertFpath)
-
-	serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
-	require.NoError(t, err)
-	defer os.Remove(serverKeyFpath)
+	serverCertFpath := test.CreateTempFile(t, test.TLSCertPub)
+	serverKeyFpath := test.CreateTempFile(t, test.TLSCertKey)
 
 	for _, ca := range []string{
 		"rtsp",
@@ -1150,7 +1129,7 @@ func TestAPIProtocolKick(t *testing.T) {
 			cnf += "paths:\n" +
 				"  all_others:\n"
 
-			p, ok := newInstance(cnf)
+			p, ok := newInstance(t, cnf)
 			require.Equal(t, true, ok)
 			defer p.Close()
 
@@ -1163,7 +1142,7 @@ func TestAPIProtocolKick(t *testing.T) {
 			switch ca {
 			case "rtsp":
 				source := gortsplib.Client{}
-				err = source.StartRecording("rtsp://localhost:8554/mypath",
+				err := source.StartRecording("rtsp://localhost:8554/mypath",
 					&description.Session{Medias: []*description.Media{medi}})
 				require.NoError(t, err)
 				defer source.Close()
@@ -1172,14 +1151,14 @@ func TestAPIProtocolKick(t *testing.T) {
 				source := gortsplib.Client{
 					TLSConfig: &tls.Config{InsecureSkipVerify: true},
 				}
-				err = source.StartRecording("rtsps://localhost:8322/mypath",
+				err := source.StartRecording("rtsps://localhost:8322/mypath",
 					&description.Session{Medias: []*description.Media{medi}})
 				require.NoError(t, err)
 				defer source.Close()
 
 			case "rtmp":
 				var u *url.URL
-				u, err = url.Parse("rtmp://localhost:1935/mypath")
+				u, err := url.Parse("rtmp://localhost:1935/mypath")
 				require.NoError(t, err)
 
 				conn := &gortmplib.Client{
@@ -1209,7 +1188,7 @@ func TestAPIProtocolKick(t *testing.T) {
 
 			case "hls":
 				source := gortsplib.Client{}
-				err = source.StartRecording("rtsp://localhost:8554/mypath",
+				err := source.StartRecording("rtsp://localhost:8554/mypath",
 					&description.Session{Medias: []*description.Media{medi}})
 				require.NoError(t, err)
 				defer source.Close()
@@ -1248,7 +1227,7 @@ func TestAPIProtocolKick(t *testing.T) {
 
 			case "webrtc":
 				var u *url.URL
-				u, err = url.Parse("http://localhost:8889/mypath/whip")
+				u, err := url.Parse("http://localhost:8889/mypath/whip")
 				require.NoError(t, err)
 
 				track := &webrtc.OutgoingTrack{
@@ -1278,7 +1257,7 @@ func TestAPIProtocolKick(t *testing.T) {
 				conf.StreamId = "publish:mypath"
 
 				var conn srt.Conn
-				conn, err = srt.Dial("srt", "localhost:8890", conf)
+				conn, err := srt.Dial("srt", "localhost:8890", conf)
 				require.NoError(t, err)
 				defer conn.Close()
 
@@ -1341,13 +1320,8 @@ func TestAPIProtocolKick(t *testing.T) {
 }
 
 func TestAPIProtocolKickNotFound(t *testing.T) {
-	serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
-	require.NoError(t, err)
-	defer os.Remove(serverCertFpath)
-
-	serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
-	require.NoError(t, err)
-	defer os.Remove(serverKeyFpath)
+	serverCertFpath := test.CreateTempFile(t, test.TLSCertPub)
+	serverKeyFpath := test.CreateTempFile(t, test.TLSCertKey)
 
 	for _, ca := range []string{
 		"rtsp",
@@ -1370,7 +1344,7 @@ func TestAPIProtocolKickNotFound(t *testing.T) {
 			cnf += "paths:\n" +
 				"  all_others:\n"
 
-			p, ok := newInstance(cnf)
+			p, ok := newInstance(t, cnf)
 			require.Equal(t, true, ok)
 			defer p.Close()
 
@@ -1401,7 +1375,7 @@ func TestAPIProtocolKickNotFound(t *testing.T) {
 
 			func() {
 				var req *http.Request
-				req, err = http.NewRequest(http.MethodPost, "http://localhost:9997/v3/"+pa+"/kick/"+uuid.New().String(), nil)
+				req, err := http.NewRequest(http.MethodPost, "http://localhost:9997/v3/"+pa+"/kick/"+uuid.New().String(), nil)
 				require.NoError(t, err)
 
 				var res *http.Response
diff --git a/internal/core/core_test.go b/internal/core/core_test.go
index 8fae7479..5f545286 100644
--- a/internal/core/core_test.go
+++ b/internal/core/core_test.go
@@ -12,16 +12,12 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func newInstance(conf string) (*Core, bool) {
+func newInstance(t *testing.T, conf string) (*Core, bool) {
 	if conf == "" {
 		return New([]string{})
 	}
 
-	tmpf, err := test.CreateTempFile([]byte(conf))
-	if err != nil {
-		return nil, false
-	}
-	defer os.Remove(tmpf)
+	tmpf := test.CreateTempFile(t, []byte(conf))
 
 	return New([]string{tmpf})
 }
@@ -89,14 +85,14 @@ func TestCoreErrors(t *testing.T) {
 		},
 	} {
 		t.Run(ca.name, func(t *testing.T) {
-			_, ok := newInstance(ca.conf)
+			_, ok := newInstance(t, ca.conf)
 			require.Equal(t, false, ok)
 		})
 	}
 }
 
 func TestCoreHotReloading(t *testing.T) {
-	confPath := filepath.Join(os.TempDir(), "rtsp-conf")
+	confPath := filepath.Join(t.TempDir(), "rtsp-conf")
 
 	err := os.WriteFile(confPath, []byte("paths:\n"+
 		"  test1:\n"+
@@ -104,7 +100,6 @@ func TestCoreHotReloading(t *testing.T) {
 		"    publishPass: mypass\n"),
 		0o644)
 	require.NoError(t, err)
-	defer os.Remove(confPath)
 
 	p, ok := New([]string{confPath})
 	require.Equal(t, true, ok)
@@ -134,12 +129,11 @@ func TestCoreHotReloading(t *testing.T) {
 }
 
 func TestCoreHotReloadingAndLoggerError(t *testing.T) {
-	confPath := filepath.Join(os.TempDir(), "rtsp-conf")
+	confPath := filepath.Join(t.TempDir(), "rtsp-conf")
 
 	err := os.WriteFile(confPath, []byte(""),
 		0o644)
 	require.NoError(t, err)
-	defer os.Remove(confPath)
 
 	p, ok := New([]string{confPath})
 	require.Equal(t, true, ok)
diff --git a/internal/core/metrics_test.go b/internal/core/metrics_test.go
index 1c49565e..11d841a3 100644
--- a/internal/core/metrics_test.go
+++ b/internal/core/metrics_test.go
@@ -7,7 +7,6 @@ import (
 	"io"
 	"net/http"
 	"net/url"
-	"os"
 	"sync"
 	"testing"
 	"time"
@@ -44,26 +43,21 @@ func httpPullFile(t *testing.T, hc *http.Client, u string) []byte {
 }
 
 func TestMetrics(t *testing.T) {
-	serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
-	require.NoError(t, err)
-	defer os.Remove(serverCertFpath)
+	serverCertFpath := test.CreateTempFile(t, test.TLSCertPub)
+	serverKeyFpath := test.CreateTempFile(t, test.TLSCertKey)
 
-	serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
-	require.NoError(t, err)
-	defer os.Remove(serverKeyFpath)
-
-	p, ok := newInstance("api: yes\n" +
-		"hlsAlwaysRemux: yes\n" +
-		"metrics: yes\n" +
-		"webrtcServerCert: " + serverCertFpath + "\n" +
-		"webrtcServerKey: " + serverKeyFpath + "\n" +
-		"rtspEncryption: optional\n" +
-		"rtspServerCert: " + serverCertFpath + "\n" +
-		"rtspServerKey: " + serverKeyFpath + "\n" +
-		"rtmpEncryption: optional\n" +
-		"rtmpServerCert: " + serverCertFpath + "\n" +
-		"rtmpServerKey: " + serverKeyFpath + "\n" +
-		"paths:\n" +
+	p, ok := newInstance(t, "api: yes\n"+
+		"hlsAlwaysRemux: yes\n"+
+		"metrics: yes\n"+
+		"webrtcServerCert: "+serverCertFpath+"\n"+
+		"webrtcServerKey: "+serverKeyFpath+"\n"+
+		"rtspEncryption: optional\n"+
+		"rtspServerCert: "+serverCertFpath+"\n"+
+		"rtspServerKey: "+serverKeyFpath+"\n"+
+		"rtmpEncryption: optional\n"+
+		"rtmpServerCert: "+serverCertFpath+"\n"+
+		"rtmpServerKey: "+serverKeyFpath+"\n"+
+		"paths:\n"+
 		"  all_others:\n")
 	require.Equal(t, true, ok)
 	defer p.Close()
diff --git a/internal/core/path_manager_test.go b/internal/core/path_manager_test.go
index 591d1b0d..cc1bec06 100644
--- a/internal/core/path_manager_test.go
+++ b/internal/core/path_manager_test.go
@@ -124,9 +124,9 @@ func TestPathManagerDynamicPathDescribeAndPublish(t *testing.T) {
 
 func TestPathManagerConfigHotReload(t *testing.T) {
 	// Start MediaMTX with basic configuration
-	p, ok := newInstance("api: yes\n" +
-		"paths:\n" +
-		"  all:\n" +
+	p, ok := newInstance(t, "api: yes\n"+
+		"paths:\n"+
+		"  all:\n"+
 		"    record: no\n")
 	require.Equal(t, true, ok)
 	defer p.Close()
diff --git a/internal/core/path_test.go b/internal/core/path_test.go
index 563e9954..1ddb4fd9 100644
--- a/internal/core/path_test.go
+++ b/internal/core/path_test.go
@@ -51,15 +51,12 @@ func (sh *testServer) OnPlay(ctx *gortsplib.ServerHandlerOnPlayCtx) (*base.Respo
 var _ defs.Path = &path{}
 
 func TestPathRunOnDemand(t *testing.T) {
-	onDemand := filepath.Join(os.TempDir(), "on_demand")
-	onUnDemand := filepath.Join(os.TempDir(), "on_undemand")
-
 	for _, ca := range []string{"describe", "setup", "describe and setup"} {
 		t.Run(ca, func(t *testing.T) {
-			defer os.Remove(onDemand)
-			defer os.Remove(onUnDemand)
+			onDemand := filepath.Join(t.TempDir(), "on_demand")
+			onUnDemand := filepath.Join(t.TempDir(), "on_undemand")
 
-			p1, ok := newInstance(fmt.Sprintf("rtmp: no\n"+
+			p1, ok := newInstance(t, fmt.Sprintf("rtmp: no\n"+
 				"hls: no\n"+
 				"webrtc: no\n"+
 				"paths:\n"+
@@ -152,26 +149,18 @@ func TestPathRunOnDemand(t *testing.T) {
 }
 
 func TestPathRunOnConnect(t *testing.T) {
-	serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
-	require.NoError(t, err)
-	defer os.Remove(serverCertFpath)
-
-	serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
-	require.NoError(t, err)
-	defer os.Remove(serverKeyFpath)
+	serverCertFpath := test.CreateTempFile(t, test.TLSCertPub)
+	serverKeyFpath := test.CreateTempFile(t, test.TLSCertKey)
 
 	for _, ca := range []string{"rtsp", "rtsps", "rtmp", "rtmps", "srt"} {
 		t.Run(ca, func(t *testing.T) {
-			onConnect := filepath.Join(os.TempDir(), "on_connect")
-			defer os.Remove(onConnect)
-
-			onDisconnect := filepath.Join(os.TempDir(), "on_disconnect")
-			defer os.Remove(onDisconnect)
+			onConnect := filepath.Join(t.TempDir(), "on_connect")
+			onDisconnect := filepath.Join(t.TempDir(), "on_disconnect")
 
 			connType := ""
 
 			func() {
-				p, ok := newInstance(fmt.Sprintf(
+				p, ok := newInstance(t, fmt.Sprintf(
 					"rtspEncryption: optional\n"+
 						"rtspServerCert: "+serverCertFpath+"\n"+
 						"rtspServerKey: "+serverKeyFpath+"\n"+
@@ -192,7 +181,7 @@ func TestPathRunOnConnect(t *testing.T) {
 
 					c := gortsplib.Client{}
 
-					err = c.StartRecording(
+					err := c.StartRecording(
 						"rtsp://localhost:8554/test",
 						&description.Session{Medias: []*description.Media{test.UniqueMediaH264()}})
 					require.NoError(t, err)
@@ -203,7 +192,7 @@ func TestPathRunOnConnect(t *testing.T) {
 
 					c := gortsplib.Client{TLSConfig: &tls.Config{InsecureSkipVerify: true}}
 
-					err = c.StartRecording(
+					err := c.StartRecording(
 						"rtsps://localhost:8322/test",
 						&description.Session{Medias: []*description.Media{test.UniqueMediaH264()}})
 					require.NoError(t, err)
@@ -213,7 +202,7 @@ func TestPathRunOnConnect(t *testing.T) {
 					connType = "rtmpConn"
 
 					var u *url.URL
-					u, err = url.Parse("rtmp://127.0.0.1:1935/test")
+					u, err := url.Parse("rtmp://127.0.0.1:1935/test")
 					require.NoError(t, err)
 
 					conn := &gortmplib.Client{
@@ -228,7 +217,7 @@ func TestPathRunOnConnect(t *testing.T) {
 					connType = "rtmpsConn"
 
 					var u *url.URL
-					u, err = url.Parse("rtmps://127.0.0.1:1936/test")
+					u, err := url.Parse("rtmps://127.0.0.1:1936/test")
 					require.NoError(t, err)
 
 					conn := &gortmplib.Client{
@@ -245,7 +234,7 @@ func TestPathRunOnConnect(t *testing.T) {
 
 					conf := srt.DefaultConfig()
 					var address string
-					address, err = conf.UnmarshalURL("srt://localhost:8890?streamid=publish:test")
+					address, err := conf.UnmarshalURL("srt://localhost:8890?streamid=publish:test")
 					require.NoError(t, err)
 
 					err = conf.Validate()
@@ -261,7 +250,7 @@ func TestPathRunOnConnect(t *testing.T) {
 			}()
 
 			var byts []byte
-			byts, err = os.ReadFile(onConnect)
+			byts, err := os.ReadFile(onConnect)
 			require.NoError(t, err)
 			fields := strings.Split(string(byts[:len(byts)-1]), " ")
 			require.Equal(t, connType, fields[0])
@@ -279,14 +268,11 @@ func TestPathRunOnConnect(t *testing.T) {
 }
 
 func TestPathRunOnReady(t *testing.T) {
-	onReady := filepath.Join(os.TempDir(), "on_ready")
-	defer os.Remove(onReady)
-
-	onNotReady := filepath.Join(os.TempDir(), "on_unready")
-	defer os.Remove(onNotReady)
+	onReady := filepath.Join(t.TempDir(), "on_ready")
+	onNotReady := filepath.Join(t.TempDir(), "on_unready")
 
 	func() {
-		p, ok := newInstance(fmt.Sprintf("rtmp: no\n"+
+		p, ok := newInstance(t, fmt.Sprintf("rtmp: no\n"+
 			"hls: no\n"+
 			"webrtc: no\n"+
 			"paths:\n"+
@@ -330,24 +316,16 @@ func TestPathRunOnReady(t *testing.T) {
 }
 
 func TestPathRunOnRead(t *testing.T) {
-	serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
-	require.NoError(t, err)
-	defer os.Remove(serverCertFpath)
-
-	serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
-	require.NoError(t, err)
-	defer os.Remove(serverKeyFpath)
+	serverCertFpath := test.CreateTempFile(t, test.TLSCertPub)
+	serverKeyFpath := test.CreateTempFile(t, test.TLSCertKey)
 
 	for _, ca := range []string{"rtsp", "rtsps", "rtmp", "rtmps", "srt", "webrtc"} {
 		t.Run(ca, func(t *testing.T) {
-			onRead := filepath.Join(os.TempDir(), "on_read")
-			defer os.Remove(onRead)
-
-			onUnread := filepath.Join(os.TempDir(), "on_unread")
-			defer os.Remove(onUnread)
+			onRead := filepath.Join(t.TempDir(), "on_read")
+			onUnread := filepath.Join(t.TempDir(), "on_unread")
 
 			func() {
-				p, ok := newInstance(fmt.Sprintf(
+				p, ok := newInstance(t, fmt.Sprintf(
 					"rtspEncryption: optional\n"+
 						"rtspServerCert: "+serverCertFpath+"\n"+
 						"rtspServerKey: "+serverKeyFpath+"\n"+
@@ -366,7 +344,7 @@ func TestPathRunOnRead(t *testing.T) {
 
 				source := gortsplib.Client{}
 
-				err = source.StartRecording(
+				err := source.StartRecording(
 					"rtsp://localhost:8554/test",
 					&description.Session{Medias: []*description.Media{media0}})
 				require.NoError(t, err)
@@ -564,7 +542,7 @@ func TestPathRunOnRead(t *testing.T) {
 			}
 
 			var byts []byte
-			byts, err = os.ReadFile(onRead)
+			byts, err := os.ReadFile(onRead)
 			require.NoError(t, err)
 			fields := strings.Split(string(byts[:len(byts)-1]), " ")
 			require.Equal(t, "test", fields[0])
@@ -588,18 +566,14 @@ func TestPathRunOnRead(t *testing.T) {
 }
 
 func TestPathRunOnRecordSegment(t *testing.T) {
-	onRecordSegmentCreate := filepath.Join(os.TempDir(), "on_record_segment_create")
-	defer os.Remove(onRecordSegmentCreate)
+	onRecordSegmentCreate := filepath.Join(t.TempDir(), "on_record_segment_create")
+	onRecordSegmentComplete := filepath.Join(t.TempDir(), "on_record_segment_complete")
 
-	onRecordSegmentComplete := filepath.Join(os.TempDir(), "on_record_segment_complete")
-	defer os.Remove(onRecordSegmentComplete)
-
-	recordDir, err := os.MkdirTemp("", "rtsp-path-record")
-	require.NoError(t, err)
-	defer os.RemoveAll(recordDir)
+	recordDir := t.TempDir()
+	var err error
 
 	func() {
-		p, ok := newInstance(fmt.Sprintf("record: yes\n"+
+		p, ok := newInstance(t, fmt.Sprintf("record: yes\n"+
 			"recordPath: %s\n"+
 			"paths:\n"+
 			"  test:\n"+
@@ -655,8 +629,8 @@ func TestPathRunOnRecordSegment(t *testing.T) {
 }
 
 func TestPathMaxReaders(t *testing.T) {
-	p, ok := newInstance("paths:\n" +
-		"  all_others:\n" +
+	p, ok := newInstance(t, "paths:\n"+
+		"  all_others:\n"+
 		"    maxReaders: 1\n")
 	require.Equal(t, true, ok)
 	defer p.Close()
@@ -700,15 +674,13 @@ func TestPathMaxReaders(t *testing.T) {
 }
 
 func TestPathRecord(t *testing.T) {
-	dir, err := os.MkdirTemp("", "rtsp-path-record")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
-	p, ok := newInstance("api: yes\n" +
-		"record: yes\n" +
-		"recordPath: " + filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f") + "\n" +
-		"paths:\n" +
-		"  all_others:\n" +
+	p, ok := newInstance(t, "api: yes\n"+
+		"record: yes\n"+
+		"recordPath: "+filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")+"\n"+
+		"paths:\n"+
+		"  all_others:\n"+
 		"    record: yes\n")
 	require.Equal(t, true, ok)
 	defer p.Close()
@@ -717,7 +689,7 @@ func TestPathRecord(t *testing.T) {
 
 	source := gortsplib.Client{}
 
-	err = source.StartRecording(
+	err := source.StartRecording(
 		"rtsp://localhost:8554/mystream",
 		&description.Session{Medias: []*description.Media{media0}})
 	require.NoError(t, err)
@@ -812,7 +784,7 @@ func TestPathFallback(t *testing.T) {
 					"  path2:\n"
 			}
 
-			p1, ok := newInstance(cnf)
+			p1, ok := newInstance(t, cnf)
 			require.Equal(t, true, ok)
 			defer p1.Close()
 
@@ -880,11 +852,11 @@ func TestPathResolveSource(t *testing.T) {
 	require.NoError(t, err)
 	defer strm.Close()
 
-	p, ok := newInstance(
-		"paths:\n" +
-			"  '~^test_(.+)$':\n" +
-			"    source: rtsp://127.0.0.1:8555/$G1?$MTX_QUERY\n" +
-			"    sourceOnDemand: yes\n" +
+	p, ok := newInstance(t,
+		"paths:\n"+
+			"  '~^test_(.+)$':\n"+
+			"    source: rtsp://127.0.0.1:8555/$G1?$MTX_QUERY\n"+
+			"    sourceOnDemand: yes\n"+
 			"  'all':\n")
 	require.Equal(t, true, ok)
 	defer p.Close()
@@ -919,7 +891,7 @@ func TestPathOverridePublisher(t *testing.T) {
 				cnf += "    overridePublisher: no\n"
 			}
 
-			p, ok := newInstance(cnf)
+			p, ok := newInstance(t, cnf)
 			require.Equal(t, true, ok)
 			defer p.Close()
 
diff --git a/internal/logger/logger_test.go b/internal/logger/logger_test.go
index 16ba8f5d..628adfa3 100644
--- a/internal/logger/logger_test.go
+++ b/internal/logger/logger_test.go
@@ -45,9 +45,8 @@ func TestLoggerToFile(t *testing.T) {
 		"structured",
 	} {
 		t.Run(ca, func(t *testing.T) {
-			tempFile, err := os.CreateTemp(os.TempDir(), "mtx-logger-")
+			tempFile, err := os.CreateTemp(t.TempDir(), "mtx-logger-")
 			require.NoError(t, err)
-			defer os.Remove(tempFile.Name())
 			defer tempFile.Close()
 
 			l := &Logger{
diff --git a/internal/packetdumper/conn_test.go b/internal/packetdumper/conn_test.go
index ffd93014..0ae2c269 100644
--- a/internal/packetdumper/conn_test.go
+++ b/internal/packetdumper/conn_test.go
@@ -3,7 +3,6 @@ package packetdumper
 import (
 	"io"
 	"net"
-	"os"
 	"path/filepath"
 	"testing"
 	"time"
@@ -40,41 +39,33 @@ func startTCPPair(t *testing.T) (client, server net.Conn) {
 	return client, server
 }
 
-func cleanupPcapng(t *testing.T, prefix string) {
+func checkPcapngPresence(t *testing.T, prefix string) {
 	t.Helper()
-
 	matches, err := filepath.Glob(prefix + "_*.pcapng")
-	require.NoError(t, err, "glob for pcapng files")
+	require.NoError(t, err)
 	require.NotEmpty(t, matches, "expected at least one pcapng file to have been created")
-
-	for _, f := range matches {
-		require.NoError(t, os.Remove(f), "removing pcapng file %s", f)
-	}
 }
 
 func TestConnInitialize_CreatesFile(t *testing.T) {
 	client, server := startTCPPair(t)
-	defer server.Close()
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &conn{Prefix: prefix, Conn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapng(t, prefix)
-	defer c.Close() //nolint:errcheck
+	c.Close() //nolint:errcheck
+	server.Close()
+
+	checkPcapngPresence(t, prefix)
 }
 
 func TestConnWrite(t *testing.T) {
 	client, server := startTCPPair(t)
-	defer server.Close()
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &conn{Prefix: prefix, Conn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapng(t, prefix)
-	defer c.Close() //nolint:errcheck
-
 	n, err := c.Write([]byte("hello world"))
 	require.NoError(t, err)
 	require.Equal(t, 11, n)
@@ -83,19 +74,20 @@ func TestConnWrite(t *testing.T) {
 	_, err = io.ReadFull(server, buf)
 	require.NoError(t, err)
 	require.Equal(t, []byte("hello world"), buf)
+
+	c.Close() //nolint:errcheck
+	server.Close()
+
+	checkPcapngPresence(t, prefix)
 }
 
 func TestConnRead(t *testing.T) {
 	client, server := startTCPPair(t)
-	defer server.Close()
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &conn{Prefix: prefix, Conn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapng(t, prefix)
-	defer c.Close() //nolint:errcheck
-
 	_, err := server.Write([]byte("incoming data"))
 	require.NoError(t, err)
 
@@ -103,19 +95,20 @@ func TestConnRead(t *testing.T) {
 	n, err := c.Read(buf)
 	require.NoError(t, err)
 	require.Equal(t, []byte("incoming data"), buf[:n])
+
+	c.Close() //nolint:errcheck
+	server.Close()
+
+	checkPcapngPresence(t, prefix)
 }
 
 func TestConnServerSide(t *testing.T) {
 	client, server := startTCPPair(t)
-	defer client.Close()
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &conn{Prefix: prefix, Conn: server, ServerSide: true}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapng(t, prefix)
-	defer c.Close() //nolint:errcheck
-
 	n, err := c.Write([]byte("server response"))
 	require.NoError(t, err)
 	require.Equal(t, 15, n)
@@ -124,19 +117,20 @@ func TestConnServerSide(t *testing.T) {
 	_, err = io.ReadFull(client, buf)
 	require.NoError(t, err)
 	require.Equal(t, []byte("server response"), buf)
+
+	c.Close() //nolint:errcheck
+	client.Close()
+
+	checkPcapngPresence(t, prefix)
 }
 
 func TestConnMultipleWriteRead(t *testing.T) {
 	client, server := startTCPPair(t)
-	defer server.Close()
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &conn{Prefix: prefix, Conn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapng(t, prefix)
-	defer c.Close() //nolint:errcheck
-
 	for _, msg := range []string{"foo", "bar", "baz"} {
 		n, err := c.Write([]byte(msg))
 		require.NoError(t, err)
@@ -157,37 +151,43 @@ func TestConnMultipleWriteRead(t *testing.T) {
 	_, err = io.ReadFull(c, readBuf)
 	require.NoError(t, err)
 	require.Equal(t, []byte("abcdefghij"), readBuf)
+
+	c.Close() //nolint:errcheck
+	server.Close()
+
+	checkPcapngPresence(t, prefix)
 }
 
 func TestConnCloseIdempotent(t *testing.T) {
 	client, server := startTCPPair(t)
-	defer server.Close()
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &conn{Prefix: prefix, Conn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapng(t, prefix)
+	c.Close() //nolint:errcheck
+	c.Close() //nolint:errcheck
+	server.Close()
 
-	defer c.Close() //nolint:errcheck
-	defer c.Close() //nolint:errcheck
+	checkPcapngPresence(t, prefix)
 }
 
 func TestConnDelegatesAddrMethods(t *testing.T) {
 	client, server := startTCPPair(t)
-	defer server.Close()
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &conn{Prefix: prefix, Conn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapng(t, prefix)
-	defer c.Close() //nolint:errcheck
-
 	require.Equal(t, client.LocalAddr(), c.LocalAddr())
 	require.Equal(t, client.RemoteAddr(), c.RemoteAddr())
 
 	require.NoError(t, c.SetDeadline(time.Now().Add(time.Second)))
 	require.NoError(t, c.SetReadDeadline(time.Now().Add(time.Second)))
 	require.NoError(t, c.SetWriteDeadline(time.Now().Add(time.Second)))
+
+	c.Close() //nolint:errcheck
+	server.Close()
+
+	checkPcapngPresence(t, prefix)
 }
diff --git a/internal/packetdumper/packet_conn_test.go b/internal/packetdumper/packet_conn_test.go
index 0f6dbe1b..f7e059c2 100644
--- a/internal/packetdumper/packet_conn_test.go
+++ b/internal/packetdumper/packet_conn_test.go
@@ -2,7 +2,6 @@ package packetdumper
 
 import (
 	"net"
-	"os"
 	"path/filepath"
 	"testing"
 	"time"
@@ -34,41 +33,26 @@ func startUDPPair(t *testing.T) (client, server *net.UDPConn) {
 	return client, server
 }
 
-func cleanupPcapngPacket(t *testing.T, prefix string) {
-	t.Helper()
-
-	matches, err := filepath.Glob(prefix + "_*.pcapng")
-	require.NoError(t, err, "glob for pcapng files")
-	require.NotEmpty(t, matches, "expected at least one pcapng file to have been created")
-
-	for _, f := range matches {
-		require.NoError(t, os.Remove(f), "removing pcapng file %s", f)
-	}
-}
-
 func TestPacketConnInitialize_CreatesFile(t *testing.T) {
 	client, server := startUDPPair(t)
-	defer server.Close() //nolint:errcheck
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &packetConn{Prefix: prefix, PacketConn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapngPacket(t, prefix)
-	defer c.Close() //nolint:errcheck
+	c.Close()      //nolint:errcheck
+	server.Close() //nolint:errcheck
+
+	checkPcapngPresence(t, prefix)
 }
 
 func TestPacketConnWriteTo(t *testing.T) {
 	client, server := startUDPPair(t)
-	defer server.Close() //nolint:errcheck
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &packetConn{Prefix: prefix, PacketConn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapngPacket(t, prefix)
-	defer c.Close() //nolint:errcheck
-
 	n, err := c.WriteTo([]byte("hello world"), server.LocalAddr())
 	require.NoError(t, err)
 	require.Equal(t, 11, n)
@@ -78,19 +62,20 @@ func TestPacketConnWriteTo(t *testing.T) {
 	rn, _, err := server.ReadFromUDP(buf)
 	require.NoError(t, err)
 	require.Equal(t, []byte("hello world"), buf[:rn])
+
+	c.Close()      //nolint:errcheck
+	server.Close() //nolint:errcheck
+
+	checkPcapngPresence(t, prefix)
 }
 
 func TestPacketConnReadFrom(t *testing.T) {
 	client, server := startUDPPair(t)
-	defer server.Close() //nolint:errcheck
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &packetConn{Prefix: prefix, PacketConn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapngPacket(t, prefix)
-	defer c.Close() //nolint:errcheck
-
 	_, err := server.WriteTo([]byte("incoming data"), client.LocalAddr())
 	require.NoError(t, err)
 
@@ -100,19 +85,20 @@ func TestPacketConnReadFrom(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, []byte("incoming data"), buf[:n])
 	require.NotNil(t, addr)
+
+	c.Close()      //nolint:errcheck
+	server.Close() //nolint:errcheck
+
+	checkPcapngPresence(t, prefix)
 }
 
 func TestPacketConnMultipleWriteRead(t *testing.T) {
 	client, server := startUDPPair(t)
-	defer server.Close() //nolint:errcheck
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &packetConn{Prefix: prefix, PacketConn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapngPacket(t, prefix)
-	defer c.Close() //nolint:errcheck
-
 	serverAddr := server.LocalAddr()
 	for _, msg := range []string{"foo", "bar", "baz"} {
 		n, err := c.WriteTo([]byte(msg), serverAddr)
@@ -143,51 +129,53 @@ func TestPacketConnMultipleWriteRead(t *testing.T) {
 		readReceived = append(readReceived, buf[:n]...)
 	}
 	require.Equal(t, []byte("abcdefghij"), readReceived)
+
+	c.Close()      //nolint:errcheck
+	server.Close() //nolint:errcheck
+
+	checkPcapngPresence(t, prefix)
 }
 
 func TestPacketConnCloseIdempotent(t *testing.T) {
 	client, server := startUDPPair(t)
-	defer server.Close() //nolint:errcheck
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &packetConn{Prefix: prefix, PacketConn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapngPacket(t, prefix)
+	c.Close()      //nolint:errcheck
+	c.Close()      //nolint:errcheck
+	server.Close() //nolint:errcheck
 
-	defer c.Close() //nolint:errcheck
-	defer c.Close() //nolint:errcheck
+	checkPcapngPresence(t, prefix)
 }
 
 func TestPacketConnDelegatesAddrMethods(t *testing.T) {
 	client, server := startUDPPair(t)
-	defer server.Close() //nolint:errcheck
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &packetConn{Prefix: prefix, PacketConn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapngPacket(t, prefix)
-	defer c.Close() //nolint:errcheck
-
 	require.Equal(t, client.LocalAddr(), c.LocalAddr())
 
 	require.NoError(t, c.SetDeadline(time.Now().Add(time.Second)))
 	require.NoError(t, c.SetReadDeadline(time.Now().Add(time.Second)))
 	require.NoError(t, c.SetWriteDeadline(time.Now().Add(time.Second)))
+
+	c.Close()      //nolint:errcheck
+	server.Close() //nolint:errcheck
+
+	checkPcapngPresence(t, prefix)
 }
 
 func TestPacketConnReadFromRecordsSource(t *testing.T) {
 	client, server := startUDPPair(t)
-	defer server.Close() //nolint:errcheck
 
 	prefix := filepath.Join(t.TempDir(), "capture")
 	c := &packetConn{Prefix: prefix, PacketConn: client}
 	require.NoError(t, c.Initialize())
 
-	defer cleanupPcapngPacket(t, prefix)
-	defer c.Close() //nolint:errcheck
-
 	_, err := server.WriteTo([]byte("ping"), client.LocalAddr())
 	require.NoError(t, err)
 
@@ -199,4 +187,9 @@ func TestPacketConnReadFromRecordsSource(t *testing.T) {
 
 	// The reported source address should match the server's address.
 	require.Equal(t, server.LocalAddr().String(), addr.String())
+
+	c.Close()      //nolint:errcheck
+	server.Close() //nolint:errcheck
+
+	checkPcapngPresence(t, prefix)
 }
diff --git a/internal/playback/on_get_test.go b/internal/playback/on_get_test.go
index 62d9a25a..0ed35ce5 100644
--- a/internal/playback/on_get_test.go
+++ b/internal/playback/on_get_test.go
@@ -239,11 +239,9 @@ func TestOnGet(t *testing.T) {
 			"mtxi",
 		} {
 			t.Run(format+"_"+mode, func(t *testing.T) {
-				dir, err := os.MkdirTemp("", "mediamtx-playback")
-				require.NoError(t, err)
-				defer os.RemoveAll(dir)
+				dir := t.TempDir()
 
-				err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
+				err := os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
 				require.NoError(t, err)
 
 				init := fmp4.Init{
@@ -700,11 +698,9 @@ func TestOnGet(t *testing.T) {
 }
 
 func TestOnGetDifferentInit(t *testing.T) {
-	dir, err := os.MkdirTemp("", "mediamtx-playback")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
-	err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
+	err := os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
 	require.NoError(t, err)
 
 	writeSegment1(t, filepath.Join(dir, "mypath", "2008-11-07_11-22-00-500000.mp4"))
@@ -782,11 +778,9 @@ func TestOnGetDifferentInit(t *testing.T) {
 func TestOnGetInMiddleOfLastSample(t *testing.T) {
 	for _, format := range []string{"fmp4", "mp4"} {
 		t.Run(format, func(t *testing.T) {
-			dir, err := os.MkdirTemp("", "mediamtx-playback")
-			require.NoError(t, err)
-			defer os.RemoveAll(dir)
+			dir := t.TempDir()
 
-			err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
+			err := os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
 			require.NoError(t, err)
 
 			init := fmp4.Init{
@@ -914,11 +908,9 @@ func TestOnGetBetweenSegments(t *testing.T) {
 		"idr after",
 	} {
 		t.Run(ca, func(t *testing.T) {
-			dir, err := os.MkdirTemp("", "mediamtx-playback")
-			require.NoError(t, err)
-			defer os.RemoveAll(dir)
+			dir := t.TempDir()
 
-			err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
+			err := os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
 			require.NoError(t, err)
 
 			init := fmp4.Init{
diff --git a/internal/playback/on_list_test.go b/internal/playback/on_list_test.go
index cf6fe6ae..807947e4 100644
--- a/internal/playback/on_list_test.go
+++ b/internal/playback/on_list_test.go
@@ -31,11 +31,9 @@ func TestOnList(t *testing.T) {
 		"start before first",
 	} {
 		t.Run(ca, func(t *testing.T) {
-			dir, err := os.MkdirTemp("", "mediamtx-playback")
-			require.NoError(t, err)
-			defer os.RemoveAll(dir)
+			dir := t.TempDir()
 
-			err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
+			err := os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
 			require.NoError(t, err)
 
 			switch ca {
@@ -289,11 +287,9 @@ func TestOnListInvalidPath(t *testing.T) {
 }
 
 func TestOnListCachedDuration(t *testing.T) {
-	dir, err := os.MkdirTemp("", "mediamtx-playback")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
-	err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
+	err := os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
 	require.NoError(t, err)
 
 	func() {
@@ -371,11 +367,9 @@ func TestOnListCachedDuration(t *testing.T) {
 }
 
 func TestOnListXForwardedProto(t *testing.T) {
-	dir, err := os.MkdirTemp("", "mediamtx-playback")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
-	err = os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
+	err := os.Mkdir(filepath.Join(dir, "mypath"), 0o755)
 	require.NoError(t, err)
 
 	writeSegment1(t, filepath.Join(dir, "mypath", "2008-11-07_11-22-00-500000.mp4"))
diff --git a/internal/playback/segment_fmp4_test.go b/internal/playback/segment_fmp4_test.go
index 9edb6792..4d156434 100644
--- a/internal/playback/segment_fmp4_test.go
+++ b/internal/playback/segment_fmp4_test.go
@@ -54,11 +54,10 @@ func writeBenchInit(f io.WriteSeeker) {
 }
 
 func BenchmarkFMP4ReadHeader(b *testing.B) {
-	f, err := os.CreateTemp(os.TempDir(), "mediamtx-playback-fmp4-")
+	f, err := os.CreateTemp(b.TempDir(), "mediamtx-playback-fmp4-")
 	if err != nil {
 		panic(err)
 	}
-	defer os.Remove(f.Name())
 
 	writeBenchInit(f)
 	f.Close()
diff --git a/internal/protocols/unix/listener_test.go b/internal/protocols/unix/listener_test.go
index 729742f1..62729199 100644
--- a/internal/protocols/unix/listener_test.go
+++ b/internal/protocols/unix/listener_test.go
@@ -10,10 +10,9 @@ import (
 )
 
 func TestListen(t *testing.T) {
-	socket, err := os.CreateTemp(os.TempDir(), "mtx-unix-")
+	socket, err := os.CreateTemp(t.TempDir(), "mtx-unix-")
 	require.NoError(t, err)
 	socket.Close()
-	defer os.Remove(socket.Name())
 
 	l := &Listener{
 		Path: socket.Name(),
diff --git a/internal/recordcleaner/cleaner_test.go b/internal/recordcleaner/cleaner_test.go
index 9f9a1822..a2cc84fe 100644
--- a/internal/recordcleaner/cleaner_test.go
+++ b/internal/recordcleaner/cleaner_test.go
@@ -17,13 +17,11 @@ func TestCleaner(t *testing.T) {
 		return time.Date(2009, 5, 20, 22, 15, 25, 427000, time.Local)
 	}
 
-	dir, err := os.MkdirTemp("", "mediamtx-cleaner")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	const specialChars = "_-+*?^$()[]{}|"
 
-	err = os.Mkdir(filepath.Join(dir, specialChars+"_mypath"), 0o755)
+	err := os.Mkdir(filepath.Join(dir, specialChars+"_mypath"), 0o755)
 	require.NoError(t, err)
 
 	err = os.WriteFile(filepath.Join(dir, specialChars+"_mypath", "2008-05-20_22-15-25-000125.mp4"), []byte{1}, 0o644)
@@ -61,11 +59,9 @@ func TestCleanerMultipleEntriesSamePath(t *testing.T) {
 		return time.Date(2009, 5, 20, 22, 15, 25, 427000, time.Local)
 	}
 
-	dir, err := os.MkdirTemp("", "mediamtx-cleaner")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
-	err = os.Mkdir(filepath.Join(dir, "path1"), 0o755)
+	err := os.Mkdir(filepath.Join(dir, "path1"), 0o755)
 	require.NoError(t, err)
 
 	err = os.Mkdir(filepath.Join(dir, "path2"), 0o755)
diff --git a/internal/recorder/recorder_test.go b/internal/recorder/recorder_test.go
index e9af32da..ed3015a4 100644
--- a/internal/recorder/recorder_test.go
+++ b/internal/recorder/recorder_test.go
@@ -146,9 +146,7 @@ func TestRecorder(t *testing.T) {
 			err = subStream.Initialize()
 			require.NoError(t, err)
 
-			dir, err := os.MkdirTemp("", "mediamtx-agent")
-			require.NoError(t, err)
-			defer os.RemoveAll(dir)
+			dir := t.TempDir()
 
 			recordPath := filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")
 
@@ -441,9 +439,7 @@ func TestRecorderFMP4NegativeInitialDTS(t *testing.T) {
 	err = subStream.Initialize()
 	require.NoError(t, err)
 
-	dir, err := os.MkdirTemp("", "mediamtx-agent")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	recordPath := filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")
 
@@ -536,9 +532,7 @@ func TestRecorderFMP4NegativeDTSDiff(t *testing.T) {
 	err = subStream.Initialize()
 	require.NoError(t, err)
 
-	dir, err := os.MkdirTemp("", "mediamtx-agent")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	recordPath := filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")
 
@@ -636,9 +630,7 @@ func TestRecorderSkipTracksPartial(t *testing.T) {
 			err = subStream.Initialize()
 			require.NoError(t, err)
 
-			dir, err := os.MkdirTemp("", "mediamtx-agent")
-			require.NoError(t, err)
-			defer os.RemoveAll(dir)
+			dir := t.TempDir()
 
 			recordPath := filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")
 
@@ -704,9 +696,7 @@ func TestRecorderSkipTracksFull(t *testing.T) {
 			err = subStream.Initialize()
 			require.NoError(t, err)
 
-			dir, err := os.MkdirTemp("", "mediamtx-agent")
-			require.NoError(t, err)
-			defer os.RemoveAll(dir)
+			dir := t.TempDir()
 
 			recordPath := filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")
 
@@ -774,9 +764,7 @@ func TestRecorderFMP4SegmentSwitch(t *testing.T) {
 	err = subStream.Initialize()
 	require.NoError(t, err)
 
-	dir, err := os.MkdirTemp("", "mediamtx-agent")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	n := 0
 
@@ -903,9 +891,7 @@ func TestRecorderTimeDriftDetector(t *testing.T) {
 			err = subStream.Initialize()
 			require.NoError(t, err)
 
-			dir, err := os.MkdirTemp("", "mediamtx-agent")
-			require.NoError(t, err)
-			defer os.RemoveAll(dir)
+			dir := t.TempDir()
 
 			recordPath := filepath.Join(dir, "%path/%Y-%m-%d_%H-%M-%S-%f")
 
diff --git a/internal/recordstore/segment_test.go b/internal/recordstore/segment_test.go
index aa535fcc..52d65951 100644
--- a/internal/recordstore/segment_test.go
+++ b/internal/recordstore/segment_test.go
@@ -18,11 +18,9 @@ func ptrOf[T any](v T) *T {
 }
 
 func TestFindAllPathsWithSegments(t *testing.T) {
-	dir, err := os.MkdirTemp("", "mediamtx-recordstore")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
-	err = os.Mkdir(filepath.Join(dir, "path1"), 0o755)
+	err := os.Mkdir(filepath.Join(dir, "path1"), 0o755)
 	require.NoError(t, err)
 
 	err = os.Mkdir(filepath.Join(dir, "path2"), 0o755)
@@ -51,11 +49,9 @@ func TestFindAllPathsWithSegments(t *testing.T) {
 }
 
 func TestFindAllPathsWithSegmentsInvalidPath(t *testing.T) {
-	dir, err := os.MkdirTemp("", "mediamtx-recordstore")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
-	err = os.WriteFile(filepath.Join(dir, "_2015-05-19_22-15-25-000427.mp4"), []byte{1}, 0o644)
+	err := os.WriteFile(filepath.Join(dir, "_2015-05-19_22-15-25-000427.mp4"), []byte{1}, 0o644)
 	require.NoError(t, err)
 
 	paths := FindAllPathsWithSegments(map[string]*conf.Path{
@@ -76,11 +72,9 @@ func TestFindSegments(t *testing.T) {
 		"start before first",
 	} {
 		t.Run(ca, func(t *testing.T) {
-			dir, err := os.MkdirTemp("", "mediamtx-recordstore")
-			require.NoError(t, err)
-			defer os.RemoveAll(dir)
+			dir := t.TempDir()
 
-			err = os.Mkdir(filepath.Join(dir, "path1"), 0o755)
+			err := os.Mkdir(filepath.Join(dir, "path1"), 0o755)
 			require.NoError(t, err)
 
 			err = os.Mkdir(filepath.Join(dir, "path2"), 0o755)
diff --git a/internal/servers/hls/server_test.go b/internal/servers/hls/server_test.go
index bb2db936..18a6e956 100644
--- a/internal/servers/hls/server_test.go
+++ b/internal/servers/hls/server_test.go
@@ -488,9 +488,7 @@ func TestServerRead(t *testing.T) {
 }
 
 func TestServerDirectory(t *testing.T) {
-	dir, err := os.MkdirTemp("", "mediamtx-playback")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 
 	desc := &description.Session{Medias: []*description.Media{test.MediaH264}}
 
@@ -500,7 +498,7 @@ func TestServerDirectory(t *testing.T) {
 		RTPMaxPayloadSize: 1450,
 		Parent:            test.NilLogger,
 	}
-	err = strm.Initialize()
+	err := strm.Initialize()
 	require.NoError(t, err)
 
 	subStream := &stream.SubStream{
diff --git a/internal/servers/rtmp/server_test.go b/internal/servers/rtmp/server_test.go
index 9b14257f..eceed8df 100644
--- a/internal/servers/rtmp/server_test.go
+++ b/internal/servers/rtmp/server_test.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"crypto/tls"
 	"net/url"
-	"os"
 	"testing"
 	"time"
 
@@ -50,14 +49,8 @@ func TestServerPublish(t *testing.T) {
 			var serverKeyFpath string
 
 			if encrypt == "tls" {
-				var err error
-				serverCertFpath, err = test.CreateTempFile(test.TLSCertPub)
-				require.NoError(t, err)
-				defer os.Remove(serverCertFpath)
-
-				serverKeyFpath, err = test.CreateTempFile(test.TLSCertKey)
-				require.NoError(t, err)
-				defer os.Remove(serverKeyFpath)
+				serverCertFpath = test.CreateTempFile(t, test.TLSCertPub)
+				serverKeyFpath = test.CreateTempFile(t, test.TLSCertKey)
 			}
 
 			var strm *stream.Stream
@@ -225,14 +218,8 @@ func TestServerRead(t *testing.T) {
 			var serverKeyFpath string
 
 			if encrypt == "tls" {
-				var err error
-				serverCertFpath, err = test.CreateTempFile(test.TLSCertPub)
-				require.NoError(t, err)
-				defer os.Remove(serverCertFpath)
-
-				serverKeyFpath, err = test.CreateTempFile(test.TLSCertKey)
-				require.NoError(t, err)
-				defer os.Remove(serverKeyFpath)
+				serverCertFpath = test.CreateTempFile(t, test.TLSCertPub)
+				serverKeyFpath = test.CreateTempFile(t, test.TLSCertKey)
 			}
 			desc := &description.Session{Medias: []*description.Media{test.MediaH264}}
 
diff --git a/internal/staticsources/mpegts/source_test.go b/internal/staticsources/mpegts/source_test.go
index ecd8b3bd..b9c43988 100644
--- a/internal/staticsources/mpegts/source_test.go
+++ b/internal/staticsources/mpegts/source_test.go
@@ -157,7 +157,7 @@ func TestSourceUnixSocket(t *testing.T) {
 			if ca == "relative" {
 				pa = "test_mpegts.sock"
 			} else {
-				pa = filepath.Join(os.TempDir(), "test_mpegts.sock")
+				pa = filepath.Join(t.TempDir(), "test_mpegts.sock")
 			}
 
 			func() {
diff --git a/internal/staticsources/rtmp/source_test.go b/internal/staticsources/rtmp/source_test.go
index 633275f4..d65c97c9 100644
--- a/internal/staticsources/rtmp/source_test.go
+++ b/internal/staticsources/rtmp/source_test.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"crypto/tls"
 	"net"
-	"os"
 	"testing"
 	"time"
 
@@ -34,16 +33,11 @@ func TestSource(t *testing.T) {
 					ln, err = net.Listen("tcp", "127.0.0.1:1935")
 					require.NoError(t, err)
 				} else {
-					serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
-					require.NoError(t, err)
-					defer os.Remove(serverCertFpath)
-
-					serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
-					require.NoError(t, err)
-					defer os.Remove(serverKeyFpath)
+					serverCertFpath := test.CreateTempFile(t, test.TLSCertPub)
+					serverKeyFpath := test.CreateTempFile(t, test.TLSCertKey)
 
 					var cert tls.Certificate
-					cert, err = tls.LoadX509KeyPair(serverCertFpath, serverKeyFpath)
+					cert, err := tls.LoadX509KeyPair(serverCertFpath, serverKeyFpath)
 					require.NoError(t, err)
 
 					ln, err = tls.Listen("tcp", "127.0.0.1:1936", &tls.Config{Certificates: []tls.Certificate{cert}})
diff --git a/internal/staticsources/rtp/source_test.go b/internal/staticsources/rtp/source_test.go
index faf6ce5f..998b3b7e 100644
--- a/internal/staticsources/rtp/source_test.go
+++ b/internal/staticsources/rtp/source_test.go
@@ -159,7 +159,7 @@ func TestSourceUnixSocket(t *testing.T) {
 			if ca == "relative" {
 				pa = "test_rtp.sock"
 			} else {
-				pa = filepath.Join(os.TempDir(), "test_rtp.sock")
+				pa = filepath.Join(t.TempDir(), "test_rtp.sock")
 			}
 
 			func() {
diff --git a/internal/staticsources/rtsp/source_test.go b/internal/staticsources/rtsp/source_test.go
index 0cef9fe5..ff1f8393 100644
--- a/internal/staticsources/rtsp/source_test.go
+++ b/internal/staticsources/rtsp/source_test.go
@@ -3,7 +3,6 @@ package rtsp
 import (
 	"context"
 	"crypto/tls"
-	"os"
 	"testing"
 	"time"
 
@@ -131,15 +130,8 @@ func TestSource(t *testing.T) {
 				s.UDPRTCPAddress = "127.0.0.1:8003"
 
 			case "rtsps", "rtsps+http", "rtsps+ws":
-				var serverCertFpath string
-				serverCertFpath, err = test.CreateTempFile(test.TLSCertPub)
-				require.NoError(t, err)
-				defer os.Remove(serverCertFpath)
-
-				var serverKeyFpath string
-				serverKeyFpath, err = test.CreateTempFile(test.TLSCertKey)
-				require.NoError(t, err)
-				defer os.Remove(serverKeyFpath)
+				serverCertFpath := test.CreateTempFile(t, test.TLSCertPub)
+				serverKeyFpath := test.CreateTempFile(t, test.TLSCertKey)
 
 				var cert tls.Certificate
 				cert, err = tls.LoadX509KeyPair(serverCertFpath, serverKeyFpath)
diff --git a/internal/stream/stream_alwaysavailable_test.go b/internal/stream/stream_alwaysavailable_test.go
index a2f3727d..dfa5790d 100644
--- a/internal/stream/stream_alwaysavailable_test.go
+++ b/internal/stream/stream_alwaysavailable_test.go
@@ -148,9 +148,8 @@ func TestStreamAlwaysAvailable(t *testing.T) {
 					{Codec: conf.CodecLPCM, SampleRate: 48000, ChannelCount: 2},
 				}
 			} else {
-				tmpf, err := os.CreateTemp(os.TempDir(), "rtsp-")
+				tmpf, err := os.CreateTemp(t.TempDir(), "rtsp-")
 				require.NoError(t, err)
-				defer os.Remove(tmpf.Name())
 
 				pmp4 := &pmp4.Presentation{
 					Tracks: []*pmp4.Track{
diff --git a/internal/test/temp_file.go b/internal/test/temp_file.go
index d7e62feb..27334ff9 100644
--- a/internal/test/temp_file.go
+++ b/internal/test/temp_file.go
@@ -1,19 +1,20 @@
 package test
 
-import "os"
+import (
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
 
 // CreateTempFile creates a temporary file with given content.
-func CreateTempFile(byts []byte) (string, error) {
-	tmpf, err := os.CreateTemp(os.TempDir(), "rtsp-")
-	if err != nil {
-		return "", err
-	}
+func CreateTempFile(t *testing.T, byts []byte) string {
+	tmpf, err := os.CreateTemp(t.TempDir(), "rtsp-")
+	require.NoError(t, err)
 	defer tmpf.Close()
 
 	_, err = tmpf.Write(byts)
-	if err != nil {
-		return "", err
-	}
+	require.NoError(t, err)
 
-	return tmpf.Name(), nil
+	return tmpf.Name()
 }
diff --git a/internal/teste2e/hls_manager_test.go b/internal/teste2e/hls_manager_test.go
index 0ebb7ea3..2f30c9d3 100644
--- a/internal/teste2e/hls_manager_test.go
+++ b/internal/teste2e/hls_manager_test.go
@@ -11,7 +11,7 @@ import (
 )
 
 func TestHLSServerRead(t *testing.T) {
-	p, ok := newInstance("paths:\n" +
+	p, ok := newInstance(t, "paths:\n"+
 		"  all_others:\n")
 	require.Equal(t, true, ok)
 	defer p.Close()
@@ -52,7 +52,7 @@ func TestHLSServerAuth(t *testing.T) {
 				"    readPass: testpass\n" +
 				"    readIPs: [127.0.0.0/16]\n"
 
-			p, ok := newInstance(cnf)
+			p, ok := newInstance(t, cnf)
 			require.Equal(t, true, ok)
 			defer p.Close()
 
diff --git a/internal/teste2e/rtsp_server_test.go b/internal/teste2e/rtsp_server_test.go
index fbfed7de..82590b93 100644
--- a/internal/teste2e/rtsp_server_test.go
+++ b/internal/teste2e/rtsp_server_test.go
@@ -3,7 +3,6 @@
 package teste2e
 
 import (
-	"os"
 	"testing"
 	"time"
 
@@ -42,11 +41,11 @@ func TestRTSPServerPublishRead(t *testing.T) {
 				proto = "rtsp"
 				port = "8554"
 
-				p, ok := newInstance("rtmp: no\n" +
-					"hls: no\n" +
-					"webrtc: no\n" +
-					"readTimeout: 20s\n" +
-					"paths:\n" +
+				p, ok := newInstance(t, "rtmp: no\n"+
+					"hls: no\n"+
+					"webrtc: no\n"+
+					"readTimeout: 20s\n"+
+					"paths:\n"+
 					"  all_others:\n")
 				require.Equal(t, true, ok)
 				defer p.Close()
@@ -54,23 +53,18 @@ func TestRTSPServerPublishRead(t *testing.T) {
 				proto = "rtsps"
 				port = "8322"
 
-				serverCertFpath, err := test.CreateTempFile(test.TLSCertPub)
-				require.NoError(t, err)
-				defer os.Remove(serverCertFpath)
+				serverCertFpath := test.CreateTempFile(t, test.TLSCertPub)
+				serverKeyFpath := test.CreateTempFile(t, test.TLSCertKey)
 
-				serverKeyFpath, err := test.CreateTempFile(test.TLSCertKey)
-				require.NoError(t, err)
-				defer os.Remove(serverKeyFpath)
-
-				p, ok := newInstance("rtmp: no\n" +
-					"hls: no\n" +
-					"webrtc: no\n" +
-					"readTimeout: 20s\n" +
-					"rtspTransports: [tcp]\n" +
-					"rtspEncryption: \"yes\"\n" +
-					"rtspServerCert: " + serverCertFpath + "\n" +
-					"rtspServerKey: " + serverKeyFpath + "\n" +
-					"paths:\n" +
+				p, ok := newInstance(t, "rtmp: no\n"+
+					"hls: no\n"+
+					"webrtc: no\n"+
+					"readTimeout: 20s\n"+
+					"rtspTransports: [tcp]\n"+
+					"rtspEncryption: \"yes\"\n"+
+					"rtspServerCert: "+serverCertFpath+"\n"+
+					"rtspServerKey: "+serverKeyFpath+"\n"+
+					"paths:\n"+
 					"  all_others:\n")
 				require.Equal(t, true, ok)
 				defer p.Close()
@@ -199,13 +193,13 @@ func TestRTSPServerPublishRead(t *testing.T) {
 }
 
 func TestRTSPServerRedirect(t *testing.T) {
-	p1, ok := newInstance("rtmp: no\n" +
-		"hls: no\n" +
-		"webrtc: no\n" +
-		"paths:\n" +
-		"  path1:\n" +
-		"    source: redirect\n" +
-		"    sourceRedirect: rtsp://localhost:8554/path2\n" +
+	p1, ok := newInstance(t, "rtmp: no\n"+
+		"hls: no\n"+
+		"webrtc: no\n"+
+		"paths:\n"+
+		"  path1:\n"+
+		"    source: redirect\n"+
+		"    sourceRedirect: rtsp://localhost:8554/path2\n"+
 		"  path2:\n")
 	require.Equal(t, true, ok)
 	defer p1.Close()
diff --git a/internal/teste2e/tests_test.go b/internal/teste2e/tests_test.go
index 5d553443..a8838658 100644
--- a/internal/teste2e/tests_test.go
+++ b/internal/teste2e/tests_test.go
@@ -6,22 +6,19 @@ import (
 	"os"
 	"os/exec"
 	"strconv"
+	"testing"
 	"time"
 
 	"github.com/bluenviron/mediamtx/internal/core"
 	"github.com/bluenviron/mediamtx/internal/test"
 )
 
-func newInstance(conf string) (*core.Core, bool) {
+func newInstance(t *testing.T, conf string) (*core.Core, bool) {
 	if conf == "" {
 		return core.New([]string{})
 	}
 
-	tmpf, err := test.CreateTempFile([]byte(conf))
-	if err != nil {
-		return nil, false
-	}
-	defer os.Remove(tmpf)
+	tmpf := test.CreateTempFile(t, []byte(conf))
 
 	return core.New([]string{tmpf})
 }