diff --git a/abci/example/kvstore/kvstore_test.go b/abci/example/kvstore/kvstore_test.go
index 0c104f6d7..4418aa58e 100644
--- a/abci/example/kvstore/kvstore_test.go
+++ b/abci/example/kvstore/kvstore_test.go
@@ -3,7 +3,6 @@ package kvstore
 import (
 	"context"
 	"fmt"
-	"os"
 	"sort"
 	"testing"
 
@@ -72,10 +71,7 @@ func TestKVStoreKV(t *testing.T) {
 }
 
 func TestPersistentKVStoreKV(t *testing.T) {
-	dir, err := os.MkdirTemp("/tmp", "abci-kvstore-test") // TODO
-	if err != nil {
-		t.Fatal(err)
-	}
+	dir := t.TempDir()
 	logger := log.NewTestingLogger(t)
 
 	kvstore := NewPersistentKVStoreApplication(logger, dir)
@@ -90,10 +86,7 @@ func TestPersistentKVStoreKV(t *testing.T) {
 }
 
 func TestPersistentKVStoreInfo(t *testing.T) {
-	dir, err := os.MkdirTemp("/tmp", "abci-kvstore-test") // TODO
-	if err != nil {
-		t.Fatal(err)
-	}
+	dir := t.TempDir()
 	logger := log.NewTestingLogger(t)
 
 	kvstore := NewPersistentKVStoreApplication(logger, dir)
@@ -124,10 +117,7 @@ func TestPersistentKVStoreInfo(t *testing.T) {
 
 // add a validator, remove a validator, update a validator
 func TestValUpdates(t *testing.T) {
-	dir, err := os.MkdirTemp("/tmp", "abci-kvstore-test") // TODO
-	if err != nil {
-		t.Fatal(err)
-	}
+	dir := t.TempDir()
 	logger := log.NewTestingLogger(t)
 
 	kvstore := NewPersistentKVStoreApplication(logger, dir)
diff --git a/cmd/tendermint/commands/reindex_event_test.go b/cmd/tendermint/commands/reindex_event_test.go
index 91b1ba42a..a35307a84 100644
--- a/cmd/tendermint/commands/reindex_event_test.go
+++ b/cmd/tendermint/commands/reindex_event_test.go
@@ -110,7 +110,7 @@ func TestLoadEventSink(t *testing.T) {
 }
 
 func TestLoadBlockStore(t *testing.T) {
-	testCfg, err := config.ResetTestRoot(t.Name())
+	testCfg, err := config.ResetTestRoot(t.TempDir(), t.Name())
 	require.NoError(t, err)
 	testCfg.DBBackend = "goleveldb"
 	_, _, err = loadStateAndBlockStore(testCfg)
diff --git a/cmd/tendermint/commands/rollback_test.go b/cmd/tendermint/commands/rollback_test.go
index 43e25915f..760dbf0ec 100644
--- a/cmd/tendermint/commands/rollback_test.go
+++ b/cmd/tendermint/commands/rollback_test.go
@@ -19,7 +19,7 @@ func TestRollbackIntegration(t *testing.T) {
 	dir := t.TempDir()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	cfg, err := rpctest.CreateConfig(t.Name())
+	cfg, err := rpctest.CreateConfig(t, t.Name())
 	require.NoError(t, err)
 	cfg.BaseConfig.DBBackend = "goleveldb"
 
diff --git a/config/toml.go b/config/toml.go
index 665300727..41d2a6614 100644
--- a/config/toml.go
+++ b/config/toml.go
@@ -504,13 +504,13 @@ namespace = "{{ .Instrumentation.Namespace }}"
 
 /****** these are for test settings ***********/
 
-func ResetTestRoot(testName string) (*Config, error) {
-	return ResetTestRootWithChainID(testName, "")
+func ResetTestRoot(dir, testName string) (*Config, error) {
+	return ResetTestRootWithChainID(dir, testName, "")
 }
 
-func ResetTestRootWithChainID(testName string, chainID string) (*Config, error) {
+func ResetTestRootWithChainID(dir, testName string, chainID string) (*Config, error) {
 	// create a unique, concurrency-safe test directory under os.TempDir()
-	rootDir, err := os.MkdirTemp("", fmt.Sprintf("%s-%s_", chainID, testName))
+	rootDir, err := os.MkdirTemp(dir, fmt.Sprintf("%s-%s_", chainID, testName))
 	if err != nil {
 		return nil, err
 	}
diff --git a/config/toml_test.go b/config/toml_test.go
index fa7e88da0..cf27c4484 100644
--- a/config/toml_test.go
+++ b/config/toml_test.go
@@ -20,9 +20,7 @@ func ensureFiles(t *testing.T, rootDir string, files ...string) {
 
 func TestEnsureRoot(t *testing.T) {
 	// setup temp dir for test
-	tmpDir, err := os.MkdirTemp("", "config-test")
-	require.NoError(t, err)
-	defer os.RemoveAll(tmpDir)
+	tmpDir := t.TempDir()
 
 	// create root dir
 	EnsureRoot(tmpDir)
@@ -42,7 +40,7 @@ func TestEnsureTestRoot(t *testing.T) {
 	testName := "ensureTestRoot"
 
 	// create root dir
-	cfg, err := ResetTestRoot(testName)
+	cfg, err := ResetTestRoot(t.TempDir(), testName)
 	require.NoError(t, err)
 	defer os.RemoveAll(cfg.RootDir)
 	rootDir := cfg.RootDir
diff --git a/internal/blocksync/reactor_test.go b/internal/blocksync/reactor_test.go
index 25814a2ea..3a6b7b2f5 100644
--- a/internal/blocksync/reactor_test.go
+++ b/internal/blocksync/reactor_test.go
@@ -203,7 +203,7 @@ func TestReactor_AbruptDisconnect(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cfg, err := config.ResetTestRoot("block_sync_reactor_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "block_sync_reactor_test")
 	require.NoError(t, err)
 	defer os.RemoveAll(cfg.RootDir)
 
@@ -243,7 +243,7 @@ func TestReactor_SyncTime(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cfg, err := config.ResetTestRoot("block_sync_reactor_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "block_sync_reactor_test")
 	require.NoError(t, err)
 	defer os.RemoveAll(cfg.RootDir)
 
@@ -271,7 +271,7 @@ func TestReactor_NoBlockResponse(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cfg, err := config.ResetTestRoot("block_sync_reactor_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "block_sync_reactor_test")
 	require.NoError(t, err)
 	defer os.RemoveAll(cfg.RootDir)
 
@@ -323,7 +323,7 @@ func TestReactor_BadBlockStopsPeer(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cfg, err := config.ResetTestRoot("block_sync_reactor_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "block_sync_reactor_test")
 	require.NoError(t, err)
 	defer os.RemoveAll(cfg.RootDir)
 
diff --git a/internal/consensus/byzantine_test.go b/internal/consensus/byzantine_test.go
index 50b4ffc30..f7bae0fa8 100644
--- a/internal/consensus/byzantine_test.go
+++ b/internal/consensus/byzantine_test.go
@@ -60,7 +60,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 			require.NoError(t, err)
 			require.NoError(t, stateStore.Save(state))
 
-			thisConfig, err := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
+			thisConfig, err := ResetConfig(t.TempDir(), fmt.Sprintf("%s_%d", testName, i))
 			require.NoError(t, err)
 
 			defer os.RemoveAll(thisConfig.RootDir)
diff --git a/internal/consensus/common_test.go b/internal/consensus/common_test.go
index 2ec3dda9a..bddc2c2c3 100644
--- a/internal/consensus/common_test.go
+++ b/internal/consensus/common_test.go
@@ -50,23 +50,23 @@ type cleanupFunc func()
 func configSetup(t *testing.T) *config.Config {
 	t.Helper()
 
-	cfg, err := ResetConfig("consensus_reactor_test")
+	cfg, err := ResetConfig(t.TempDir(), "consensus_reactor_test")
 	require.NoError(t, err)
 	t.Cleanup(func() { os.RemoveAll(cfg.RootDir) })
 
-	consensusReplayConfig, err := ResetConfig("consensus_replay_test")
+	consensusReplayConfig, err := ResetConfig(t.TempDir(), "consensus_replay_test")
 	require.NoError(t, err)
 	t.Cleanup(func() { os.RemoveAll(consensusReplayConfig.RootDir) })
 
-	configStateTest, err := ResetConfig("consensus_state_test")
+	configStateTest, err := ResetConfig(t.TempDir(), "consensus_state_test")
 	require.NoError(t, err)
 	t.Cleanup(func() { os.RemoveAll(configStateTest.RootDir) })
 
-	configMempoolTest, err := ResetConfig("consensus_mempool_test")
+	configMempoolTest, err := ResetConfig(t.TempDir(), "consensus_mempool_test")
 	require.NoError(t, err)
 	t.Cleanup(func() { os.RemoveAll(configMempoolTest.RootDir) })
 
-	configByzantineTest, err := ResetConfig("consensus_byzantine_test")
+	configByzantineTest, err := ResetConfig(t.TempDir(), "consensus_byzantine_test")
 	require.NoError(t, err)
 	t.Cleanup(func() { os.RemoveAll(configByzantineTest.RootDir) })
 
@@ -78,8 +78,8 @@ func ensureDir(t *testing.T, dir string, mode os.FileMode) {
 	require.NoError(t, tmos.EnsureDir(dir, mode))
 }
 
-func ResetConfig(name string) (*config.Config, error) {
-	return config.ResetTestRoot(name)
+func ResetConfig(dir, name string) (*config.Config, error) {
+	return config.ResetTestRoot(dir, name)
 }
 
 //-------------------------------------------------------------------------------
@@ -422,7 +422,7 @@ func newState(
 ) *State {
 	t.Helper()
 
-	cfg, err := config.ResetTestRoot("consensus_state_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "consensus_state_test")
 	require.NoError(t, err)
 
 	return newStateWithConfig(ctx, t, logger, cfg, state, pv, app)
@@ -769,7 +769,7 @@ func makeConsensusState(
 		blockStore := store.NewBlockStore(dbm.NewMemDB()) // each state needs its own db
 		state, err := sm.MakeGenesisState(genDoc)
 		require.NoError(t, err)
-		thisConfig, err := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
+		thisConfig, err := ResetConfig(t.TempDir(), fmt.Sprintf("%s_%d", testName, i))
 		require.NoError(t, err)
 
 		configRootDirs = append(configRootDirs, thisConfig.RootDir)
@@ -827,7 +827,7 @@ func randConsensusNetWithPeers(
 	configRootDirs := make([]string, 0, nPeers)
 	for i := 0; i < nPeers; i++ {
 		state, _ := sm.MakeGenesisState(genDoc)
-		thisConfig, err := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
+		thisConfig, err := ResetConfig(t.TempDir(), fmt.Sprintf("%s_%d", testName, i))
 		require.NoError(t, err)
 
 		configRootDirs = append(configRootDirs, thisConfig.RootDir)
@@ -839,10 +839,10 @@ func randConsensusNetWithPeers(
 		if i < nValidators {
 			privVal = privVals[i]
 		} else {
-			tempKeyFile, err := os.CreateTemp("", "priv_validator_key_")
+			tempKeyFile, err := os.CreateTemp(t.TempDir(), "priv_validator_key_")
 			require.NoError(t, err)
 
-			tempStateFile, err := os.CreateTemp("", "priv_validator_state_")
+			tempStateFile, err := os.CreateTemp(t.TempDir(), "priv_validator_state_")
 			require.NoError(t, err)
 
 			privVal, err = privval.GenFilePV(tempKeyFile.Name(), tempStateFile.Name(), "")
@@ -946,8 +946,7 @@ func (*mockTicker) SetLogger(log.Logger) {}
 func newPersistentKVStore(t *testing.T, logger log.Logger) abci.Application {
 	t.Helper()
 
-	dir, err := os.MkdirTemp("", "persistent-kvstore")
-	require.NoError(t, err)
+	dir := t.TempDir()
 
 	return kvstore.NewPersistentKVStoreApplication(logger, dir)
 }
diff --git a/internal/consensus/mempool_test.go b/internal/consensus/mempool_test.go
index 0cbee4fcd..cef661592 100644
--- a/internal/consensus/mempool_test.go
+++ b/internal/consensus/mempool_test.go
@@ -35,7 +35,7 @@ func TestMempoolNoProgressUntilTxsAvailable(t *testing.T) {
 
 	baseConfig := configSetup(t)
 
-	config, err := ResetConfig("consensus_mempool_txs_available_test")
+	config, err := ResetConfig(t.TempDir(), "consensus_mempool_txs_available_test")
 	require.NoError(t, err)
 	t.Cleanup(func() { _ = os.RemoveAll(config.RootDir) })
 
@@ -62,7 +62,7 @@ func TestMempoolProgressAfterCreateEmptyBlocksInterval(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	config, err := ResetConfig("consensus_mempool_txs_available_test")
+	config, err := ResetConfig(t.TempDir(), "consensus_mempool_txs_available_test")
 	require.NoError(t, err)
 	t.Cleanup(func() { _ = os.RemoveAll(config.RootDir) })
 
@@ -87,7 +87,7 @@ func TestMempoolProgressInHigherRound(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	config, err := ResetConfig("consensus_mempool_txs_available_test")
+	config, err := ResetConfig(t.TempDir(), "consensus_mempool_txs_available_test")
 	require.NoError(t, err)
 	t.Cleanup(func() { _ = os.RemoveAll(config.RootDir) })
 
diff --git a/internal/consensus/reactor_test.go b/internal/consensus/reactor_test.go
index e8c2df745..167a9c46f 100644
--- a/internal/consensus/reactor_test.go
+++ b/internal/consensus/reactor_test.go
@@ -391,7 +391,7 @@ func TestReactorWithEvidence(t *testing.T) {
 		stateStore := sm.NewStore(stateDB)
 		state, err := sm.MakeGenesisState(genDoc)
 		require.NoError(t, err)
-		thisConfig, err := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
+		thisConfig, err := ResetConfig(t.TempDir(), fmt.Sprintf("%s_%d", testName, i))
 		require.NoError(t, err)
 
 		defer os.RemoveAll(thisConfig.RootDir)
diff --git a/internal/consensus/replay_test.go b/internal/consensus/replay_test.go
index 48be064e8..607fdd5a0 100644
--- a/internal/consensus/replay_test.go
+++ b/internal/consensus/replay_test.go
@@ -142,7 +142,7 @@ func TestWALCrash(t *testing.T) {
 	for _, tc := range testCases {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
-			consensusReplayConfig, err := ResetConfig(tc.name)
+			consensusReplayConfig, err := ResetConfig(t.TempDir(), tc.name)
 			require.NoError(t, err)
 			crashWALandCheckLiveness(ctx, t, consensusReplayConfig, tc.initFn, tc.heightToStop)
 		})
@@ -709,7 +709,7 @@ func TestMockProxyApp(t *testing.T) {
 func tempWALWithData(t *testing.T, data []byte) string {
 	t.Helper()
 
-	walFile, err := os.CreateTemp("", "wal")
+	walFile, err := os.CreateTemp(t.TempDir(), "wal")
 	require.NoError(t, err, "failed to create temp WAL file")
 
 	_, err = walFile.Write(data)
@@ -743,7 +743,7 @@ func testHandshakeReplay(
 
 	logger := log.TestingLogger()
 	if testValidatorsChange {
-		testConfig, err := ResetConfig(fmt.Sprintf("%s_%v_m", t.Name(), mode))
+		testConfig, err := ResetConfig(t.TempDir(), fmt.Sprintf("%s_%v_m", t.Name(), mode))
 		require.NoError(t, err)
 		defer func() { _ = os.RemoveAll(testConfig.RootDir) }()
 		stateDB = dbm.NewMemDB()
@@ -754,7 +754,7 @@ func testHandshakeReplay(
 		commits = sim.Commits
 		store = newMockBlockStore(t, cfg, genesisState.ConsensusParams)
 	} else { // test single node
-		testConfig, err := ResetConfig(fmt.Sprintf("%s_%v_s", t.Name(), mode))
+		testConfig, err := ResetConfig(t.TempDir(), fmt.Sprintf("%s_%v_s", t.Name(), mode))
 		require.NoError(t, err)
 		defer func() { _ = os.RemoveAll(testConfig.RootDir) }()
 		walBody, err := WALWithNBlocks(ctx, t, logger, numBlocks)
@@ -1004,7 +1004,7 @@ func TestHandshakePanicsIfAppReturnsWrongAppHash(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cfg, err := ResetConfig("handshake_test_")
+	cfg, err := ResetConfig(t.TempDir(), "handshake_test_")
 	require.NoError(t, err)
 	t.Cleanup(func() { os.RemoveAll(cfg.RootDir) })
 	privVal, err := privval.LoadFilePV(cfg.PrivValidator.KeyFile(), cfg.PrivValidator.StateFile())
@@ -1288,7 +1288,7 @@ func TestHandshakeUpdatesValidators(t *testing.T) {
 	app := &initChainApp{vals: types.TM2PB.ValidatorUpdates(vals)}
 	clientCreator := abciclient.NewLocalCreator(app)
 
-	cfg, err := ResetConfig("handshake_test_")
+	cfg, err := ResetConfig(t.TempDir(), "handshake_test_")
 	require.NoError(t, err)
 	t.Cleanup(func() { _ = os.RemoveAll(cfg.RootDir) })
 
diff --git a/internal/consensus/types/height_vote_set_test.go b/internal/consensus/types/height_vote_set_test.go
index 3ebfcf2ee..c95beadb1 100644
--- a/internal/consensus/types/height_vote_set_test.go
+++ b/internal/consensus/types/height_vote_set_test.go
@@ -2,8 +2,6 @@ package types
 
 import (
 	"context"
-	"log"
-	"os"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -16,40 +14,33 @@ import (
 	"github.com/tendermint/tendermint/types"
 )
 
-var cfg *config.Config // NOTE: must be reset for each _test.go file
-
-func TestMain(m *testing.M) {
-	var err error
-	cfg, err = config.ResetTestRoot("consensus_height_vote_set_test")
+func TestPeerCatchupRounds(t *testing.T) {
+	cfg, err := config.ResetTestRoot(t.TempDir(), "consensus_height_vote_set_test")
 	if err != nil {
-		log.Fatal(err)
+		t.Fatal(err)
 	}
-	code := m.Run()
-	os.RemoveAll(cfg.RootDir)
-	os.Exit(code)
-}
 
-func TestPeerCatchupRounds(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
 	valSet, privVals := factory.ValidatorSet(ctx, t, 10, 1)
 
-	hvs := NewHeightVoteSet(cfg.ChainID(), 1, valSet)
+	chainID := cfg.ChainID()
+	hvs := NewHeightVoteSet(chainID, 1, valSet)
 
-	vote999_0 := makeVoteHR(ctx, t, 1, 0, 999, privVals)
+	vote999_0 := makeVoteHR(ctx, t, 1, 0, 999, privVals, chainID)
 	added, err := hvs.AddVote(vote999_0, "peer1")
 	if !added || err != nil {
 		t.Error("Expected to successfully add vote from peer", added, err)
 	}
 
-	vote1000_0 := makeVoteHR(ctx, t, 1, 0, 1000, privVals)
+	vote1000_0 := makeVoteHR(ctx, t, 1, 0, 1000, privVals, chainID)
 	added, err = hvs.AddVote(vote1000_0, "peer1")
 	if !added || err != nil {
 		t.Error("Expected to successfully add vote from peer", added, err)
 	}
 
-	vote1001_0 := makeVoteHR(ctx, t, 1, 0, 1001, privVals)
+	vote1001_0 := makeVoteHR(ctx, t, 1, 0, 1001, privVals, chainID)
 	added, err = hvs.AddVote(vote1001_0, "peer1")
 	if err != ErrGotVoteFromUnwantedRound {
 		t.Errorf("expected GotVoteFromUnwantedRoundError, but got %v", err)
@@ -71,6 +62,7 @@ func makeVoteHR(
 	height int64,
 	valIndex, round int32,
 	privVals []types.PrivValidator,
+	chainID string,
 ) *types.Vote {
 	t.Helper()
 
@@ -89,7 +81,6 @@ func makeVoteHR(
 		Type:             tmproto.PrecommitType,
 		BlockID:          types.BlockID{Hash: randBytes, PartSetHeader: types.PartSetHeader{}},
 	}
-	chainID := cfg.ChainID()
 
 	v := vote.ToProto()
 	err = privVal.SignVote(ctx, chainID, v)
diff --git a/internal/consensus/wal_generator.go b/internal/consensus/wal_generator.go
index 19d447222..76294288c 100644
--- a/internal/consensus/wal_generator.go
+++ b/internal/consensus/wal_generator.go
@@ -145,7 +145,7 @@ func makeAddrs() (p2pAddr, rpcAddr string) {
 
 // getConfig returns a config for test cases
 func getConfig(t *testing.T) *config.Config {
-	c, err := config.ResetTestRoot(t.Name())
+	c, err := config.ResetTestRoot(t.TempDir(), t.Name())
 	require.NoError(t, err)
 
 	p2pAddr, rpcAddr := makeAddrs()
diff --git a/internal/inspect/inspect_test.go b/internal/inspect/inspect_test.go
index c4ec3695e..f80a2e55a 100644
--- a/internal/inspect/inspect_test.go
+++ b/internal/inspect/inspect_test.go
@@ -28,7 +28,7 @@ import (
 )
 
 func TestInspectConstructor(t *testing.T) {
-	cfg, err := config.ResetTestRoot("test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "test")
 	require.NoError(t, err)
 	testLogger := log.TestingLogger()
 	t.Cleanup(leaktest.Check(t))
@@ -43,7 +43,7 @@ func TestInspectConstructor(t *testing.T) {
 }
 
 func TestInspectRun(t *testing.T) {
-	cfg, err := config.ResetTestRoot("test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "test")
 	require.NoError(t, err)
 
 	testLogger := log.TestingLogger()
diff --git a/internal/libs/autofile/autofile_test.go b/internal/libs/autofile/autofile_test.go
index dc5ba0682..9dbba276a 100644
--- a/internal/libs/autofile/autofile_test.go
+++ b/internal/libs/autofile/autofile_test.go
@@ -25,11 +25,7 @@ func TestSIGHUP(t *testing.T) {
 	})
 
 	// First, create a temporary directory and move into it
-	dir, err := os.MkdirTemp("", "sighup_test")
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		_ = os.RemoveAll(dir)
-	})
+	dir := t.TempDir()
 	require.NoError(t, os.Chdir(dir))
 
 	// Create an AutoFile in the temporary directory
@@ -48,9 +44,7 @@ func TestSIGHUP(t *testing.T) {
 	require.NoError(t, os.Rename(name, name+"_old"))
 
 	// Move into a different temporary directory
-	otherDir, err := os.MkdirTemp("", "sighup_test_other")
-	require.NoError(t, err)
-	t.Cleanup(func() { os.RemoveAll(otherDir) })
+	otherDir := t.TempDir()
 	require.NoError(t, os.Chdir(otherDir))
 
 	// Send SIGHUP to self.
@@ -112,7 +106,7 @@ func TestAutoFileSize(t *testing.T) {
 	defer cancel()
 
 	// First, create an AutoFile writing to a tempfile dir
-	f, err := os.CreateTemp("", "sighup_test")
+	f, err := os.CreateTemp(t.TempDir(), "sighup_test")
 	require.NoError(t, err)
 	require.NoError(t, f.Close())
 
diff --git a/internal/libs/autofile/group_test.go b/internal/libs/autofile/group_test.go
index f6b3eaab6..e20604d82 100644
--- a/internal/libs/autofile/group_test.go
+++ b/internal/libs/autofile/group_test.go
@@ -132,11 +132,8 @@ func TestRotateFile(t *testing.T) {
 		}
 	}()
 
-	dir, err := os.MkdirTemp("", "rotate_test")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
-	err = os.Chdir(dir)
-	require.NoError(t, err)
+	dir := t.TempDir()
+	require.NoError(t, os.Chdir(dir))
 
 	require.True(t, filepath.IsAbs(g.Head.Path))
 	require.True(t, filepath.IsAbs(g.Dir))
diff --git a/internal/libs/tempfile/tempfile_test.go b/internal/libs/tempfile/tempfile_test.go
index 5c38f9736..aee540c59 100644
--- a/internal/libs/tempfile/tempfile_test.go
+++ b/internal/libs/tempfile/tempfile_test.go
@@ -21,7 +21,7 @@ func TestWriteFileAtomic(t *testing.T) {
 		perm os.FileMode = 0600
 	)
 
-	f, err := os.CreateTemp("/tmp", "write-atomic-test-")
+	f, err := os.CreateTemp(t.TempDir(), "write-atomic-test-")
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/internal/mempool/mempool_test.go b/internal/mempool/mempool_test.go
index 1aba029a4..21e3743ed 100644
--- a/internal/mempool/mempool_test.go
+++ b/internal/mempool/mempool_test.go
@@ -82,7 +82,7 @@ func setup(ctx context.Context, t testing.TB, cacheSize int, options ...TxMempoo
 	cc := abciclient.NewLocalCreator(app)
 	logger := log.TestingLogger()
 
-	cfg, err := config.ResetTestRoot(strings.ReplaceAll(t.Name(), "/", "|"))
+	cfg, err := config.ResetTestRoot(t.TempDir(), strings.ReplaceAll(t.Name(), "/", "|"))
 	require.NoError(t, err)
 	cfg.Mempool.CacheSize = cacheSize
 	appConnMem, err := cc(logger)
diff --git a/internal/mempool/reactor_test.go b/internal/mempool/reactor_test.go
index b64b22120..46b4e8528 100644
--- a/internal/mempool/reactor_test.go
+++ b/internal/mempool/reactor_test.go
@@ -41,7 +41,7 @@ type reactorTestSuite struct {
 func setupReactors(ctx context.Context, t *testing.T, numNodes int, chBuf uint) *reactorTestSuite {
 	t.Helper()
 
-	cfg, err := config.ResetTestRoot(strings.ReplaceAll(t.Name(), "/", "|"))
+	cfg, err := config.ResetTestRoot(t.TempDir(), strings.ReplaceAll(t.Name(), "/", "|"))
 	require.NoError(t, err)
 	t.Cleanup(func() { os.RemoveAll(cfg.RootDir) })
 
diff --git a/internal/state/indexer/tx/kv/kv_bench_test.go b/internal/state/indexer/tx/kv/kv_bench_test.go
index 7744c3183..e36aed185 100644
--- a/internal/state/indexer/tx/kv/kv_bench_test.go
+++ b/internal/state/indexer/tx/kv/kv_bench_test.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"crypto/rand"
 	"fmt"
-	"os"
 	"testing"
 
 	dbm "github.com/tendermint/tm-db"
@@ -15,10 +14,7 @@ import (
 )
 
 func BenchmarkTxSearch(b *testing.B) {
-	dbDir, err := os.MkdirTemp("", "benchmark_tx_search_test")
-	if err != nil {
-		b.Errorf("failed to create temporary directory: %s", err)
-	}
+	dbDir := b.TempDir()
 
 	db, err := dbm.NewGoLevelDB("benchmark_tx_search_test", dbDir)
 	if err != nil {
diff --git a/internal/state/indexer/tx/kv/kv_test.go b/internal/state/indexer/tx/kv/kv_test.go
index 018fe51b4..2caf9efc1 100644
--- a/internal/state/indexer/tx/kv/kv_test.go
+++ b/internal/state/indexer/tx/kv/kv_test.go
@@ -3,7 +3,6 @@ package kv
 import (
 	"context"
 	"fmt"
-	"os"
 	"testing"
 
 	"github.com/gogo/protobuf/proto"
@@ -333,9 +332,7 @@ func txResultWithEvents(events []abci.Event) *abci.TxResult {
 }
 
 func benchmarkTxIndex(txsCount int64, b *testing.B) {
-	dir, err := os.MkdirTemp("", "tx_index_db")
-	require.NoError(b, err)
-	defer os.RemoveAll(dir)
+	dir := b.TempDir()
 
 	store, err := dbm.NewDB("tx_index", "goleveldb", dir)
 	require.NoError(b, err)
diff --git a/internal/state/state_test.go b/internal/state/state_test.go
index d5c6a649d..7a32c38c2 100644
--- a/internal/state/state_test.go
+++ b/internal/state/state_test.go
@@ -26,7 +26,7 @@ import (
 
 // setupTestCase does setup common to all test cases.
 func setupTestCase(t *testing.T) (func(t *testing.T), dbm.DB, sm.State) {
-	cfg, err := config.ResetTestRoot("state_")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "state_")
 	require.NoError(t, err)
 
 	dbType := dbm.BackendType(cfg.DBBackend)
diff --git a/internal/state/store_test.go b/internal/state/store_test.go
index d7e599610..e0e14bf59 100644
--- a/internal/state/store_test.go
+++ b/internal/state/store_test.go
@@ -110,7 +110,7 @@ func TestStoreLoadValidators(t *testing.T) {
 func BenchmarkLoadValidators(b *testing.B) {
 	const valSetSize = 100
 
-	cfg, err := config.ResetTestRoot("state_")
+	cfg, err := config.ResetTestRoot(b.TempDir(), "state_")
 	require.NoError(b, err)
 
 	defer os.RemoveAll(cfg.RootDir)
diff --git a/internal/statesync/chunks_test.go b/internal/statesync/chunks_test.go
index c3604df9d..8480b4dd8 100644
--- a/internal/statesync/chunks_test.go
+++ b/internal/statesync/chunks_test.go
@@ -18,7 +18,7 @@ func setupChunkQueue(t *testing.T) (*chunkQueue, func()) {
 		Hash:     []byte{7},
 		Metadata: nil,
 	}
-	queue, err := newChunkQueue(snapshot, "")
+	queue, err := newChunkQueue(snapshot, t.TempDir())
 	require.NoError(t, err)
 	teardown := func() {
 		err := queue.Close()
@@ -35,9 +35,7 @@ func TestNewChunkQueue_TempDir(t *testing.T) {
 		Hash:     []byte{7},
 		Metadata: nil,
 	}
-	dir, err := os.MkdirTemp("", "newchunkqueue")
-	require.NoError(t, err)
-	defer os.RemoveAll(dir)
+	dir := t.TempDir()
 	queue, err := newChunkQueue(snapshot, dir)
 	require.NoError(t, err)
 
diff --git a/internal/statesync/syncer_test.go b/internal/statesync/syncer_test.go
index 46287ada1..be0c5b63d 100644
--- a/internal/statesync/syncer_test.go
+++ b/internal/statesync/syncer_test.go
@@ -503,7 +503,7 @@ func TestSyncer_applyChunks_Results(t *testing.T) {
 			rts := setup(ctx, t, nil, nil, stateProvider, 2)
 
 			body := []byte{1, 2, 3}
-			chunks, err := newChunkQueue(&snapshot{Height: 1, Format: 1, Chunks: 1}, "")
+			chunks, err := newChunkQueue(&snapshot{Height: 1, Format: 1, Chunks: 1}, t.TempDir())
 			require.NoError(t, err)
 
 			fetchStartTime := time.Now()
@@ -562,7 +562,7 @@ func TestSyncer_applyChunks_RefetchChunks(t *testing.T) {
 
 			rts := setup(ctx, t, nil, nil, stateProvider, 2)
 
-			chunks, err := newChunkQueue(&snapshot{Height: 1, Format: 1, Chunks: 3}, "")
+			chunks, err := newChunkQueue(&snapshot{Height: 1, Format: 1, Chunks: 3}, t.TempDir())
 			require.NoError(t, err)
 
 			fetchStartTime := time.Now()
@@ -660,7 +660,7 @@ func TestSyncer_applyChunks_RejectSenders(t *testing.T) {
 			_, err = rts.syncer.AddSnapshot(peerCID, s2)
 			require.NoError(t, err)
 
-			chunks, err := newChunkQueue(s1, "")
+			chunks, err := newChunkQueue(s1, t.TempDir())
 			require.NoError(t, err)
 
 			fetchStartTime := time.Now()
diff --git a/internal/store/store_test.go b/internal/store/store_test.go
index 52bf518d4..8e1ee2db3 100644
--- a/internal/store/store_test.go
+++ b/internal/store/store_test.go
@@ -46,8 +46,8 @@ func makeTestCommit(height int64, timestamp time.Time) *types.Commit {
 		commitSigs)
 }
 
-func makeStateAndBlockStore(logger log.Logger) (sm.State, *BlockStore, cleanupFunc, error) {
-	cfg, err := config.ResetTestRoot("blockchain_reactor_test")
+func makeStateAndBlockStore(dir string, logger log.Logger) (sm.State, *BlockStore, cleanupFunc, error) {
+	cfg, err := config.ResetTestRoot(dir, "blockchain_reactor_test")
 	if err != nil {
 		return sm.State{}, nil, nil, err
 	}
@@ -75,10 +75,13 @@ var (
 )
 
 func TestMain(m *testing.M) {
+	dir, err := os.MkdirTemp("", "store_test")
+	if err != nil {
+		stdlog.Fatal(err)
+	}
 	var cleanup cleanupFunc
-	var err error
 
-	state, _, cleanup, err = makeStateAndBlockStore(log.NewNopLogger())
+	state, _, cleanup, err = makeStateAndBlockStore(dir, log.NewNopLogger())
 	if err != nil {
 		stdlog.Fatal(err)
 	}
@@ -97,12 +100,13 @@ func TestMain(m *testing.M) {
 	seenCommit1 = makeTestCommit(10, tmtime.Now())
 	code := m.Run()
 	cleanup()
+	os.RemoveAll(dir) // best-effort
 	os.Exit(code)
 }
 
 // TODO: This test should be simplified ...
 func TestBlockStoreSaveLoadBlock(t *testing.T) {
-	state, bs, cleanup, err := makeStateAndBlockStore(log.NewNopLogger())
+	state, bs, cleanup, err := makeStateAndBlockStore(t.TempDir(), log.NewNopLogger())
 	defer cleanup()
 	require.NoError(t, err)
 	require.Equal(t, bs.Base(), int64(0), "initially the base should be zero")
@@ -313,7 +317,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 }
 
 func TestLoadBaseMeta(t *testing.T) {
-	cfg, err := config.ResetTestRoot("blockchain_reactor_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "blockchain_reactor_test")
 	require.NoError(t, err)
 
 	defer os.RemoveAll(cfg.RootDir)
@@ -373,7 +377,7 @@ func TestLoadBlockPart(t *testing.T) {
 }
 
 func TestPruneBlocks(t *testing.T) {
-	cfg, err := config.ResetTestRoot("blockchain_reactor_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "blockchain_reactor_test")
 	require.NoError(t, err)
 
 	defer os.RemoveAll(cfg.RootDir)
@@ -494,7 +498,7 @@ func TestLoadBlockMeta(t *testing.T) {
 }
 
 func TestBlockFetchAtHeight(t *testing.T) {
-	state, bs, cleanup, err := makeStateAndBlockStore(log.NewNopLogger())
+	state, bs, cleanup, err := makeStateAndBlockStore(t.TempDir(), log.NewNopLogger())
 	defer cleanup()
 	require.NoError(t, err)
 	require.Equal(t, bs.Height(), int64(0), "initially the height should be zero")
diff --git a/libs/cli/setup_test.go b/libs/cli/setup_test.go
index 4c23c722a..9198485ef 100644
--- a/libs/cli/setup_test.go
+++ b/libs/cli/setup_test.go
@@ -60,13 +60,6 @@ func TestSetupEnv(t *testing.T) {
 	}
 }
 
-func tempDir(t *testing.T) string {
-	t.Helper()
-	cdir, err := os.MkdirTemp("", "test-cli")
-	require.NoError(t, err)
-	return cdir
-}
-
 // writeConfigVals writes a toml file with the given values.
 // It returns an error if writing was impossible.
 func writeConfigVals(dir string, vals map[string]string) error {
@@ -86,7 +79,7 @@ func TestSetupConfig(t *testing.T) {
 	// we pre-create two config files we can refer to in the rest of
 	// the test cases.
 	cval1 := "fubble"
-	conf1 := tempDir(t)
+	conf1 := t.TempDir()
 	err := writeConfigVals(conf1, map[string]string{"boo": cval1})
 	require.NoError(t, err)
 
@@ -147,11 +140,11 @@ func TestSetupUnmarshal(t *testing.T) {
 	// we pre-create two config files we can refer to in the rest of
 	// the test cases.
 	cval1, cval2 := "someone", "else"
-	conf1 := tempDir(t)
+	conf1 := t.TempDir()
 	err := writeConfigVals(conf1, map[string]string{"name": cval1})
 	require.NoError(t, err)
 	// even with some ignored fields, should be no problem
-	conf2 := tempDir(t)
+	conf2 := t.TempDir()
 	err = writeConfigVals(conf2, map[string]string{"name": cval2, "foo": "bar"})
 	require.NoError(t, err)
 
diff --git a/libs/os/os_test.go b/libs/os/os_test.go
index fe503f921..0f01be315 100644
--- a/libs/os/os_test.go
+++ b/libs/os/os_test.go
@@ -12,7 +12,7 @@ import (
 )
 
 func TestCopyFile(t *testing.T) {
-	tmpfile, err := os.CreateTemp("", "example")
+	tmpfile, err := os.CreateTemp(t.TempDir(), "example")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -40,12 +40,10 @@ func TestCopyFile(t *testing.T) {
 }
 
 func TestEnsureDir(t *testing.T) {
-	tmp, err := os.MkdirTemp("", "ensure-dir")
-	require.NoError(t, err)
-	defer os.RemoveAll(tmp)
+	tmp := t.TempDir()
 
 	// Should be possible to create a new directory.
-	err = tmos.EnsureDir(filepath.Join(tmp, "dir"), 0755)
+	err := tmos.EnsureDir(filepath.Join(tmp, "dir"), 0755)
 	require.NoError(t, err)
 	require.DirExists(t, filepath.Join(tmp, "dir"))
 
@@ -76,11 +74,7 @@ func TestEnsureDir(t *testing.T) {
 // the origin is positively a non-directory and that it is ready for copying.
 // See https://github.com/tendermint/tendermint/issues/6427
 func TestTrickedTruncation(t *testing.T) {
-	tmpDir, err := os.MkdirTemp(os.TempDir(), "pwn_truncate")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Remove(tmpDir)
+	tmpDir := t.TempDir()
 
 	originalWALPath := filepath.Join(tmpDir, "wal")
 	originalWALContent := []byte("I AM BECOME DEATH, DESTROYER OF ALL WORLDS!")
diff --git a/light/example_test.go b/light/example_test.go
index 7362ca06b..c735c21a2 100644
--- a/light/example_test.go
+++ b/light/example_test.go
@@ -2,8 +2,7 @@ package light_test
 
 import (
 	"context"
-	stdlog "log"
-	"os"
+	"testing"
 	"time"
 
 	dbm "github.com/tendermint/tm-db"
@@ -17,17 +16,17 @@ import (
 )
 
 // Manually getting light blocks and verifying them.
-func ExampleClient() {
+func TestExampleClient(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	conf, err := rpctest.CreateConfig("ExampleClient_VerifyLightBlockAtHeight")
+	conf, err := rpctest.CreateConfig(t, "ExampleClient_VerifyLightBlockAtHeight")
 	if err != nil {
-		stdlog.Fatal(err)
+		t.Fatal(err)
 	}
 
 	logger, err := log.NewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo)
 	if err != nil {
-		stdlog.Fatal(err)
+		t.Fatal(err)
 	}
 
 	// Start a test application
@@ -35,21 +34,16 @@ func ExampleClient() {
 
 	_, closer, err := rpctest.StartTendermint(ctx, conf, app, rpctest.SuppressStdout)
 	if err != nil {
-		stdlog.Fatal(err)
+		t.Fatal(err)
 	}
 	defer func() { _ = closer(ctx) }()
 
-	dbDir, err := os.MkdirTemp("", "light-client-example")
-	if err != nil {
-		stdlog.Fatal(err)
-	}
-	defer os.RemoveAll(dbDir)
-
+	dbDir := t.TempDir()
 	chainID := conf.ChainID()
 
 	primary, err := httpp.New(chainID, conf.RPC.ListenAddress)
 	if err != nil {
-		stdlog.Fatal(err)
+		t.Fatal(err)
 	}
 
 	// give Tendermint time to generate some blocks
@@ -57,12 +51,12 @@ func ExampleClient() {
 
 	block, err := primary.LightBlock(ctx, 2)
 	if err != nil {
-		stdlog.Fatal(err)
+		t.Fatal(err)
 	}
 
 	db, err := dbm.NewGoLevelDB("light-client-db", dbDir)
 	if err != nil {
-		stdlog.Fatal(err)
+		t.Fatal(err)
 	}
 
 	c, err := light.NewClient(ctx,
@@ -78,11 +72,11 @@ func ExampleClient() {
 		light.Logger(logger),
 	)
 	if err != nil {
-		stdlog.Fatal(err)
+		t.Fatal(err)
 	}
 	defer func() {
 		if err := c.Cleanup(); err != nil {
-			stdlog.Fatal(err)
+			t.Fatal(err)
 		}
 	}()
 
@@ -92,19 +86,19 @@ func ExampleClient() {
 	// veify the block at height 3
 	_, err = c.VerifyLightBlockAtHeight(ctx, 3, time.Now())
 	if err != nil {
-		stdlog.Fatal(err)
+		t.Fatal(err)
 	}
 
 	// retrieve light block at height 3
 	_, err = c.TrustedLightBlock(3)
 	if err != nil {
-		stdlog.Fatal(err)
+		t.Fatal(err)
 	}
 
 	// update to the latest height
 	lb, err := c.Update(ctx, time.Now())
 	if err != nil {
-		stdlog.Fatal(err)
+		t.Fatal(err)
 	}
 
 	logger.Info("verified light block", "light-block", lb)
diff --git a/light/light_test.go b/light/light_test.go
index 7e8977de9..35e6d1933 100644
--- a/light/light_test.go
+++ b/light/light_test.go
@@ -2,7 +2,6 @@ package light_test
 
 import (
 	"context"
-	"os"
 	"testing"
 	"time"
 
@@ -28,7 +27,7 @@ func TestClientIntegration_Update(t *testing.T) {
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	conf, err := rpctest.CreateConfig(t.Name())
+	conf, err := rpctest.CreateConfig(t, t.Name())
 	require.NoError(t, err)
 
 	logger := log.NewTestingLogger(t)
@@ -42,10 +41,7 @@ func TestClientIntegration_Update(t *testing.T) {
 	// give Tendermint time to generate some blocks
 	time.Sleep(5 * time.Second)
 
-	dbDir, err := os.MkdirTemp("", "light-client-test-update-example")
-	require.NoError(t, err)
-	defer os.RemoveAll(dbDir)
-
+	dbDir := t.TempDir()
 	chainID := conf.ChainID()
 
 	primary, err := httpp.New(chainID, conf.RPC.ListenAddress)
@@ -91,7 +87,7 @@ func TestClientIntegration_VerifyLightBlockAtHeight(t *testing.T) {
 	t.Parallel()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	conf, err := rpctest.CreateConfig(t.Name())
+	conf, err := rpctest.CreateConfig(t, t.Name())
 	require.NoError(t, err)
 
 	logger := log.NewTestingLogger(t)
@@ -103,10 +99,7 @@ func TestClientIntegration_VerifyLightBlockAtHeight(t *testing.T) {
 	require.NoError(t, err)
 	defer func() { require.NoError(t, closer(ctx)) }()
 
-	dbDir, err := os.MkdirTemp("", "light-client-test-verify-example")
-	require.NoError(t, err)
-	defer os.RemoveAll(dbDir)
-
+	dbDir := t.TempDir()
 	chainID := conf.ChainID()
 
 	primary, err := httpp.New(chainID, conf.RPC.ListenAddress)
@@ -171,7 +164,7 @@ func waitForBlock(ctx context.Context, p provider.Provider, height int64) (*type
 func TestClientStatusRPC(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	conf, err := rpctest.CreateConfig(t.Name())
+	conf, err := rpctest.CreateConfig(t, t.Name())
 	require.NoError(t, err)
 
 	// Start a test application
@@ -181,10 +174,7 @@ func TestClientStatusRPC(t *testing.T) {
 	require.NoError(t, err)
 	defer func() { require.NoError(t, closer(ctx)) }()
 
-	dbDir, err := os.MkdirTemp("", "light-client-test-status-example")
-	require.NoError(t, err)
-	t.Cleanup(func() { os.RemoveAll(dbDir) })
-
+	dbDir := t.TempDir()
 	chainID := conf.ChainID()
 
 	primary, err := httpp.New(chainID, conf.RPC.ListenAddress)
diff --git a/light/provider/http/http_test.go b/light/provider/http/http_test.go
index 4c7761d50..cb443caaf 100644
--- a/light/provider/http/http_test.go
+++ b/light/provider/http/http_test.go
@@ -35,7 +35,7 @@ func TestNewProvider(t *testing.T) {
 func TestProvider(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	cfg, err := rpctest.CreateConfig(t.Name())
+	cfg, err := rpctest.CreateConfig(t, t.Name())
 	require.NoError(t, err)
 
 	// start a tendermint node in the background to test against
diff --git a/node/node_test.go b/node/node_test.go
index 116319294..6d37d3fee 100644
--- a/node/node_test.go
+++ b/node/node_test.go
@@ -39,7 +39,7 @@ import (
 )
 
 func TestNodeStartStop(t *testing.T) {
-	cfg, err := config.ResetTestRoot("node_node_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "node_node_test")
 	require.NoError(t, err)
 
 	defer os.RemoveAll(cfg.RootDir)
@@ -104,7 +104,7 @@ func getTestNode(ctx context.Context, t *testing.T, conf *config.Config, logger
 }
 
 func TestNodeDelayedStart(t *testing.T) {
-	cfg, err := config.ResetTestRoot("node_delayed_start_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "node_delayed_start_test")
 	require.NoError(t, err)
 
 	defer os.RemoveAll(cfg.RootDir)
@@ -126,7 +126,7 @@ func TestNodeDelayedStart(t *testing.T) {
 }
 
 func TestNodeSetAppVersion(t *testing.T) {
-	cfg, err := config.ResetTestRoot("node_app_version_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "node_app_version_test")
 	require.NoError(t, err)
 	defer os.RemoveAll(cfg.RootDir)
 
@@ -159,7 +159,7 @@ func TestNodeSetPrivValTCP(t *testing.T) {
 
 	logger := log.NewNopLogger()
 
-	cfg, err := config.ResetTestRoot("node_priv_val_tcp_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "node_priv_val_tcp_test")
 	require.NoError(t, err)
 	defer os.RemoveAll(cfg.RootDir)
 	cfg.PrivValidator.ListenAddr = addr
@@ -196,7 +196,7 @@ func TestPrivValidatorListenAddrNoProtocol(t *testing.T) {
 
 	addrNoPrefix := testFreeAddr(t)
 
-	cfg, err := config.ResetTestRoot("node_priv_val_tcp_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "node_priv_val_tcp_test")
 	require.NoError(t, err)
 	defer os.RemoveAll(cfg.RootDir)
 	cfg.PrivValidator.ListenAddr = addrNoPrefix
@@ -220,7 +220,7 @@ func TestNodeSetPrivValIPC(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cfg, err := config.ResetTestRoot("node_priv_val_tcp_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "node_priv_val_tcp_test")
 	require.NoError(t, err)
 	defer os.RemoveAll(cfg.RootDir)
 	cfg.PrivValidator.ListenAddr = "unix://" + tmpfile
@@ -267,7 +267,7 @@ func TestCreateProposalBlock(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cfg, err := config.ResetTestRoot("node_create_proposal")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "node_create_proposal")
 	require.NoError(t, err)
 	defer os.RemoveAll(cfg.RootDir)
 
@@ -364,7 +364,7 @@ func TestMaxTxsProposalBlockSize(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cfg, err := config.ResetTestRoot("node_create_proposal")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "node_create_proposal")
 	require.NoError(t, err)
 
 	defer os.RemoveAll(cfg.RootDir)
@@ -432,7 +432,7 @@ func TestMaxProposalBlockSize(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	cfg, err := config.ResetTestRoot("node_create_proposal")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "node_create_proposal")
 	require.NoError(t, err)
 	defer os.RemoveAll(cfg.RootDir)
 
@@ -547,7 +547,7 @@ func TestMaxProposalBlockSize(t *testing.T) {
 }
 
 func TestNodeNewSeedNode(t *testing.T) {
-	cfg, err := config.ResetTestRoot("node_new_node_custom_reactors_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "node_new_node_custom_reactors_test")
 	require.NoError(t, err)
 	cfg.Mode = config.ModeSeed
 	defer os.RemoveAll(cfg.RootDir)
@@ -585,7 +585,7 @@ func TestNodeNewSeedNode(t *testing.T) {
 }
 
 func TestNodeSetEventSink(t *testing.T) {
-	cfg, err := config.ResetTestRoot("node_app_version_test")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "node_app_version_test")
 	require.NoError(t, err)
 
 	defer os.RemoveAll(cfg.RootDir)
@@ -725,7 +725,7 @@ func loadStatefromGenesis(ctx context.Context, t *testing.T) sm.State {
 
 	stateDB := dbm.NewMemDB()
 	stateStore := sm.NewStore(stateDB)
-	cfg, err := config.ResetTestRoot("load_state_from_genesis")
+	cfg, err := config.ResetTestRoot(t.TempDir(), "load_state_from_genesis")
 	require.NoError(t, err)
 
 	loadedState, err := stateStore.Load()
diff --git a/privval/file_test.go b/privval/file_test.go
index 9e0c3d691..91c2e2a9b 100644
--- a/privval/file_test.go
+++ b/privval/file_test.go
@@ -21,9 +21,9 @@ import (
 )
 
 func TestGenLoadValidator(t *testing.T) {
-	tempKeyFile, err := os.CreateTemp("", "priv_validator_key_")
+	tempKeyFile, err := os.CreateTemp(t.TempDir(), "priv_validator_key_")
 	require.NoError(t, err)
-	tempStateFile, err := os.CreateTemp("", "priv_validator_state_")
+	tempStateFile, err := os.CreateTemp(t.TempDir(), "priv_validator_state_")
 	require.NoError(t, err)
 
 	privVal, err := GenFilePV(tempKeyFile.Name(), tempStateFile.Name(), "")
@@ -44,9 +44,9 @@ func TestResetValidator(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	tempKeyFile, err := os.CreateTemp("", "priv_validator_key_")
+	tempKeyFile, err := os.CreateTemp(t.TempDir(), "priv_validator_key_")
 	require.NoError(t, err)
-	tempStateFile, err := os.CreateTemp("", "priv_validator_state_")
+	tempStateFile, err := os.CreateTemp(t.TempDir(), "priv_validator_state_")
 	require.NoError(t, err)
 
 	privVal, err := GenFilePV(tempKeyFile.Name(), tempStateFile.Name(), "")
@@ -74,9 +74,9 @@ func TestResetValidator(t *testing.T) {
 }
 
 func TestLoadOrGenValidator(t *testing.T) {
-	tempKeyFile, err := os.CreateTemp("", "priv_validator_key_")
+	tempKeyFile, err := os.CreateTemp(t.TempDir(), "priv_validator_key_")
 	require.NoError(t, err)
-	tempStateFile, err := os.CreateTemp("", "priv_validator_state_")
+	tempStateFile, err := os.CreateTemp(t.TempDir(), "priv_validator_state_")
 	require.NoError(t, err)
 
 	tempKeyFilePath := tempKeyFile.Name()
@@ -160,9 +160,9 @@ func TestSignVote(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	tempKeyFile, err := os.CreateTemp("", "priv_validator_key_")
+	tempKeyFile, err := os.CreateTemp(t.TempDir(), "priv_validator_key_")
 	require.NoError(t, err)
-	tempStateFile, err := os.CreateTemp("", "priv_validator_state_")
+	tempStateFile, err := os.CreateTemp(t.TempDir(), "priv_validator_state_")
 	require.NoError(t, err)
 
 	privVal, err := GenFilePV(tempKeyFile.Name(), tempStateFile.Name(), "")
@@ -215,9 +215,9 @@ func TestSignProposal(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	tempKeyFile, err := os.CreateTemp("", "priv_validator_key_")
+	tempKeyFile, err := os.CreateTemp(t.TempDir(), "priv_validator_key_")
 	require.NoError(t, err)
-	tempStateFile, err := os.CreateTemp("", "priv_validator_state_")
+	tempStateFile, err := os.CreateTemp(t.TempDir(), "priv_validator_state_")
 	require.NoError(t, err)
 
 	privVal, err := GenFilePV(tempKeyFile.Name(), tempStateFile.Name(), "")
@@ -263,9 +263,9 @@ func TestDifferByTimestamp(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	tempKeyFile, err := os.CreateTemp("", "priv_validator_key_")
+	tempKeyFile, err := os.CreateTemp(t.TempDir(), "priv_validator_key_")
 	require.NoError(t, err)
-	tempStateFile, err := os.CreateTemp("", "priv_validator_state_")
+	tempStateFile, err := os.CreateTemp(t.TempDir(), "priv_validator_state_")
 	require.NoError(t, err)
 
 	privVal, err := GenFilePV(tempKeyFile.Name(), tempStateFile.Name(), "")
diff --git a/privval/socket_dialers_test.go b/privval/socket_dialers_test.go
index 1ff738cbb..7ec8fe30f 100644
--- a/privval/socket_dialers_test.go
+++ b/privval/socket_dialers_test.go
@@ -23,7 +23,7 @@ func getFreeLocalhostAddrPort(t *testing.T) string {
 
 func getDialerTestCases(t *testing.T) []dialerTestCase {
 	tcpAddr := getFreeLocalhostAddrPort(t)
-	unixFilePath, err := testUnixAddr()
+	unixFilePath, err := testUnixAddr(t)
 	require.NoError(t, err)
 	unixAddr := fmt.Sprintf("unix://%s", unixFilePath)
 
diff --git a/privval/socket_listeners_test.go b/privval/socket_listeners_test.go
index c411332b2..31d089639 100644
--- a/privval/socket_listeners_test.go
+++ b/privval/socket_listeners_test.go
@@ -28,14 +28,17 @@ type listenerTestCase struct {
 
 // testUnixAddr will attempt to obtain a platform-independent temporary file
 // name for a Unix socket
-func testUnixAddr() (string, error) {
-	f, err := os.CreateTemp("", "tendermint-privval-test-*")
+func testUnixAddr(t *testing.T) (string, error) {
+	// N.B. We can't use t.TempDir here because socket filenames have a
+	// restrictive length limit (~100 bytes) for silly historical reasons.
+	f, err := os.CreateTemp("", "tendermint-privval-test-*.sock")
 	if err != nil {
 		return "", err
 	}
 	addr := f.Name()
 	f.Close()
-	os.Remove(addr)
+	os.Remove(addr)                       // remove so the test can bind it
+	t.Cleanup(func() { os.Remove(addr) }) // clean up after the test
 	return addr, nil
 }
 
@@ -56,7 +59,7 @@ func tcpListenerTestCase(t *testing.T, timeoutAccept, timeoutReadWrite time.Dura
 }
 
 func unixListenerTestCase(t *testing.T, timeoutAccept, timeoutReadWrite time.Duration) listenerTestCase {
-	addr, err := testUnixAddr()
+	addr, err := testUnixAddr(t)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/rpc/client/examples_test.go b/rpc/client/examples_test.go
index e26d499f1..122090387 100644
--- a/rpc/client/examples_test.go
+++ b/rpc/client/examples_test.go
@@ -22,7 +22,7 @@ func TestHTTPSimple(t *testing.T) {
 
 	// Start a tendermint node (and kvstore) in the background to test against
 	app := kvstore.NewApplication()
-	conf, err := rpctest.CreateConfig("ExampleHTTP_simple")
+	conf, err := rpctest.CreateConfig(t, "ExampleHTTP_simple")
 	require.NoError(t, err)
 
 	_, closer, err := rpctest.StartTendermint(ctx, conf, app, rpctest.SuppressStdout)
@@ -72,7 +72,7 @@ func TestHTTPBatching(t *testing.T) {
 
 	// Start a tendermint node (and kvstore) in the background to test against
 	app := kvstore.NewApplication()
-	conf, err := rpctest.CreateConfig("ExampleHTTP_batching")
+	conf, err := rpctest.CreateConfig(t, "ExampleHTTP_batching")
 	require.NoError(t, err)
 
 	_, closer, err := rpctest.StartTendermint(ctx, conf, app, rpctest.SuppressStdout)
diff --git a/rpc/client/main_test.go b/rpc/client/main_test.go
index ad3043098..066b8490b 100644
--- a/rpc/client/main_test.go
+++ b/rpc/client/main_test.go
@@ -2,7 +2,6 @@ package client_test
 
 import (
 	"context"
-	"fmt"
 	"os"
 	"testing"
 
@@ -20,13 +19,11 @@ func NodeSuite(t *testing.T, logger log.Logger) (service.Service, *config.Config
 
 	ctx, cancel := context.WithCancel(context.Background())
 
-	conf, err := rpctest.CreateConfig(t.Name())
+	conf, err := rpctest.CreateConfig(t, t.Name())
 	require.NoError(t, err)
 
 	// start a tendermint node in the background to test against
-	dir, err := os.MkdirTemp("/tmp", fmt.Sprint("rpc-client-test-", t.Name()))
-	require.NoError(t, err)
-
+	dir := t.TempDir()
 	app := kvstore.NewPersistentKVStoreApplication(logger, dir)
 
 	node, closer, err := rpctest.StartTendermint(ctx, conf, app, rpctest.SuppressStdout)
diff --git a/rpc/test/helpers.go b/rpc/test/helpers.go
index 42f78c01f..f6c5217bf 100644
--- a/rpc/test/helpers.go
+++ b/rpc/test/helpers.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"testing"
 	"time"
 
 	abciclient "github.com/tendermint/tendermint/abci/client"
@@ -57,8 +58,8 @@ func makeAddrs() (p2pAddr, rpcAddr string) {
 	return fmt.Sprintf(addrTemplate, randPort()), fmt.Sprintf(addrTemplate, randPort())
 }
 
-func CreateConfig(testName string) (*config.Config, error) {
-	c, err := config.ResetTestRoot(testName)
+func CreateConfig(t *testing.T, testName string) (*config.Config, error) {
+	c, err := config.ResetTestRoot(t.TempDir(), testName)
 	if err != nil {
 		return nil, err
 	}
diff --git a/types/genesis_test.go b/types/genesis_test.go
index 1045b7065..99227ad3b 100644
--- a/types/genesis_test.go
+++ b/types/genesis_test.go
@@ -126,7 +126,7 @@ func TestBasicGenesisDoc(t *testing.T) {
 }
 
 func TestGenesisSaveAs(t *testing.T) {
-	tmpfile, err := os.CreateTemp("", "genesis")
+	tmpfile, err := os.CreateTemp(t.TempDir(), "genesis")
 	require.NoError(t, err)
 	defer os.Remove(tmpfile.Name())