// Code generated by smithy-go-codegen DO NOT EDIT.

//go:build response_snapshot

package sqs

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/sqs/types"
	smithyendpoints "github.com/aws/smithy-go/endpoints"
	"github.com/aws/smithy-go/middleware"
	"github.com/aws/smithy-go/ptr"
	smithytesting "github.com/aws/smithy-go/testing"
	smithyhttp "github.com/aws/smithy-go/transport/http"
	"io"
	"io/fs"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
	"testing"
)

const serdeRespSSPrefix = "response_snapshot"

func serdeRespSSPath(op string) string {
	return fmt.Sprintf("%s/%s.snap", serdeRespSSPrefix, op)
}

// serdeRespReadSnapshot parses a frozen wire response fixture: a status-code
// line, HTTP headers, a blank line, then the raw body.
func serdeRespReadSnapshot(op string) (int, http.Header, []byte, error) {
	raw, err := os.ReadFile(serdeRespSSPath(op))
	if err != nil {
		return 0, nil, nil, err
	}

	r := bufio.NewReader(bytes.NewReader(raw))
	statusLine, err := r.ReadString('\n')
	if err != nil {
		return 0, nil, nil, fmt.Errorf("read status line: %w", err)
	}
	status, err := strconv.Atoi(strings.TrimSpace(statusLine))
	if err != nil {
		return 0, nil, nil, fmt.Errorf("parse status: %w", err)
	}

	header := http.Header{}
	for {
		line, err := r.ReadString('\n')
		if err != nil && err != io.EOF {
			return 0, nil, nil, err
		}
		trimmed := strings.TrimRight(line, "\r\n")
		if trimmed == "" {
			break
		}
		k, v, ok := strings.Cut(trimmed, ": ")
		if !ok {
			return 0, nil, nil, fmt.Errorf("malformed header %q", trimmed)
		}
		header.Add(k, v)
		if err == io.EOF {
			break
		}
	}

	body, err := io.ReadAll(r)
	if err != nil {
		return 0, nil, nil, err
	}
	return status, header, body, nil
}

type serdeRespEndpointResolver struct{}

func (*serdeRespEndpointResolver) ResolveEndpoint(ctx context.Context, params EndpointParameters) (smithyendpoints.Endpoint, error) {
	return smithyendpoints.Endpoint{URI: url.URL{Scheme: "https", Host: "test.example.com"}}, nil
}

func serdeRespClient(status int, header http.Header, body []byte) *Client {
	return New(Options{
		Region: "us-east-1",
		HTTPClient: smithyhttp.ClientDoFunc(func(req *http.Request) (*http.Response, error) {
			resp := &http.Response{StatusCode: status, Header: header, Request: req}
			if len(body) > 0 {
				resp.ContentLength = int64(len(body))
				resp.Body = io.NopCloser(bytes.NewReader(body))
			} else {
				resp.Body = http.NoBody
			}
			return resp, nil
		}),
		EndpointResolverV2: &serdeRespEndpointResolver{},
		APIOptions: []func(*middleware.Stack) error{
			func(s *middleware.Stack) error {
				s.Finalize.Clear()
				s.Initialize.Remove("OperationInputValidation")
				return nil
			},
		},
	})
}
func TestCheckResponseSnapshot_AddPermission(t *testing.T) {
	want := &AddPermissionOutput{}
	status, header, body, err := serdeRespReadSnapshot("AddPermission.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AddPermission(context.Background(), &AddPermissionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AddPermission.response", err)
	}
}

func TestCheckResponseSnapshot_CancelMessageMoveTask(t *testing.T) {
	want := &CancelMessageMoveTaskOutput{
		ApproximateNumberOfMessagesMoved: 1,
	}
	status, header, body, err := serdeRespReadSnapshot("CancelMessageMoveTask.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CancelMessageMoveTask(context.Background(), &CancelMessageMoveTaskInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CancelMessageMoveTask.response", err)
	}
}

