uber-go
diff --git a/‎.golangci.yml‎
Lines changed: 2 additions & 1 deletion b/‎.golangci.yml‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎array_test.go‎
Lines changed: 12 additions & 5 deletions b/‎array_test.go‎
Lines changed: 12 additions & 5 deletions
diff --git a/‎buffer/buffer_test.go‎
Lines changed: 70 additions & 16 deletions b/‎buffer/buffer_test.go‎
Lines changed: 70 additions & 16 deletions
diff --git a/‎buffer/pool_test.go‎
Lines changed: 2 additions & 0 deletions b/‎buffer/pool_test.go‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎clock_test.go‎
Lines changed: 2 additions & 0 deletions b/‎clock_test.go‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎config_test.go‎
Lines changed: 17 additions & 0 deletions b/‎config_test.go‎
Lines changed: 17 additions & 0 deletions
diff --git a/‎encoder_test.go‎
Lines changed: 11 additions & 0 deletions b/‎encoder_test.go‎
Lines changed: 11 additions & 0 deletions
diff --git a/‎error_test.go‎
Lines changed: 25 additions & 9 deletions b/‎error_test.go‎
Lines changed: 25 additions & 9 deletions
diff --git a/‎exp/zapfield/zapfield_test.go‎
Lines changed: 11 additions & 4 deletions b/‎exp/zapfield/zapfield_test.go‎
Lines changed: 11 additions & 4 deletions
@@ -18,7 +18,8 @@ linters:
 
     # Our own extras:
     - gofumpt
-    - nolintlint # lints nolint directives
+    - nolintlint   # lints nolint directives
+    - paralleltest # requires t.Parallel on all tests
     - revive
 
 linters-settings:
 
@@ -53,6 +53,8 @@ func BenchmarkBoolsReflect(b *testing.B) {
 }
 
 func TestArrayWrappers(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		desc     string
 		field    Field
@@ -101,11 +103,16 @@ func TestArrayWrappers(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		enc := zapcore.NewMapObjectEncoder()
-		tt.field.Key = "k"
-		tt.field.AddTo(enc)
-		assert.Equal(t, tt.expected, enc.Fields["k"], "%s: unexpected map contents.", tt.desc)
-		assert.Equal(t, 1, len(enc.Fields), "%s: found extra keys in map: %v", tt.desc, enc.Fields)
+		tt := tt
+		t.Run(tt.desc, func(t *testing.T) {
+			t.Parallel()
+
+			enc := zapcore.NewMapObjectEncoder()
+			tt.field.Key = "k"
+			tt.field.AddTo(enc)
+			assert.Equal(t, tt.expected, enc.Fields["k"], "unexpected map contents")
+			assert.Equal(t, 1, len(enc.Fields), "found extra keys in map: %v", enc.Fields)
+		})
 	}
 }
 
 
