test(time): drop redundant comments in timestamp tests

Author: moonD4rk

browser/chromium/chromium_test.go

@@ -722,13 +722,7 @@ func TestSetKeyRetrievers_SatisfiesInterface(t *testing.T) {
 	} = (*Browser)(nil)
 }
 
-// ---------------------------------------------------------------------------
-// timeEpoch
-// ---------------------------------------------------------------------------
-
-// Anchor: 2024-01-15T10:30:00Z = Unix seconds 1705314600. Chromium stores
-// this as microseconds since 1601-01-01 UTC, so the stored value is
-// (1705314600 + 11644473600) * 1e6.
+// Anchor: 2024-01-15T10:30:00Z as Chromium microseconds since 1601 UTC.
 const anchorUnixSeconds = int64(1705314600)
 
 var anchorChromiumMicros = (anchorUnixSeconds + 11644473600) * 1_000_000
@@ -741,41 +735,30 @@ func TestTimeEpoch_AnchorDate(t *testing.T) {
 }
 
 func TestTimeEpoch_ZeroReturnsZeroTime(t *testing.T) {
-	// Chromium uses 0 for session cookies (no persistent expiry).
 	assert.True(t, timeEpoch(0).IsZero())
 }
 
 func TestTimeEpoch_NegativeReturnsZeroTime(t *testing.T) {
-	// -1 is the legacy "never expires" sentinel on older profiles.
 	assert.True(t, timeEpoch(-1).IsZero())
 }
 
 func TestTimeEpoch_AlwaysUTC(t *testing.T) {
-	// Location must be UTC regardless of the test runner's TZ. Set a
-	// non-UTC local zone via t.Setenv so the assertion catches any
-	// accidental time.Local usage.
 	t.Setenv("TZ", "Asia/Shanghai")
 	got := timeEpoch(anchorChromiumMicros)
 	assert.Equal(t, time.UTC, got.Location())
 }
 
 func TestTimeEpoch_MicrosecondPrecisionPreserved(t *testing.T) {
-	// Add 123456 μs to the anchor and confirm the nanosecond component
-	// survives the conversion (no silent truncation to seconds).
 	got := timeEpoch(anchorChromiumMicros + 123456)
 	assert.Equal(t, 123456*int64(time.Microsecond), int64(got.Nanosecond()))
 }
 
 func TestTimeEpoch_UnixEpochBoundary(t *testing.T) {
-	// Exactly the offset constant → 1970-01-01T00:00:00 UTC.
 	got := timeEpoch(chromiumEpochOffsetMicros)
 	assert.Equal(t, time.Unix(0, 0).UTC(), got)
 }
 
 func TestTimeEpoch_OutOfJSONRangeReturnsZero(t *testing.T) {
-	// Some sites write nonsense "never expires" sentinels that compute
-	// to years past 9999. time.Time.MarshalJSON would crash on those;
-	// the helper must defensively return zero so JSON export works.
 	jsonBytes, err := timeEpoch(1 << 62).MarshalJSON()
 	require.NoError(t, err)
 	assert.JSONEq(t, `"0001-01-01T00:00:00Z"`, string(jsonBytes))

browser/firefox/firefox_test.go

@@ -317,11 +317,7 @@ func TestExtractCategory(t *testing.T) {
 	})
 }
 
-// ---------------------------------------------------------------------------
-// firefoxMicros / firefoxMillis / firefoxSeconds
-// ---------------------------------------------------------------------------
-
-// Anchor: 2024-01-15T10:30:00Z → Unix seconds 1705314600.
+// Anchor: 2024-01-15T10:30:00Z.
 const anchorUnixSeconds = int64(1705314600)
 
 func TestFirefoxMicros_AnchorDate(t *testing.T) {
@@ -331,7 +327,6 @@ func TestFirefoxMicros_AnchorDate(t *testing.T) {
 }
 
 func TestFirefoxMicros_PrecisionPreserved(t *testing.T) {
-	// 123456 μs past the anchor — the sub-second portion must survive.
 	got := firefoxMicros(anchorUnixSeconds*1_000_000 + 123456)
 	assert.Equal(t, 123456*int64(time.Microsecond), int64(got.Nanosecond()))
 }
@@ -366,16 +361,13 @@ func TestFirefoxHelpers_NegativeReturnsZeroTime(t *testing.T) {
 }
 
 func TestFirefoxHelpers_AlwaysUTC(t *testing.T) {
-	// Verify no helper leaks time.Local, regardless of runner TZ.
 	t.Setenv("TZ", "Asia/Shanghai")
 	assert.Equal(t, time.UTC, firefoxMicros(anchorUnixSeconds*1_000_000).Location())
 	assert.Equal(t, time.UTC, firefoxMillis(anchorUnixSeconds*1_000).Location())
 	assert.Equal(t, time.UTC, firefoxSeconds(anchorUnixSeconds).Location())
 }
 
 func TestFirefoxHelpers_SameMomentAcrossUnits(t *testing.T) {
-	// The same wall-clock instant, expressed in three units, must
-	// produce three equal time.Time values (no unit confusion).
 	us := firefoxMicros(anchorUnixSeconds * 1_000_000)
 	ms := firefoxMillis(anchorUnixSeconds * 1_000)
 	s := firefoxSeconds(anchorUnixSeconds)
@@ -384,10 +376,6 @@ func TestFirefoxHelpers_SameMomentAcrossUnits(t *testing.T) {
 }
 
 func TestFirefoxHelpers_OutOfJSONRangeReturnsZero(t *testing.T) {
-	// Cookie expiry is occasionally set to INT64_MAX meaning "never";
-	// without the clamp, time.Time.MarshalJSON would crash at export.
-	// All three helpers must return the zero time for such input, so
-	// JSON round-trip just yields "0001-01-01T00:00:00Z".
 	for _, tc := range []struct {
 		name string
 		got  time.Time

browser/safari/safari_test.go

@@ -336,12 +336,7 @@ func TestExtractCategory(t *testing.T) {
 	})
 }
 
-// ---------------------------------------------------------------------------
-// coredataTimestamp
-// ---------------------------------------------------------------------------
-
-// Anchor: 2024-01-15T10:30:00Z = Unix 1705314600, which is
-// 1705314600 - 978307200 seconds past the Core Data epoch (2001-01-01Z).
+// Anchor: 2024-01-15T10:30:00Z, in seconds past the Core Data epoch (2001-01-01Z).
 const anchorCoreDataSeconds = 1705314600 - 978307200
 
 func TestCoredataTimestamp_AnchorDate(t *testing.T) {
@@ -351,8 +346,6 @@ func TestCoredataTimestamp_AnchorDate(t *testing.T) {
 }
 
 func TestCoredataTimestamp_EpochZero(t *testing.T) {
-	// Core Data "distant past" sentinel (0 seconds) maps to the zero
-	// time.Time rather than silently returning 2001-01-01.
 	assert.True(t, coredataTimestamp(0).IsZero())
 }
 
@@ -361,8 +354,6 @@ func TestCoredataTimestamp_NegativeReturnsZeroTime(t *testing.T) {
 }
 
 func TestCoredataTimestamp_FractionalSecondsPreserved(t *testing.T) {
-	// Core Data is a floating-point double, so fractional seconds are
-	// real. 0.5s fraction must survive, not silently truncate.
 	got := coredataTimestamp(float64(anchorCoreDataSeconds) + 0.5)
 	assert.Equal(t, 500*int64(time.Millisecond), int64(got.Nanosecond()))
 }