added test

Author: Pranjali-2501

stream.go

@@ -542,6 +542,8 @@ type clientStream struct {
 
 	sentLast bool // sent an end stream
 
+	recvFirstMsg bool // received first msg
+
 	methodConfig *MethodConfig
 
 	ctx context.Context // the application's context, wrapped by stats/tracing
@@ -1135,14 +1137,17 @@ func (a *csAttempt) recvMsg(m any, payInfo *payloadInfo) (err error) {
 				return statusErr
 			}
 			// received no msg and status ok for non-server streaming rpcs.
-			if !cs.desc.ServerStreams {
+			if !cs.desc.ServerStreams && !cs.recvFirstMsg {
 				return status.Errorf(codes.Internal, "cardinality violation: received no response message from non-streaming RPC")
 			}
 			return io.EOF // indicates successful end of stream.
 		}
 
 		return toRPCErr(err)
 	}
+	if !cs.desc.ServerStreams {
+		cs.recvFirstMsg = true
+	}
 	if a.trInfo != nil {
 		a.mu.Lock()
 		if a.trInfo.tr != nil {

test/end2end_test.go

@@ -3736,6 +3736,38 @@ func (s) TestClientStreaming_ReturnErrorAfterSendAndClose(t *testing.T) {
 	}
 }
 
+// Tests for a successful RPC, client will continue to receive io.EOF for successive calls to CloseAndRecv().
+func (s) TestClientStreaming_ClientCallCloseAndRecvAfterCloseAndRecv(t *testing.T) {
+	ss := stubserver.StubServer{
+		StreamingInputCallF: func(stream testgrpc.TestService_StreamingInputCallServer) error {
+			if err := stream.SendAndClose(&testpb.StreamingInputCallResponse{}); err != nil {
+				t.Errorf("stream.SendAndClose(_) = %v, want <nil>", err)
+			}
+			return nil
+		},
+	}
+	if err := ss.Start(nil); err != nil {
+		t.Fatal("Error starting server:", err)
+	}
+	defer ss.Stop()
+
+	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
+	defer cancel()
+	stream, err := ss.Client.StreamingInputCall(ctx)
+	if err != nil {
+		t.Fatalf(".StreamingInputCall(_) = _, %v, want <nil>", err)
+	}
+	if err := stream.Send(&testpb.StreamingInputCallRequest{}); err != nil {
+		t.Fatalf("stream.Send(_) = %v, want <nil>", err)
+	}
+	if _, err := stream.CloseAndRecv(); err != nil {
+		t.Fatalf("stream.CloseAndRecv() = %v , want <nil>", err)
+	}
+	if _, err := stream.CloseAndRecv(); err != io.EOF {
+		t.Fatalf("stream.CloseAndRecv() = %v, want error %s", err, io.EOF)
+	}
+}
+
 // Tests that a client receives a cardinality violation error for unary
 // RPCs if the server doesn't send a message before returning status OK.
 func (s) TestUnaryRPC_ServerSendsOnlyTrailersWithOK(t *testing.T) {