@@ -30,32 +30,86 @@ import (
 )
 
 func TestBufferWrites(t *testing.T) {
-	buf := NewPool().Get()
+	t.Parallel()
 
 	tests := []struct {
 		desc string
-		f    func()
+		f    func(*Buffer)
 		want string
 	}{
-		{"AppendByte", func() { buf.AppendByte('v') }, "v"},
-		{"AppendString", func() { buf.AppendString("foo") }, "foo"},
-		{"AppendIntPositive", func() { buf.AppendInt(42) }, "42"},
-		{"AppendIntNegative", func() { buf.AppendInt(-42) }, "-42"},
-		{"AppendUint", func() { buf.AppendUint(42) }, "42"},
-		{"AppendBool", func() { buf.AppendBool(true) }, "true"},
-		{"AppendFloat64", func() { buf.AppendFloat(3.14, 64) }, "3.14"},
+		{
+			desc: "AppendByte",
+			f:    func(buf *Buffer) { buf.AppendByte('v') },
+			want: "v",
+		},
+		{
+			desc: "AppendString",
+			f:    func(buf *Buffer) { buf.AppendString("foo") },
+			want: "foo",
+		},
+		{
+			desc: "AppendIntPositive",
+			f:    func(buf *Buffer) { buf.AppendInt(42) },
+			want: "42",
+		},
+		{
+			desc: "AppendIntNegative",
+			f:    func(buf *Buffer) { buf.AppendInt(-42) },
+			want: "-42",
+		},
+		{
+			desc: "AppendUint",
+			f:    func(buf *Buffer) { buf.AppendUint(42) },
+			want: "42",
+		},
+		{
+			desc: "AppendBool",
+			f:    func(buf *Buffer) { buf.AppendBool(true) },
+			want: "true",
+		},
+		{
+			desc: "AppendFloat64",
+			f:    func(buf *Buffer) { buf.AppendFloat(3.14, 64) },
+			want: "3.14",
+		},
 		// Intentionally introduce some floating-point error.
-		{"AppendFloat32", func() { buf.AppendFloat(float64(float32(3.14)), 32) }, "3.14"},
-		{"AppendWrite", func() { buf.Write([]byte("foo")) }, "foo"},
-		{"AppendTime", func() { buf.AppendTime(time.Date(2000, 1, 2, 3, 4, 5, 6, time.UTC), time.RFC3339) }, "2000-01-02T03:04:05Z"},
-		{"WriteByte", func() { buf.WriteByte('v') }, "v"},
-		{"WriteString", func() { buf.WriteString("foo") }, "foo"},
+		{
+			desc: "AppendFloat32",
+			f:    func(buf *Buffer) { buf.AppendFloat(float64(float32(3.14)), 32) },
+			want: "3.14",
+		},
+		{
+			desc: "AppendWrite",
+			f:    func(buf *Buffer) { buf.Write([]byte("foo")) },
+			want: "foo",
+		},
+		{
+			desc: "AppendTime",
+			f:    func(buf *Buffer) { buf.AppendTime(time.Date(2000, 1, 2, 3, 4, 5, 6, time.UTC), time.RFC3339) },
+			want: "2000-01-02T03:04:05Z",
+		},
+		{
+			desc: "WriteByte",
+			f:    func(buf *Buffer) { buf.WriteByte('v') },
+			want: "v",
+		},
+		{
+			desc: "WriteString",
+			f:    func(buf *Buffer) { buf.WriteString("foo") },
+			want: "foo",
+		},
 	}
 
+	pool := NewPool()
 	for _, tt := range tests {
+		tt := tt
 		t.Run(tt.desc, func(t *testing.T) {
-			buf.Reset()
-			tt.f()
+			t.Parallel()
+
+			buf := pool.Get()
+			defer buf.Free()
+
+			tt.f(buf)
 			assert.Equal(t, tt.want, buf.String(), "Unexpected buffer.String().")
 			assert.Equal(t, tt.want, string(buf.Bytes()), "Unexpected string(buffer.Bytes()).")
 			assert.Equal(t, len(tt.want), buf.Len(), "Unexpected buffer length.")
 
@@ -28,6 +28,8 @@ import (
 )
 
 func TestBuffers(t *testing.T) {
+	t.Parallel()
+
 	const dummyData = "dummy data"
 	p := NewPool()
 
 
@@ -37,6 +37,8 @@ func (c constantClock) NewTicker(d time.Duration) *time.Ticker {
 }
 
 func TestWithClock(t *testing.T) {
+	t.Parallel()
+
 	date := time.Date(2077, 1, 23, 10, 15, 13, 441, time.UTC)
 	clock := constantClock(date)
 	withLogger(t, DebugLevel, []Option{WithClock(clock)}, func(log *Logger, logs *observer.ObservedLogs) {
 
@@ -32,6 +32,8 @@ import (
 )
 
 func TestConfig(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		desc     string
 		cfg      Config
@@ -57,7 +59,10 @@ func TestConfig(t *testing.T) {
 	}
 
 	for _, tt := range tests {
+		tt := tt
 		t.Run(tt.desc, func(t *testing.T) {
+			t.Parallel()
+
 			logOut := filepath.Join(t.TempDir(), "test.log")
 
 			tt.cfg.OutputPaths = []string{logOut}
@@ -86,6 +91,8 @@ func TestConfig(t *testing.T) {
 }
 
 func TestConfigWithInvalidPaths(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		desc      string
 		output    string
@@ -97,7 +104,10 @@ func TestConfigWithInvalidPaths(t *testing.T) {
 	}
 
 	for _, tt := range tests {
+		tt := tt
 		t.Run(tt.desc, func(t *testing.T) {
+			t.Parallel()
+
 			cfg := NewProductionConfig()
 			cfg.OutputPaths = []string{tt.output}
 			cfg.ErrorOutputPaths = []string{tt.errOutput}
@@ -108,6 +118,8 @@ func TestConfigWithInvalidPaths(t *testing.T) {
 }
 
 func TestConfigWithMissingAttributes(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		desc      string
 		cfg       Config
@@ -135,7 +147,10 @@ func TestConfigWithMissingAttributes(t *testing.T) {
 	}
 
 	for _, tt := range tests {
+		tt := tt
 		t.Run(tt.desc, func(t *testing.T) {
+			t.Parallel()
+
 			cfg := tt.cfg
 			_, err := cfg.Build()
 			assert.EqualError(t, err, tt.expectErr)
@@ -159,6 +174,8 @@ func makeSamplerCountingHook() (h func(zapcore.Entry, zapcore.SamplingDecision),
 }
 
 func TestConfigWithSamplingHook(t *testing.T) {
+	t.Parallel()
+
 	shook, dcount, scount := makeSamplerCountingHook()
 	cfg := Config{
 		Level:       NewAtomicLevelAt(InfoLevel),
 
@@ -29,16 +29,20 @@ import (
 )
 
 func TestRegisterDefaultEncoders(t *testing.T) {
+	t.Parallel()
+
 	testEncodersRegistered(t, "console", "json")
 }
 
+//nolint:paralleltest // modifies global registry
 func TestRegisterEncoder(t *testing.T) {
 	testEncoders(func() {
 		assert.NoError(t, RegisterEncoder("foo", newNilEncoder), "expected to be able to register the encoder foo")
 		testEncodersRegistered(t, "foo")
 	})
 }
 
+//nolint:paralleltest // modifies global registry
 func TestDuplicateRegisterEncoder(t *testing.T) {
 	testEncoders(func() {
 		assert.NoError(t, RegisterEncoder("foo", newNilEncoder), "expected to be able to register the encoder foo")
@@ -47,9 +51,12 @@ func TestDuplicateRegisterEncoder(t *testing.T) {
 }
 
 func TestRegisterEncoderNoName(t *testing.T) {
+	t.Parallel()
+
 	assert.Equal(t, errNoEncoderNameSpecified, RegisterEncoder("", newNilEncoder), "expected an error when registering an encoder with no name")
 }
 
+//nolint:paralleltest // modifies global registry
 func TestNewEncoder(t *testing.T) {
 	testEncoders(func() {
 		assert.NoError(t, RegisterEncoder("foo", newNilEncoder), "expected to be able to register the encoder foo")
@@ -60,11 +67,15 @@ func TestNewEncoder(t *testing.T) {
 }
 
 func TestNewEncoderNotRegistered(t *testing.T) {
+	t.Parallel()
+
 	_, err := newEncoder("foo", zapcore.EncoderConfig{})
 	assert.Error(t, err, "expected an error when trying to create an encoder of an unregistered name")
 }
 
 func TestNewEncoderNoName(t *testing.T) {
+	t.Parallel()
+
 	_, err := newEncoder("", zapcore.EncoderConfig{})
 	assert.Equal(t, errNoEncoderNameSpecified, err, "expected an error when creating an encoder with no name")
 }
 
@@ -32,6 +32,8 @@ import (
 )
 
 func TestErrorConstructors(t *testing.T) {
+	t.Parallel()
+
 	fail := errors.New("fail")
 
 	tests := []struct {
@@ -48,14 +50,21 @@ func TestErrorConstructors(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		if !assert.Equal(t, tt.expect, tt.field, "Unexpected output from convenience field constructor %s.", tt.name) {
-			t.Logf("type expected: %T\nGot: %T", tt.expect.Interface, tt.field.Interface)
-		}
-		assertCanBeReused(t, tt.field)
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			if !assert.Equal(t, tt.expect, tt.field, "Unexpected output from convenience field constructor %s.", tt.name) {
+				t.Logf("type expected: %T\nGot: %T", tt.expect.Interface, tt.field.Interface)
+			}
+			assertCanBeReused(t, tt.field)
+		})
 	}
 }
 
 func TestErrorArrayConstructor(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		desc     string
 		field    Field
@@ -70,15 +79,22 @@ func TestErrorArrayConstructor(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		enc := zapcore.NewMapObjectEncoder()
-		tt.field.Key = "k"
-		tt.field.AddTo(enc)
-		assert.Equal(t, tt.expected, enc.Fields["k"], "%s: unexpected map contents.", tt.desc)
-		assert.Equal(t, 1, len(enc.Fields), "%s: found extra keys in map: %v", tt.desc, enc.Fields)
+		tt := tt
+		t.Run(tt.desc, func(t *testing.T) {
+			t.Parallel()
+
+			enc := zapcore.NewMapObjectEncoder()
+			tt.field.Key = "k"
+			tt.field.AddTo(enc)
+			assert.Equal(t, tt.expected, enc.Fields["k"], "%s: unexpected map contents.", tt.desc)
+			assert.Equal(t, 1, len(enc.Fields), "%s: found extra keys in map: %v", tt.desc, enc.Fields)
+		})
 	}
 }
 
 func TestErrorsArraysHandleRichErrors(t *testing.T) {
+	t.Parallel()
+
 	errs := []error{fmt.Errorf("egad")}
 
 	enc := zapcore.NewMapObjectEncoder()
 
@@ -36,6 +36,8 @@ type (
 )
 
 func TestFieldConstructors(t *testing.T) {
+	t.Parallel()
+
 	var (
 		key    = MyKey("test key")
 		value  = MyValue("test value")
@@ -55,10 +57,15 @@ func TestFieldConstructors(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		if !assert.Equal(t, tt.expect, tt.field, "Unexpected output from convenience field constructor %s.", tt.name) {
-			t.Logf("type expected: %T\nGot: %T", tt.expect.Interface, tt.field.Interface)
-		}
-		assertCanBeReused(t, tt.field)
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			if !assert.Equal(t, tt.expect, tt.field, "Unexpected output from convenience field constructor %s.", tt.name) {
+				t.Logf("type expected: %T\nGot: %T", tt.expect.Interface, tt.field.Interface)
+			}
+			assertCanBeReused(t, tt.field)
+		})
 	}
 }
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,8 @@ import (`
`28`	`28`	`)`
`29`	`29`
`30`	`30`	`func TestBuffers(t *testing.T) {`
	`31`	`+ t.Parallel()`
	`32`	`+`
`31`	`33`	`const dummyData = "dummy data"`
`32`	`34`	`p := NewPool()`
`33`	`35`
Original file line number	Diff line number	Diff line change
`@@ -37,6 +37,8 @@ func (c constantClock) NewTicker(d time.Duration) *time.Ticker {`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`func TestWithClock(t *testing.T) {`
	`40`	`+ t.Parallel()`
	`41`	`+`
`40`	`42`	`date := time.Date(2077, 1, 23, 10, 15, 13, 441, time.UTC)`
`41`	`43`	`clock := constantClock(date)`
`42`	`44`	`withLogger(t, DebugLevel, []Option{WithClock(clock)}, func(log Logger, logs observer.ObservedLogs) {`
Original file line number	Diff line number	Diff line change
`@@ -29,16 +29,20 @@ import (`
`29`	`29`	`)`
`30`	`30`
`31`	`31`	`func TestRegisterDefaultEncoders(t *testing.T) {`
	`32`	`+ t.Parallel()`
	`33`	`+`
`32`	`34`	`testEncodersRegistered(t, "console", "json")`
`33`	`35`	`}`
`34`	`36`
	`37`	`+//nolint:paralleltest // modifies global registry`
`35`	`38`	`func TestRegisterEncoder(t *testing.T) {`
`36`	`39`	`testEncoders(func() {`
`37`	`40`	`assert.NoError(t, RegisterEncoder("foo", newNilEncoder), "expected to be able to register the encoder foo")`
`38`	`41`	`testEncodersRegistered(t, "foo")`
`39`	`42`	`})`
`40`	`43`	`}`
`41`	`44`
	`45`	`+//nolint:paralleltest // modifies global registry`
`42`	`46`	`func TestDuplicateRegisterEncoder(t *testing.T) {`
`43`	`47`	`testEncoders(func() {`
`44`	`48`	`assert.NoError(t, RegisterEncoder("foo", newNilEncoder), "expected to be able to register the encoder foo")`
`@@ -47,9 +51,12 @@ func TestDuplicateRegisterEncoder(t *testing.T) {`
`47`	`51`	`}`
`48`	`52`
`49`	`53`	`func TestRegisterEncoderNoName(t *testing.T) {`
	`54`	`+ t.Parallel()`
	`55`	`+`
`50`	`56`	`assert.Equal(t, errNoEncoderNameSpecified, RegisterEncoder("", newNilEncoder), "expected an error when registering an encoder with no name")`
`51`	`57`	`}`
`52`	`58`
	`59`	`+//nolint:paralleltest // modifies global registry`
`53`	`60`	`func TestNewEncoder(t *testing.T) {`
`54`	`61`	`testEncoders(func() {`
`55`	`62`	`assert.NoError(t, RegisterEncoder("foo", newNilEncoder), "expected to be able to register the encoder foo")`
`@@ -60,11 +67,15 @@ func TestNewEncoder(t *testing.T) {`
`60`	`67`	`}`
`61`	`68`
`62`	`69`	`func TestNewEncoderNotRegistered(t *testing.T) {`
	`70`	`+ t.Parallel()`
	`71`	`+`
`63`	`72`	`_, err := newEncoder("foo", zapcore.EncoderConfig{})`
`64`	`73`	`assert.Error(t, err, "expected an error when trying to create an encoder of an unregistered name")`
`65`	`74`	`}`
`66`	`75`
`67`	`76`	`func TestNewEncoderNoName(t *testing.T) {`
	`77`	`+ t.Parallel()`
	`78`	`+`
`68`	`79`	`_, err := newEncoder("", zapcore.EncoderConfig{})`
`69`	`80`	`assert.Equal(t, errNoEncoderNameSpecified, err, "expected an error when creating an encoder with no name")`
`70`	`81`	`}`