func TestCheckResponseSnapshot_ChangeMessageVisibility(t *testing.T) {
	want := &ChangeMessageVisibilityOutput{}
	status, header, body, err := serdeRespReadSnapshot("ChangeMessageVisibility.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ChangeMessageVisibility(context.Background(), &ChangeMessageVisibilityInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ChangeMessageVisibility.response", err)
	}
}

func TestCheckResponseSnapshot_ChangeMessageVisibilityBatch(t *testing.T) {
	want := &ChangeMessageVisibilityBatchOutput{
		Successful: []types.ChangeMessageVisibilityBatchResultEntry{
			{
				Id: ptr.String("__Id__"),
			},
			{
				Id: ptr.String("__Id__"),
			},
		},
		Failed: []types.BatchResultErrorEntry{
			{
				Id:          ptr.String("__Id__"),
				SenderFault: true,
				Code:        ptr.String("__Code__"),
				Message:     ptr.String("__Message__"),
			},
			{
				Id:          ptr.String("__Id__"),
				SenderFault: true,
				Code:        ptr.String("__Code__"),
				Message:     ptr.String("__Message__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ChangeMessageVisibilityBatch.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ChangeMessageVisibilityBatch(context.Background(), &ChangeMessageVisibilityBatchInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ChangeMessageVisibilityBatch.response", err)
	}
}

func TestCheckResponseSnapshot_CreateQueue(t *testing.T) {
	want := &CreateQueueOutput{
		QueueUrl: ptr.String("__QueueUrl__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateQueue.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateQueue(context.Background(), &CreateQueueInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateQueue.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteMessage(t *testing.T) {
	want := &DeleteMessageOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteMessage.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteMessage(context.Background(), &DeleteMessageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteMessage.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteMessageBatch(t *testing.T) {
	want := &DeleteMessageBatchOutput{
		Successful: []types.DeleteMessageBatchResultEntry{
			{
				Id: ptr.String("__Id__"),
			},
			{
				Id: ptr.String("__Id__"),
			},
		},
		Failed: []types.BatchResultErrorEntry{
			{
				Id:          ptr.String("__Id__"),
				SenderFault: true,
				Code:        ptr.String("__Code__"),
				Message:     ptr.String("__Message__"),
			},
			{
				Id:          ptr.String("__Id__"),
				SenderFault: true,
				Code:        ptr.String("__Code__"),
				Message:     ptr.String("__Message__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteMessageBatch.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteMessageBatch(context.Background(), &DeleteMessageBatchInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteMessageBatch.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteQueue(t *testing.T) {
	want := &DeleteQueueOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteQueue.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteQueue(context.Background(), &DeleteQueueInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteQueue.response", err)
	}
}

func TestCheckResponseSnapshot_GetQueueAttributes(t *testing.T) {
	want := &GetQueueAttributesOutput{
		Attributes: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetQueueAttributes.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetQueueAttributes(context.Background(), &GetQueueAttributesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetQueueAttributes.response", err)
	}
}

func TestCheckResponseSnapshot_GetQueueUrl(t *testing.T) {
	want := &GetQueueUrlOutput{
		QueueUrl: ptr.String("__QueueUrl__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetQueueUrl.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetQueueUrl(context.Background(), &GetQueueUrlInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetQueueUrl.response", err)
	}
}

func TestCheckResponseSnapshot_ListDeadLetterSourceQueues(t *testing.T) {
	want := &ListDeadLetterSourceQueuesOutput{
		QueueUrls: []string{
			"__Member__",
			"__Member__",
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListDeadLetterSourceQueues.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListDeadLetterSourceQueues(context.Background(), &ListDeadLetterSourceQueuesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListDeadLetterSourceQueues.response", err)
	}
}

func TestCheckResponseSnapshot_ListMessageMoveTasks(t *testing.T) {
	want := &ListMessageMoveTasksOutput{
		Results: []types.ListMessageMoveTasksResultEntry{
			{
				TaskHandle:                        ptr.String("__TaskHandle__"),
				Status:                            ptr.String("__Status__"),
				SourceArn:                         ptr.String("__SourceArn__"),
				DestinationArn:                    ptr.String("__DestinationArn__"),
				MaxNumberOfMessagesPerSecond:      ptr.Int32(1),
				ApproximateNumberOfMessagesMoved:  1,
				ApproximateNumberOfMessagesToMove: ptr.Int64(1),
				FailureReason:                     ptr.String("__FailureReason__"),
				StartedTimestamp:                  1,
			},
			{
				TaskHandle:                        ptr.String("__TaskHandle__"),
				Status:                            ptr.String("__Status__"),
				SourceArn:                         ptr.String("__SourceArn__"),
				DestinationArn:                    ptr.String("__DestinationArn__"),
				MaxNumberOfMessagesPerSecond:      ptr.Int32(1),
				ApproximateNumberOfMessagesMoved:  1,
				ApproximateNumberOfMessagesToMove: ptr.Int64(1),
				FailureReason:                     ptr.String("__FailureReason__"),
				StartedTimestamp:                  1,
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListMessageMoveTasks.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListMessageMoveTasks(context.Background(), &ListMessageMoveTasksInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListMessageMoveTasks.response", err)
	}
}

func TestCheckResponseSnapshot_ListQueueTags(t *testing.T) {
	want := &ListQueueTagsOutput{
		Tags: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListQueueTags.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListQueueTags(context.Background(), &ListQueueTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListQueueTags.response", err)
	}
}

func TestCheckResponseSnapshot_ListQueues(t *testing.T) {
	want := &ListQueuesOutput{
		QueueUrls: []string{
			"__Member__",
			"__Member__",
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListQueues.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListQueues(context.Background(), &ListQueuesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListQueues.response", err)
	}
}

func TestCheckResponseSnapshot_PurgeQueue(t *testing.T) {
	want := &PurgeQueueOutput{}
	status, header, body, err := serdeRespReadSnapshot("PurgeQueue.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PurgeQueue(context.Background(), &PurgeQueueInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PurgeQueue.response", err)
	}
}

func TestCheckResponseSnapshot_ReceiveMessage(t *testing.T) {
	want := &ReceiveMessageOutput{
		Messages: []types.Message{
			{
				MessageId:     ptr.String("__MessageId__"),
				ReceiptHandle: ptr.String("__ReceiptHandle__"),
				MD5OfBody:     ptr.String("__MD5OfBody__"),
				Body:          ptr.String("__Body__"),
				Attributes: map[string]string{
					"key0": "__Value__",
				},
				MD5OfMessageAttributes: ptr.String("__MD5OfMessageAttributes__"),
				MessageAttributes: map[string]types.MessageAttributeValue{
					"key0": {
						StringValue: ptr.String("__StringValue__"),
						BinaryValue: []byte("blob"),
						StringListValues: []string{
							"__Member__",
							"__Member__",
						},
						BinaryListValues: [][]byte{
							[]byte("blob"),
							[]byte("blob"),
						},
						DataType: ptr.String("__DataType__"),
					},
				},
			},
			{
				MessageId:     ptr.String("__MessageId__"),
				ReceiptHandle: ptr.String("__ReceiptHandle__"),
				MD5OfBody:     ptr.String("__MD5OfBody__"),
				Body:          ptr.String("__Body__"),
				Attributes: map[string]string{
					"key0": "__Value__",
				},
				MD5OfMessageAttributes: ptr.String("__MD5OfMessageAttributes__"),
				MessageAttributes: map[string]types.MessageAttributeValue{
					"key0": {
						StringValue: ptr.String("__StringValue__"),
						BinaryValue: []byte("blob"),
						StringListValues: []string{
							"__Member__",
							"__Member__",
						},
						BinaryListValues: [][]byte{
							[]byte("blob"),
							[]byte("blob"),
						},
						DataType: ptr.String("__DataType__"),
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ReceiveMessage.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ReceiveMessage(context.Background(), &ReceiveMessageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ReceiveMessage.response", err)
	}
}

func TestCheckResponseSnapshot_RemovePermission(t *testing.T) {
	want := &RemovePermissionOutput{}
	status, header, body, err := serdeRespReadSnapshot("RemovePermission.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.RemovePermission(context.Background(), &RemovePermissionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RemovePermission.response", err)
	}
}

func TestCheckResponseSnapshot_SendMessage(t *testing.T) {
	want := &SendMessageOutput{
		MD5OfMessageBody:             ptr.String("__MD5OfMessageBody__"),
		MD5OfMessageAttributes:       ptr.String("__MD5OfMessageAttributes__"),
		MD5OfMessageSystemAttributes: ptr.String("__MD5OfMessageSystemAttributes__"),
		MessageId:                    ptr.String("__MessageId__"),
		SequenceNumber:               ptr.String("__SequenceNumber__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SendMessage.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.SendMessage(context.Background(), &SendMessageInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "SendMessage.response", err)
	}
}

func TestCheckResponseSnapshot_SendMessageBatch(t *testing.T) {
	want := &SendMessageBatchOutput{
		Successful: []types.SendMessageBatchResultEntry{
			{
				Id:                           ptr.String("__Id__"),
				MessageId:                    ptr.String("__MessageId__"),
				MD5OfMessageBody:             ptr.String("__MD5OfMessageBody__"),
				MD5OfMessageAttributes:       ptr.String("__MD5OfMessageAttributes__"),
				MD5OfMessageSystemAttributes: ptr.String("__MD5OfMessageSystemAttributes__"),
				SequenceNumber:               ptr.String("__SequenceNumber__"),
			},
			{
				Id:                           ptr.String("__Id__"),
				MessageId:                    ptr.String("__MessageId__"),
				MD5OfMessageBody:             ptr.String("__MD5OfMessageBody__"),
				MD5OfMessageAttributes:       ptr.String("__MD5OfMessageAttributes__"),
				MD5OfMessageSystemAttributes: ptr.String("__MD5OfMessageSystemAttributes__"),
				SequenceNumber:               ptr.String("__SequenceNumber__"),
			},
		},
		Failed: []types.BatchResultErrorEntry{
			{
				Id:          ptr.String("__Id__"),
				SenderFault: true,
				Code:        ptr.String("__Code__"),
				Message:     ptr.String("__Message__"),
			},
			{
				Id:          ptr.String("__Id__"),
				SenderFault: true,
				Code:        ptr.String("__Code__"),
				Message:     ptr.String("__Message__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("SendMessageBatch.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.SendMessageBatch(context.Background(), &SendMessageBatchInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "SendMessageBatch.response", err)
	}
}

func TestCheckResponseSnapshot_SetQueueAttributes(t *testing.T) {
	want := &SetQueueAttributesOutput{}
	status, header, body, err := serdeRespReadSnapshot("SetQueueAttributes.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.SetQueueAttributes(context.Background(), &SetQueueAttributesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "SetQueueAttributes.response", err)
	}
}

func TestCheckResponseSnapshot_StartMessageMoveTask(t *testing.T) {
	want := &StartMessageMoveTaskOutput{
		TaskHandle: ptr.String("__TaskHandle__"),
	}
	status, header, body, err := serdeRespReadSnapshot("StartMessageMoveTask.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.StartMessageMoveTask(context.Background(), &StartMessageMoveTaskInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartMessageMoveTask.response", err)
	}
}

func TestCheckResponseSnapshot_TagQueue(t *testing.T) {
	want := &TagQueueOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagQueue.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.TagQueue(context.Background(), &TagQueueInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagQueue.response", err)
	}
}

func TestCheckResponseSnapshot_UntagQueue(t *testing.T) {
	want := &UntagQueueOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagQueue.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UntagQueue(context.Background(), &UntagQueueInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagQueue.response", err)
	}
}

func TestCheckResponseSnapshot_Error_BatchEntryIdsNotDistinct(t *testing.T) {
	want := &types.BatchEntryIdsNotDistinct{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BatchEntryIdsNotDistinct.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ChangeMessageVisibilityBatch(context.Background(), &ChangeMessageVisibilityBatchInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BatchEntryIdsNotDistinct
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BatchEntryIdsNotDistinct, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BatchEntryIdsNotDistinct.error", err)
	}
}

func TestCheckResponseSnapshot_Error_BatchRequestTooLong(t *testing.T) {
	want := &types.BatchRequestTooLong{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("BatchRequestTooLong.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.SendMessageBatch(context.Background(), &SendMessageBatchInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.BatchRequestTooLong
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.BatchRequestTooLong, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "BatchRequestTooLong.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EmptyBatchRequest(t *testing.T) {
	want := &types.EmptyBatchRequest{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EmptyBatchRequest.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ChangeMessageVisibilityBatch(context.Background(), &ChangeMessageVisibilityBatchInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EmptyBatchRequest
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EmptyBatchRequest, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EmptyBatchRequest.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidAddress(t *testing.T) {
	want := &types.InvalidAddress{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidAddress.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AddPermission(context.Background(), &AddPermissionInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidAddress
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidAddress, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidAddress.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidAttributeName(t *testing.T) {
	want := &types.InvalidAttributeName{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidAttributeName.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateQueue(context.Background(), &CreateQueueInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidAttributeName
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidAttributeName, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidAttributeName.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidAttributeValue(t *testing.T) {
	want := &types.InvalidAttributeValue{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidAttributeValue.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateQueue(context.Background(), &CreateQueueInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidAttributeValue
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidAttributeValue, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidAttributeValue.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidBatchEntryId(t *testing.T) {
	want := &types.InvalidBatchEntryId{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidBatchEntryId.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ChangeMessageVisibilityBatch(context.Background(), &ChangeMessageVisibilityBatchInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidBatchEntryId
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidBatchEntryId, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidBatchEntryId.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidIdFormat(t *testing.T) {
	want := &types.InvalidIdFormat{}
	status, header, body, err := serdeRespReadSnapshot("InvalidIdFormat.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.DeleteMessage(context.Background(), &DeleteMessageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidIdFormat
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidIdFormat, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidIdFormat.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidMessageContents(t *testing.T) {
	want := &types.InvalidMessageContents{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidMessageContents.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.SendMessage(context.Background(), &SendMessageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidMessageContents
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidMessageContents, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidMessageContents.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidSecurity(t *testing.T) {
	want := &types.InvalidSecurity{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidSecurity.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AddPermission(context.Background(), &AddPermissionInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidSecurity
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidSecurity, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidSecurity.error", err)
	}
}

func TestCheckResponseSnapshot_Error_KmsAccessDenied(t *testing.T) {
	want := &types.KmsAccessDenied{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("KmsAccessDenied.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ReceiveMessage(context.Background(), &ReceiveMessageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.KmsAccessDenied
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.KmsAccessDenied, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "KmsAccessDenied.error", err)
	}
}

func TestCheckResponseSnapshot_Error_KmsDisabled(t *testing.T) {
	want := &types.KmsDisabled{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("KmsDisabled.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ReceiveMessage(context.Background(), &ReceiveMessageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.KmsDisabled
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.KmsDisabled, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "KmsDisabled.error", err)
	}
}

func TestCheckResponseSnapshot_Error_KmsInvalidKeyUsage(t *testing.T) {
	want := &types.KmsInvalidKeyUsage{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("KmsInvalidKeyUsage.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ReceiveMessage(context.Background(), &ReceiveMessageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.KmsInvalidKeyUsage
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.KmsInvalidKeyUsage, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "KmsInvalidKeyUsage.error", err)
	}
}

func TestCheckResponseSnapshot_Error_KmsInvalidState(t *testing.T) {
	want := &types.KmsInvalidState{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("KmsInvalidState.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ReceiveMessage(context.Background(), &ReceiveMessageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.KmsInvalidState
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.KmsInvalidState, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "KmsInvalidState.error", err)
	}
}

func TestCheckResponseSnapshot_Error_KmsNotFound(t *testing.T) {
	want := &types.KmsNotFound{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("KmsNotFound.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ReceiveMessage(context.Background(), &ReceiveMessageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.KmsNotFound
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.KmsNotFound, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "KmsNotFound.error", err)
	}
}

func TestCheckResponseSnapshot_Error_KmsOptInRequired(t *testing.T) {
	want := &types.KmsOptInRequired{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("KmsOptInRequired.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ReceiveMessage(context.Background(), &ReceiveMessageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.KmsOptInRequired
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.KmsOptInRequired, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "KmsOptInRequired.error", err)
	}
}

func TestCheckResponseSnapshot_Error_KmsThrottled(t *testing.T) {
	want := &types.KmsThrottled{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("KmsThrottled.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ReceiveMessage(context.Background(), &ReceiveMessageInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.KmsThrottled
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.KmsThrottled, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "KmsThrottled.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MessageNotInflight(t *testing.T) {
	want := &types.MessageNotInflight{}
	status, header, body, err := serdeRespReadSnapshot("MessageNotInflight.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ChangeMessageVisibility(context.Background(), &ChangeMessageVisibilityInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MessageNotInflight
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MessageNotInflight, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MessageNotInflight.error", err)
	}
}

func TestCheckResponseSnapshot_Error_OverLimit(t *testing.T) {
	want := &types.OverLimit{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("OverLimit.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AddPermission(context.Background(), &AddPermissionInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.OverLimit
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.OverLimit, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "OverLimit.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PurgeQueueInProgress(t *testing.T) {
	want := &types.PurgeQueueInProgress{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PurgeQueueInProgress.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.PurgeQueue(context.Background(), &PurgeQueueInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PurgeQueueInProgress
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PurgeQueueInProgress, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PurgeQueueInProgress.error", err)
	}
}

func TestCheckResponseSnapshot_Error_QueueDeletedRecently(t *testing.T) {
	want := &types.QueueDeletedRecently{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("QueueDeletedRecently.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateQueue(context.Background(), &CreateQueueInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.QueueDeletedRecently
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.QueueDeletedRecently, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "QueueDeletedRecently.error", err)
	}
}

func TestCheckResponseSnapshot_Error_QueueDoesNotExist(t *testing.T) {
	want := &types.QueueDoesNotExist{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("QueueDoesNotExist.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AddPermission(context.Background(), &AddPermissionInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.QueueDoesNotExist
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.QueueDoesNotExist, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "QueueDoesNotExist.error", err)
	}
}

func TestCheckResponseSnapshot_Error_QueueNameExists(t *testing.T) {
	want := &types.QueueNameExists{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("QueueNameExists.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateQueue(context.Background(), &CreateQueueInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.QueueNameExists
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.QueueNameExists, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "QueueNameExists.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ReceiptHandleIsInvalid(t *testing.T) {
	want := &types.ReceiptHandleIsInvalid{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ReceiptHandleIsInvalid.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ChangeMessageVisibility(context.Background(), &ChangeMessageVisibilityInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ReceiptHandleIsInvalid
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ReceiptHandleIsInvalid, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ReceiptHandleIsInvalid.error", err)
	}
}

func TestCheckResponseSnapshot_Error_RequestThrottled(t *testing.T) {
	want := &types.RequestThrottled{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("RequestThrottled.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AddPermission(context.Background(), &AddPermissionInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.RequestThrottled
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.RequestThrottled, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "RequestThrottled.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ResourceNotFoundException(t *testing.T) {
	want := &types.ResourceNotFoundException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ResourceNotFoundException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CancelMessageMoveTask(context.Background(), &CancelMessageMoveTaskInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ResourceNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ResourceNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ResourceNotFoundException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TooManyEntriesInBatchRequest(t *testing.T) {
	want := &types.TooManyEntriesInBatchRequest{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("TooManyEntriesInBatchRequest.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ChangeMessageVisibilityBatch(context.Background(), &ChangeMessageVisibilityBatchInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TooManyEntriesInBatchRequest
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TooManyEntriesInBatchRequest, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TooManyEntriesInBatchRequest.error", err)
	}
}

func TestCheckResponseSnapshot_Error_UnsupportedOperation(t *testing.T) {
	want := &types.UnsupportedOperation{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UnsupportedOperation.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AddPermission(context.Background(), &AddPermissionInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UnsupportedOperation
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UnsupportedOperation, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UnsupportedOperation.error", err)
	}
}