snapshot of https://github.com/grpc/grpc-go.git (master, 2026-09-15; blobs > 131072B omitted)

test/context_canceled_test.go

@@ -0,0 +1,164 @@
+/*
+ *
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/encoding/gzip"
+	"google.golang.org/grpc/internal/stubserver"
+	"google.golang.org/grpc/metadata"
+	"google.golang.org/grpc/status"
+
+	testgrpc "google.golang.org/grpc/interop/grpc_testing"
+	testpb "google.golang.org/grpc/interop/grpc_testing"
+)
+
+func (s) TestContextCanceled(t *testing.T) {
+	ss := &stubserver.StubServer{
+		FullDuplexCallF: func(stream testgrpc.TestService_FullDuplexCallServer) error {
+			stream.SetTrailer(metadata.New(map[string]string{"a": "b"}))
+			return status.Error(codes.PermissionDenied, "perm denied")
+		},
+	}
+	if err := ss.Start(nil); err != nil {
+		t.Fatalf("Error starting endpoint server: %v", err)
+	}
+	defer ss.Stop()
+
+	// Runs 10 rounds of tests with the given delay and returns counts of status codes.
+	// Fails in case of trailer/status code inconsistency.
+	const cntRetry uint = 10
+	runTest := func(delay time.Duration) (cntCanceled, cntPermDenied uint) {
+		for i := uint(0); i < cntRetry; i++ {
+			ctx, cancel := context.WithTimeout(context.Background(), delay)
+			defer cancel()
+
+			str, err := ss.Client.FullDuplexCall(ctx)
+			if err != nil {
+				continue
+			}
+
+			_, err = str.Recv()
+			if err == nil {
+				t.Fatalf("non-nil error expected from Recv()")
+			}
+
+			_, trlOk := str.Trailer()["a"]
+			switch status.Code(err) {
+			case codes.PermissionDenied:
+				if !trlOk {
+					t.Fatalf(`status err: %v; wanted key "a" in trailer but didn't get it`, err)
+				}
+				cntPermDenied++
+			case codes.DeadlineExceeded:
+				if trlOk {
+					t.Fatalf(`status err: %v; didn't want key "a" in trailer but got it`, err)
+				}
+				cntCanceled++
+			default:
+				t.Fatalf(`unexpected status err: %v`, err)
+			}
+		}
+		return cntCanceled, cntPermDenied
+	}
+
+	// Tries to find the delay that causes canceled/perm denied race.
+	canceledOk, permDeniedOk := false, false
+	for lower, upper := time.Duration(0), 2*time.Millisecond; lower <= upper; {
+		delay := lower + (upper-lower)/2
+		cntCanceled, cntPermDenied := runTest(delay)
+		if cntPermDenied > 0 && cntCanceled > 0 {
+			// Delay that causes the race is found.
+			return
+		}
+
+		// Set OK flags.
+		if cntCanceled > 0 {
+			canceledOk = true
+		}
+		if cntPermDenied > 0 {
+			permDeniedOk = true
+		}
+
+		if cntPermDenied == 0 {
+			// No perm denied, increase the delay.
+			lower += (upper-lower)/10 + 1
+		} else {
+			// All perm denied, decrease the delay.
+			upper -= (upper-lower)/10 + 1
+		}
+	}
+
+	if !canceledOk || !permDeniedOk {
+		t.Fatalf(`couldn't find the delay that causes canceled/perm denied race.`)
+	}
+}
+
+// To make sure that canceling a stream with compression enabled won't result in
+// internal error, compressed flag set with identity or empty encoding.
+//
+// The root cause is a select race on stream headerChan and ctx. Stream gets
+// whether compression is enabled and the compression type from two separate
+// functions, both include select with context. If the `case non-ctx:` wins the
+// first one, but `case ctx.Done()` wins the second one, the compression info
+// will be inconsistent, and it causes internal error.
+func (s) TestCancelWhileRecvingWithCompression(t *testing.T) {
+	ss := &stubserver.StubServer{
+		FullDuplexCallF: func(stream testgrpc.TestService_FullDuplexCallServer) error {
+			for {
+				if err := stream.Send(&testpb.StreamingOutputCallResponse{
+					Payload: nil,
+				}); err != nil {
+					return err
+				}
+			}
+		},
+	}
+	if err := ss.Start(nil); err != nil {
+		t.Fatalf("Error starting endpoint server: %v", err)
+	}
+	defer ss.Stop()
+
+	for i := 0; i < 10; i++ {
+		ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
+		s, err := ss.Client.FullDuplexCall(ctx, grpc.UseCompressor(gzip.Name))
+		if err != nil {
+			t.Fatalf("failed to start bidi streaming RPC: %v", err)
+		}
+		// Cancel the stream while receiving to trigger the internal error.
+		time.AfterFunc(time.Millisecond, cancel)
+		for {
+			_, err := s.Recv()
+			if err != nil {
+				if status.Code(err) != codes.Canceled {
+					t.Fatalf("recv failed with %v, want Canceled", err)
+				}
+				break
+			}
+		}
+	}
+	if err := ss.CC.Close(); err != nil {
+		t.Fatalf("Close failed with %v, want nil", err)
+	}
+}