tests: use testLogger

checkpoint_test.go

@@ -37,6 +37,7 @@ func TestCheckpoint(t *testing.T) {
 		FormatMajorVersion:          internalFormatNewest,
 		L0CompactionThreshold:       10,
 		DisableAutomaticCompactions: true,
+		Logger:                      testLogger{t},
 	}
 	opts.DisableTableStats = true
 	opts.private.testingAlwaysWaitForCleanup = true
@@ -217,7 +218,7 @@ func TestCheckpoint(t *testing.T) {
 
 func TestCheckpointCompaction(t *testing.T) {
 	fs := vfs.NewMem()
-	d, err := Open("", &Options{FS: fs})
+	d, err := Open("", &Options{FS: fs, Logger: testLogger{t: t}})
 	require.NoError(t, err)
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -263,7 +264,7 @@ func TestCheckpointCompaction(t *testing.T) {
 		}
 	}()
 	go func() {
-		opts := &Options{FS: fs}
+		opts := &Options{FS: fs, Logger: testLogger{t: t}}
 		defer cancel()
 		defer wg.Done()
 		for dir := range check {
@@ -300,7 +301,7 @@ func TestCheckpointCompaction(t *testing.T) {
 func TestCheckpointFlushWAL(t *testing.T) {
 	const checkpointPath = "checkpoints/checkpoint"
 	fs := vfs.NewStrictMem()
-	opts := &Options{FS: fs}
+	opts := &Options{FS: fs, Logger: testLogger{t: t}}
 	key, value := []byte("key"), []byte("value")
 
 	// Create a checkpoint from an unsynced DB.
@@ -359,6 +360,7 @@ func TestCheckpointManyFiles(t *testing.T) {
 		FS:                          vfs.NewMem(),
 		FormatMajorVersion:          internalFormatNewest,
 		DisableAutomaticCompactions: true,
+		Logger:                      testLogger{t},
 	}
 	// Disable compression to speed up the test.
 	opts.EnsureDefaults()

cleaner_test.go

@@ -95,6 +95,7 @@ func TestCleaner(t *testing.T) {
 			opts := (&Options{
 				FS:     fs,
 				WALDir: dir + "_wal",
+				Logger: testLogger{t},
 			}).WithFSDefaults()
 
 			for i := 1; i < len(td.CmdArgs); i++ {

compaction_test.go

@@ -3553,6 +3553,7 @@ func TestSharedObjectDeletePacing(t *testing.T) {
 	})
 	opts.Experimental.CreateOnShared = remote.CreateOnSharedAll
 	opts.TargetByteDeletionRate = 1
+	opts.Logger = testLogger{t}
 
 	d, err := Open("", &opts)
 	require.NoError(t, err)

db_test.go

@@ -2006,7 +2006,8 @@ func TestRecycleLogs(t *testing.T) {
 	require.NoError(t, d.Close())
 
 	d, err = Open("", &Options{
-		FS: mem,
+		FS:     mem,
+		Logger: testLogger{t},
 	})
 	require.NoError(t, err)
 	recycler = d.mu.log.manager.RecyclerForTesting()

filenames_test.go

@@ -59,6 +59,7 @@ func TestSetCurrentFileCrash(t *testing.T) {
 			FS:                    mem,
 			MaxManifestFileSize:   1,
 			L0CompactionThreshold: 10,
+			Logger:                testLogger{t},
 		})
 		require.NoError(t, err)
 		require.NoError(t, d.Close())

format_major_version_test.go

@@ -58,7 +58,7 @@ func TestRatchetFormat(t *testing.T) {
 
 	// If we Open the database again, leaving the default format, the
 	// database should Open using the persisted FormatNewest.
-	d, err = Open("", (&Options{FS: fs}).WithFSDefaults())
+	d, err = Open("", (&Options{FS: fs, Logger: testLogger{t}}).WithFSDefaults())
 	require.NoError(t, err)
 	require.Equal(t, internalFormatNewest, d.FormatMajorVersion())
 	require.NoError(t, d.Close())
@@ -106,6 +106,7 @@ func TestFormatMajorVersions(t *testing.T) {
 			opts := (&Options{
 				FS:                 fs,
 				FormatMajorVersion: vers,
+				Logger:             testLogger{t},
 			}).WithFSDefaults()
 
 			// Create a database at this format major version and perform

ingest_test.go

@@ -454,6 +454,7 @@ func TestOverlappingIngestedSSTs(t *testing.T) {
 			L0StopWritesThreshold:       100,
 			DebugCheck:                  DebugCheckLevels,
 			FormatMajorVersion:          internalFormatNewest,
+			Logger:                      testLogger{t},
 		}).WithFSDefaults()
 		// Disable automatic compactions because otherwise we'll race with
 		// delete-only compactions triggered by ingesting range tombstones.
@@ -619,6 +620,7 @@ func TestExcise(t *testing.T) {
 				flushed = true
 			}},
 			FormatMajorVersion: FormatVirtualSSTables,
+			Logger:             testLogger{t},
 		}
 		if blockSize != 0 {
 			opts.Levels = append(opts.Levels, LevelOptions{BlockSize: blockSize, IndexBlockSize: 32 << 10})
@@ -881,7 +883,7 @@ func testIngestSharedImpl(
 	replicateCounter := 1
 	var opts1, opts2 *Options
 
-	reset := func() {
+	reset := func(t *testing.T) {
 		for _, e := range efos {
 			require.NoError(t, e.Close())
 		}
@@ -906,9 +908,10 @@ func testIngestSharedImpl(
 			L0StopWritesThreshold: 100,
 			DebugCheck:            DebugCheckLevels,
 			FormatMajorVersion:    FormatVirtualSSTables,
+			Logger:                testLogger{t},
 		}
 		// lel.
-		lel := MakeLoggingEventListener(DefaultLogger)
+		lel := MakeLoggingEventListener(testLogger{t})
 		opts1.EventListener = &lel
 		opts1.Experimental.RemoteStorage = remote.MakeSimpleFactory(map[remote.Locator]remote.Storage{
 			"": sstorage,
@@ -939,7 +942,7 @@ func testIngestSharedImpl(
 		creatorIDCounter++
 		d = d1
 	}
-	reset()
+	reset(t)
 
 	datadriven.RunTest(t, fmt.Sprintf("testdata/%s", fileName), func(t *testing.T, td *datadriven.TestData) string {
 		switch td.Cmd {
@@ -966,7 +969,7 @@ func testIngestSharedImpl(
 			d = d1
 			return "ok, note that the active db has been set to 1 (use 'switch' to change)"
 		case "reset":
-			reset()
+			reset(t)
 			return ""
 		case "switch":
 			if len(td.CmdArgs) != 1 {
@@ -1228,7 +1231,7 @@ func TestSimpleIngestShared(t *testing.T) {
 	mem := vfs.NewMem()
 	var d *DB
 	var provider2 objstorage.Provider
-	opts2 := Options{FS: vfs.NewMem(), FormatMajorVersion: FormatVirtualSSTables}
+	opts2 := Options{FS: vfs.NewMem(), FormatMajorVersion: FormatVirtualSSTables, Logger: testLogger{t}}
 	opts2.EnsureDefaults()
 
 	// Create an objProvider where we will fake-create some sstables that can
@@ -1270,6 +1273,7 @@ func TestSimpleIngestShared(t *testing.T) {
 			FS:                    mem,
 			L0CompactionThreshold: 100,
 			L0StopWritesThreshold: 100,
+			Logger:                testLogger{t},
 		}
 		opts.Experimental.RemoteStorage = providerSettings.Remote.StorageFactory
 		opts.Experimental.CreateOnShared = providerSettings.Remote.CreateOnShared
@@ -1416,9 +1420,10 @@ func TestConcurrentExcise(t *testing.T) {
 			L0StopWritesThreshold: 100,
 			DebugCheck:            DebugCheckLevels,
 			FormatMajorVersion:    FormatVirtualSSTables,
+			Logger:                testLogger{t},
 		}
 		// lel.
-		lel := MakeLoggingEventListener(DefaultLogger)
+		lel := MakeLoggingEventListener(testLogger{t})
 		tel := TeeEventListener(lel, el)
 		opts1.EventListener = &tel
 		opts1.Experimental.RemoteStorage = remote.MakeSimpleFactory(map[remote.Locator]remote.Storage{
@@ -1790,6 +1795,7 @@ func TestIngestExternal(t *testing.T) {
 				flushed = true
 			}},
 			FormatMajorVersion: majorVersion,
+			Logger:             testLogger{t},
 		}
 		opts.Experimental.RemoteStorage = remote.MakeSimpleFactory(map[remote.Locator]remote.Storage{
 			"external-locator": remoteStorage,
@@ -1798,7 +1804,7 @@ func TestIngestExternal(t *testing.T) {
 		// Disable automatic compactions because otherwise we'll race with
 		// delete-only compactions triggered by ingesting range tombstones.
 		opts.DisableAutomaticCompactions = true
-		lel := MakeLoggingEventListener(DefaultLogger)
+		lel := MakeLoggingEventListener(testLogger{t})
 		opts.EventListener = &lel
 
 		reopen(t)
@@ -3142,7 +3148,7 @@ func TestIngestFileNumReuseCrash(t *testing.T) {
 	// to induce errors on Remove calls. Even if we're unsuccessful in
 	// removing the obsolete files, the external files should not be
 	// overwritten.
-	d, err = Open(dir, &Options{FS: noRemoveFS{FS: fs}})
+	d, err = Open(dir, &Options{FS: noRemoveFS{FS: fs}, Logger: testLogger{t}})
 	require.NoError(t, err)
 	require.NoError(t, d.Set([]byte("bar"), nil, nil))
 	require.NoError(t, d.Flush())

iterator_histories_test.go

@@ -50,6 +50,7 @@ func TestIterHistories(t *testing.T) {
 				BlockPropertyCollectors: []func() BlockPropertyCollector{
 					sstable.NewTestKeysBlockPropertyCollector,
 				},
+				Logger: testLogger{t},
 			}
 
 			opts.DisableAutomaticCompactions = true

level_checker_test.go

@@ -37,7 +37,8 @@ func TestCheckLevelsBasics(t *testing.T) {
 				t.Fatalf("%s: cloneFileSystem failed: %v", tc, err)
 			}
 			d, err := Open(tc, &Options{
-				FS: fs,
+				FS:     fs,
+				Logger: testLogger{t},
 			})
 			if err != nil {
 				t.Fatalf("%s: Open failed: %v", tc, err)

open_test.go

@@ -224,7 +224,7 @@ func TestOpen_WALFailover(t *testing.T) {
 			return buf.String()
 		case "open":
 			var dataDir string
-			o := &Options{}
+			o := &Options{Logger: testLogger{t}}
 			for _, cmdArg := range td.CmdArgs {
 				switch cmdArg.Key {
 				case "path":
@@ -507,11 +507,11 @@ func TestOpenCrashWritingOptions(t *testing.T) {
 	// Open the database again, this time with a mocked filesystem that
 	// will only succeed in partially writing the OPTIONS file.
 	fs := optionsTornWriteFS{FS: memFS}
-	_, err = Open("", &Options{FS: fs})
+	_, err = Open("", &Options{FS: fs, Logger: testLogger{t}})
 	require.Error(t, err)
 
 	// Re-opening the database must succeed.
-	d, err = Open("", &Options{FS: memFS})
+	d, err = Open("", &Options{FS: memFS, Logger: testLogger{t}})
 	require.NoError(t, err)
 	require.NoError(t, d.Close())
 }
@@ -790,6 +790,7 @@ func TestWALReplaySequenceNumBug(t *testing.T) {
 	d, err = Open("", &Options{
 		FS:       mem,
 		ReadOnly: true,
+		Logger:   testLogger{t},
 	})
 	require.NoError(t, err)
 	val, c, _ := d.Get([]byte("1"))
@@ -929,6 +930,7 @@ func TestTwoWALReplayPermissive(t *testing.T) {
 	opts := &Options{
 		MemTableStopWritesThreshold: 4,
 		MemTableSize:                2048,
+		Logger:                      testLogger{t},
 	}
 	opts.testingRandomized(t)
 	opts.EnsureDefaults()
@@ -977,7 +979,7 @@ func TestTwoWALReplayPermissive(t *testing.T) {
 	require.NoError(t, vfs.Default.Remove(filepath.Join(dir, optionFilename)))
 
 	// Re-opening the database should not report the corruption.
-	d, err = Open(dir, nil)
+	d, err = Open(dir, &Options{Logger: testLogger{t}})
 	require.NoError(t, err)
 	require.NoError(t, d.Close())
 }
@@ -1069,6 +1071,7 @@ func TestCrashOpenCrashAfterWALCreation(t *testing.T) {
 				}
 				return nil
 			})),
+			Logger: testLogger{t},
 		})
 		require.NoError(t, err)
 		require.NoError(t, d.Close())
@@ -1258,7 +1261,8 @@ func TestOpenNeverFlushed(t *testing.T) {
 	require.NoError(t, w.Close())
 
 	opts := &Options{
-		FS: mem,
+		FS:     mem,
+		Logger: testLogger{t},
 	}
 	db, err := Open("", opts)
 	require.NoError(t, err)
@@ -1478,7 +1482,7 @@ func TestOpenRatchetsNextFileNum(t *testing.T) {
 	mem := vfs.NewMem()
 	memShared := remote.NewInMem()
 
-	opts := &Options{FS: mem}
+	opts := &Options{FS: mem, Logger: testLogger{t}}
 	opts.Experimental.CreateOnShared = remote.CreateOnSharedAll
 	opts.Experimental.RemoteStorage = remote.MakeSimpleFactory(map[remote.Locator]remote.Storage{
 		"": memShared,

range_del_test.go

@@ -97,6 +97,7 @@ func TestFlushDelay(t *testing.T) {
 		FlushDelayDeleteRange: 10 * time.Millisecond,
 		FlushDelayRangeKey:    10 * time.Millisecond,
 		FormatMajorVersion:    internalFormatNewest,
+		Logger:                testLogger{t: t},
 	}
 	d, err := Open("", opts)
 	require.NoError(t, err)
@@ -197,6 +198,7 @@ func TestFlushDelayStress(t *testing.T) {
 		FlushDelayRangeKey:    time.Duration(rng.Intn(10)+1) * time.Millisecond,
 		FormatMajorVersion:    internalFormatNewest,
 		MemTableSize:          8192,
+		Logger:                testLogger{t: t},
 	}
 
 	const runs = 100

table_stats_test.go

@@ -34,6 +34,7 @@ func TestTableStats(t *testing.T) {
 				loadedInfo = &info
 			},
 		},
+		Logger: testLogger{t},
 	}
 
 	d, err := Open("", opts)

version_set_test.go

@@ -38,6 +38,7 @@ func TestVersionSet(t *testing.T) {
 	opts := &Options{
 		FS:       vfs.NewMem(),
 		Comparer: base.DefaultComparer,
+		Logger:   testLogger{t},
 	}
 	opts.EnsureDefaults()
 	mu := &sync.Mutex{}
@@ -199,6 +200,7 @@ func TestVersionSetCheckpoint(t *testing.T) {
 	opts := &Options{
 		FS:                  mem,
 		MaxManifestFileSize: 1,
+		Logger:              testLogger{t: t},
 	}
 	d, err := Open("", opts)
 	require.NoError(t, err)
@@ -231,6 +233,7 @@ func TestVersionSetSeqNums(t *testing.T) {
 	opts := &Options{
 		FS:                  mem,
 		MaxManifestFileSize: 1,
+		Logger:              testLogger{t: t},
 	}
 	d, err := Open("", opts)
 	require.NoError(t, err)