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

//go:build response_snapshot

package athena

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/athena/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"
	"time"
)

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_BatchGetNamedQuery(t *testing.T) {
	want := &BatchGetNamedQueryOutput{
		NamedQueries: []types.NamedQuery{
			{
				Name:         ptr.String("__Name__"),
				Description:  ptr.String("__Description__"),
				Database:     ptr.String("__Database__"),
				QueryString:  ptr.String("__QueryString__"),
				NamedQueryId: ptr.String("__NamedQueryId__"),
				WorkGroup:    ptr.String("__WorkGroup__"),
			},
			{
				Name:         ptr.String("__Name__"),
				Description:  ptr.String("__Description__"),
				Database:     ptr.String("__Database__"),
				QueryString:  ptr.String("__QueryString__"),
				NamedQueryId: ptr.String("__NamedQueryId__"),
				WorkGroup:    ptr.String("__WorkGroup__"),
			},
		},
		UnprocessedNamedQueryIds: []types.UnprocessedNamedQueryId{
			{
				NamedQueryId: ptr.String("__NamedQueryId__"),
				ErrorCode:    ptr.String("__ErrorCode__"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
			{
				NamedQueryId: ptr.String("__NamedQueryId__"),
				ErrorCode:    ptr.String("__ErrorCode__"),
				ErrorMessage: ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchGetNamedQuery.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.BatchGetNamedQuery(context.Background(), &BatchGetNamedQueryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchGetNamedQuery.response", err)
	}
}

func TestCheckResponseSnapshot_BatchGetPreparedStatement(t *testing.T) {
	want := &BatchGetPreparedStatementOutput{
		PreparedStatements: []types.PreparedStatement{
			{
				StatementName:    ptr.String("__StatementName__"),
				QueryStatement:   ptr.String("__QueryStatement__"),
				WorkGroupName:    ptr.String("__WorkGroupName__"),
				Description:      ptr.String("__Description__"),
				LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				StatementName:    ptr.String("__StatementName__"),
				QueryStatement:   ptr.String("__QueryStatement__"),
				WorkGroupName:    ptr.String("__WorkGroupName__"),
				Description:      ptr.String("__Description__"),
				LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		UnprocessedPreparedStatementNames: []types.UnprocessedPreparedStatementName{
			{
				StatementName: ptr.String("__StatementName__"),
				ErrorCode:     ptr.String("__ErrorCode__"),
				ErrorMessage:  ptr.String("__ErrorMessage__"),
			},
			{
				StatementName: ptr.String("__StatementName__"),
				ErrorCode:     ptr.String("__ErrorCode__"),
				ErrorMessage:  ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchGetPreparedStatement.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.BatchGetPreparedStatement(context.Background(), &BatchGetPreparedStatementInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchGetPreparedStatement.response", err)
	}
}

func TestCheckResponseSnapshot_BatchGetQueryExecution(t *testing.T) {
	want := &BatchGetQueryExecutionOutput{
		QueryExecutions: []types.QueryExecution{
			{
				QueryExecutionId: ptr.String("__QueryExecutionId__"),
				Query:            ptr.String("__Query__"),
				StatementType:    types.StatementType("DDL"),
				ManagedQueryResultsConfiguration: &types.ManagedQueryResultsConfiguration{
					Enabled: true,
					EncryptionConfiguration: &types.ManagedQueryResultsEncryptionConfiguration{
						KmsKey: ptr.String("__KmsKey__"),
					},
				},
				ResultConfiguration: &types.ResultConfiguration{
					OutputLocation: ptr.String("__OutputLocation__"),
					EncryptionConfiguration: &types.EncryptionConfiguration{
						EncryptionOption: types.EncryptionOption("SSE_S3"),
						KmsKey:           ptr.String("__KmsKey__"),
					},
					ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
					AclConfiguration: &types.AclConfiguration{
						S3AclOption: types.S3AclOption("BUCKET_OWNER_FULL_CONTROL"),
					},
				},
				ResultReuseConfiguration: &types.ResultReuseConfiguration{
					ResultReuseByAgeConfiguration: &types.ResultReuseByAgeConfiguration{
						Enabled:         true,
						MaxAgeInMinutes: ptr.Int32(1),
					},
				},
				QueryExecutionContext: &types.QueryExecutionContext{
					Database: ptr.String("__Database__"),
					Catalog:  ptr.String("__Catalog__"),
				},
				Status: &types.QueryExecutionStatus{
					State:              types.QueryExecutionState("QUEUED"),
					StateChangeReason:  ptr.String("__StateChangeReason__"),
					SubmissionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CompletionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					AthenaError: &types.AthenaError{
						ErrorCategory: ptr.Int32(1),
						ErrorType:     ptr.Int32(1),
						Retryable:     true,
						ErrorMessage:  ptr.String("__ErrorMessage__"),
					},
				},
				Statistics: &types.QueryExecutionStatistics{
					EngineExecutionTimeInMillis:      ptr.Int64(1),
					DataScannedInBytes:               ptr.Int64(1),
					DataManifestLocation:             ptr.String("__DataManifestLocation__"),
					TotalExecutionTimeInMillis:       ptr.Int64(1),
					QueryQueueTimeInMillis:           ptr.Int64(1),
					ServicePreProcessingTimeInMillis: ptr.Int64(1),
					QueryPlanningTimeInMillis:        ptr.Int64(1),
					ServiceProcessingTimeInMillis:    ptr.Int64(1),
					ResultReuseInformation: &types.ResultReuseInformation{
						ReusedPreviousResult: true,
					},
					DpuCount: ptr.Float64(1.0),
				},
				WorkGroup: ptr.String("__WorkGroup__"),
				EngineVersion: &types.EngineVersion{
					SelectedEngineVersion:  ptr.String("__SelectedEngineVersion__"),
					EffectiveEngineVersion: ptr.String("__EffectiveEngineVersion__"),
				},
				ExecutionParameters: []string{
					"__Member__",
					"__Member__",
				},
				SubstatementType: ptr.String("__SubstatementType__"),
				QueryResultsS3AccessGrantsConfiguration: &types.QueryResultsS3AccessGrantsConfiguration{
					EnableS3AccessGrants:  ptr.Bool(true),
					CreateUserLevelPrefix: ptr.Bool(true),
					AuthenticationType:    types.AuthenticationType("DIRECTORY_IDENTITY"),
				},
			},
			{
				QueryExecutionId: ptr.String("__QueryExecutionId__"),
				Query:            ptr.String("__Query__"),
				StatementType:    types.StatementType("DDL"),
				ManagedQueryResultsConfiguration: &types.ManagedQueryResultsConfiguration{
					Enabled: true,
					EncryptionConfiguration: &types.ManagedQueryResultsEncryptionConfiguration{
						KmsKey: ptr.String("__KmsKey__"),
					},
				},
				ResultConfiguration: &types.ResultConfiguration{
					OutputLocation: ptr.String("__OutputLocation__"),
					EncryptionConfiguration: &types.EncryptionConfiguration{
						EncryptionOption: types.EncryptionOption("SSE_S3"),
						KmsKey:           ptr.String("__KmsKey__"),
					},
					ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
					AclConfiguration: &types.AclConfiguration{
						S3AclOption: types.S3AclOption("BUCKET_OWNER_FULL_CONTROL"),
					},
				},
				ResultReuseConfiguration: &types.ResultReuseConfiguration{
					ResultReuseByAgeConfiguration: &types.ResultReuseByAgeConfiguration{
						Enabled:         true,
						MaxAgeInMinutes: ptr.Int32(1),
					},
				},
				QueryExecutionContext: &types.QueryExecutionContext{
					Database: ptr.String("__Database__"),
					Catalog:  ptr.String("__Catalog__"),
				},
				Status: &types.QueryExecutionStatus{
					State:              types.QueryExecutionState("QUEUED"),
					StateChangeReason:  ptr.String("__StateChangeReason__"),
					SubmissionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CompletionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					AthenaError: &types.AthenaError{
						ErrorCategory: ptr.Int32(1),
						ErrorType:     ptr.Int32(1),
						Retryable:     true,
						ErrorMessage:  ptr.String("__ErrorMessage__"),
					},
				},
				Statistics: &types.QueryExecutionStatistics{
					EngineExecutionTimeInMillis:      ptr.Int64(1),
					DataScannedInBytes:               ptr.Int64(1),
					DataManifestLocation:             ptr.String("__DataManifestLocation__"),
					TotalExecutionTimeInMillis:       ptr.Int64(1),
					QueryQueueTimeInMillis:           ptr.Int64(1),
					ServicePreProcessingTimeInMillis: ptr.Int64(1),
					QueryPlanningTimeInMillis:        ptr.Int64(1),
					ServiceProcessingTimeInMillis:    ptr.Int64(1),
					ResultReuseInformation: &types.ResultReuseInformation{
						ReusedPreviousResult: true,
					},
					DpuCount: ptr.Float64(1.0),
				},
				WorkGroup: ptr.String("__WorkGroup__"),
				EngineVersion: &types.EngineVersion{
					SelectedEngineVersion:  ptr.String("__SelectedEngineVersion__"),
					EffectiveEngineVersion: ptr.String("__EffectiveEngineVersion__"),
				},
				ExecutionParameters: []string{
					"__Member__",
					"__Member__",
				},
				SubstatementType: ptr.String("__SubstatementType__"),
				QueryResultsS3AccessGrantsConfiguration: &types.QueryResultsS3AccessGrantsConfiguration{
					EnableS3AccessGrants:  ptr.Bool(true),
					CreateUserLevelPrefix: ptr.Bool(true),
					AuthenticationType:    types.AuthenticationType("DIRECTORY_IDENTITY"),
				},
			},
		},
		UnprocessedQueryExecutionIds: []types.UnprocessedQueryExecutionId{
			{
				QueryExecutionId: ptr.String("__QueryExecutionId__"),
				ErrorCode:        ptr.String("__ErrorCode__"),
				ErrorMessage:     ptr.String("__ErrorMessage__"),
			},
			{
				QueryExecutionId: ptr.String("__QueryExecutionId__"),
				ErrorCode:        ptr.String("__ErrorCode__"),
				ErrorMessage:     ptr.String("__ErrorMessage__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("BatchGetQueryExecution.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.BatchGetQueryExecution(context.Background(), &BatchGetQueryExecutionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "BatchGetQueryExecution.response", err)
	}
}

func TestCheckResponseSnapshot_CancelCapacityReservation(t *testing.T) {
	want := &CancelCapacityReservationOutput{}
	status, header, body, err := serdeRespReadSnapshot("CancelCapacityReservation.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.CancelCapacityReservation(context.Background(), &CancelCapacityReservationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CancelCapacityReservation.response", err)
	}
}

func TestCheckResponseSnapshot_CreateCapacityReservation(t *testing.T) {
	want := &CreateCapacityReservationOutput{}
	status, header, body, err := serdeRespReadSnapshot("CreateCapacityReservation.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.CreateCapacityReservation(context.Background(), &CreateCapacityReservationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateCapacityReservation.response", err)
	}
}

func TestCheckResponseSnapshot_CreateDataCatalog(t *testing.T) {
	want := &CreateDataCatalogOutput{
		DataCatalog: &types.DataCatalog{
			Name:        ptr.String("__Name__"),
			Description: ptr.String("__Description__"),
			Type:        types.DataCatalogType("LAMBDA"),
			Parameters: map[string]string{
				"key0": "__Value__",
			},
			Status:         types.DataCatalogStatus("CREATE_IN_PROGRESS"),
			ConnectionType: types.ConnectionType("DYNAMODB"),
			Error:          ptr.String("__Error__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateDataCatalog.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.CreateDataCatalog(context.Background(), &CreateDataCatalogInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateDataCatalog.response", err)
	}
}

func TestCheckResponseSnapshot_CreateNamedQuery(t *testing.T) {
	want := &CreateNamedQueryOutput{
		NamedQueryId: ptr.String("__NamedQueryId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateNamedQuery.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.CreateNamedQuery(context.Background(), &CreateNamedQueryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateNamedQuery.response", err)
	}
}

func TestCheckResponseSnapshot_CreateNotebook(t *testing.T) {
	want := &CreateNotebookOutput{
		NotebookId: ptr.String("__NotebookId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateNotebook.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.CreateNotebook(context.Background(), &CreateNotebookInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateNotebook.response", err)
	}
}

func TestCheckResponseSnapshot_CreatePreparedStatement(t *testing.T) {
	want := &CreatePreparedStatementOutput{}
	status, header, body, err := serdeRespReadSnapshot("CreatePreparedStatement.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.CreatePreparedStatement(context.Background(), &CreatePreparedStatementInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreatePreparedStatement.response", err)
	}
}

func TestCheckResponseSnapshot_CreatePresignedNotebookUrl(t *testing.T) {
	want := &CreatePresignedNotebookUrlOutput{
		NotebookUrl:             ptr.String("__NotebookUrl__"),
		AuthToken:               ptr.String("__AuthToken__"),
		AuthTokenExpirationTime: ptr.Int64(1),
	}
	status, header, body, err := serdeRespReadSnapshot("CreatePresignedNotebookUrl.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.CreatePresignedNotebookUrl(context.Background(), &CreatePresignedNotebookUrlInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreatePresignedNotebookUrl.response", err)
	}
}

func TestCheckResponseSnapshot_CreateWorkGroup(t *testing.T) {
	want := &CreateWorkGroupOutput{}
	status, header, body, err := serdeRespReadSnapshot("CreateWorkGroup.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.CreateWorkGroup(context.Background(), &CreateWorkGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateWorkGroup.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteCapacityReservation(t *testing.T) {
	want := &DeleteCapacityReservationOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteCapacityReservation.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.DeleteCapacityReservation(context.Background(), &DeleteCapacityReservationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteCapacityReservation.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteDataCatalog(t *testing.T) {
	want := &DeleteDataCatalogOutput{
		DataCatalog: &types.DataCatalog{
			Name:        ptr.String("__Name__"),
			Description: ptr.String("__Description__"),
			Type:        types.DataCatalogType("LAMBDA"),
			Parameters: map[string]string{
				"key0": "__Value__",
			},
			Status:         types.DataCatalogStatus("CREATE_IN_PROGRESS"),
			ConnectionType: types.ConnectionType("DYNAMODB"),
			Error:          ptr.String("__Error__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteDataCatalog.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.DeleteDataCatalog(context.Background(), &DeleteDataCatalogInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteDataCatalog.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteNamedQuery(t *testing.T) {
	want := &DeleteNamedQueryOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteNamedQuery.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.DeleteNamedQuery(context.Background(), &DeleteNamedQueryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteNamedQuery.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteNotebook(t *testing.T) {
	want := &DeleteNotebookOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteNotebook.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.DeleteNotebook(context.Background(), &DeleteNotebookInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteNotebook.response", err)
	}
}

func TestCheckResponseSnapshot_DeletePreparedStatement(t *testing.T) {
	want := &DeletePreparedStatementOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeletePreparedStatement.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.DeletePreparedStatement(context.Background(), &DeletePreparedStatementInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeletePreparedStatement.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteWorkGroup(t *testing.T) {
	want := &DeleteWorkGroupOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteWorkGroup.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.DeleteWorkGroup(context.Background(), &DeleteWorkGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteWorkGroup.response", err)
	}
}

func TestCheckResponseSnapshot_ExportNotebook(t *testing.T) {
	want := &ExportNotebookOutput{
		NotebookMetadata: &types.NotebookMetadata{
			NotebookId:       ptr.String("__NotebookId__"),
			Name:             ptr.String("__Name__"),
			WorkGroup:        ptr.String("__WorkGroup__"),
			CreationTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Type:             types.NotebookType("IPYNB"),
			LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		Payload: ptr.String("__Payload__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ExportNotebook.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.ExportNotebook(context.Background(), &ExportNotebookInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ExportNotebook.response", err)
	}
}

func TestCheckResponseSnapshot_GetCalculationExecution(t *testing.T) {
	want := &GetCalculationExecutionOutput{
		CalculationExecutionId: ptr.String("__CalculationExecutionId__"),
		SessionId:              ptr.String("__SessionId__"),
		Description:            ptr.String("__Description__"),
		WorkingDirectory:       ptr.String("__WorkingDirectory__"),
		Status: &types.CalculationStatus{
			SubmissionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CompletionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			State:              types.CalculationExecutionState("CREATING"),
			StateChangeReason:  ptr.String("__StateChangeReason__"),
		},
		Statistics: &types.CalculationStatistics{
			DpuExecutionInMillis: ptr.Int64(1),
			Progress:             ptr.String("__Progress__"),
		},
		Result: &types.CalculationResult{
			StdOutS3Uri:   ptr.String("__StdOutS3Uri__"),
			StdErrorS3Uri: ptr.String("__StdErrorS3Uri__"),
			ResultS3Uri:   ptr.String("__ResultS3Uri__"),
			ResultType:    ptr.String("__ResultType__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetCalculationExecution.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.GetCalculationExecution(context.Background(), &GetCalculationExecutionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCalculationExecution.response", err)
	}
}

func TestCheckResponseSnapshot_GetCalculationExecutionCode(t *testing.T) {
	want := &GetCalculationExecutionCodeOutput{
		CodeBlock: ptr.String("__CodeBlock__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetCalculationExecutionCode.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.GetCalculationExecutionCode(context.Background(), &GetCalculationExecutionCodeInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCalculationExecutionCode.response", err)
	}
}

func TestCheckResponseSnapshot_GetCalculationExecutionStatus(t *testing.T) {
	want := &GetCalculationExecutionStatusOutput{
		Status: &types.CalculationStatus{
			SubmissionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CompletionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			State:              types.CalculationExecutionState("CREATING"),
			StateChangeReason:  ptr.String("__StateChangeReason__"),
		},
		Statistics: &types.CalculationStatistics{
			DpuExecutionInMillis: ptr.Int64(1),
			Progress:             ptr.String("__Progress__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetCalculationExecutionStatus.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.GetCalculationExecutionStatus(context.Background(), &GetCalculationExecutionStatusInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCalculationExecutionStatus.response", err)
	}
}

func TestCheckResponseSnapshot_GetCapacityAssignmentConfiguration(t *testing.T) {
	want := &GetCapacityAssignmentConfigurationOutput{
		CapacityAssignmentConfiguration: &types.CapacityAssignmentConfiguration{
			CapacityReservationName: ptr.String("__CapacityReservationName__"),
			CapacityAssignments: []types.CapacityAssignment{
				{
					WorkGroupNames: []string{
						"__Member__",
						"__Member__",
					},
				},
				{
					WorkGroupNames: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetCapacityAssignmentConfiguration.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.GetCapacityAssignmentConfiguration(context.Background(), &GetCapacityAssignmentConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCapacityAssignmentConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_GetCapacityReservation(t *testing.T) {
	want := &GetCapacityReservationOutput{
		CapacityReservation: &types.CapacityReservation{
			Name:          ptr.String("__Name__"),
			Status:        types.CapacityReservationStatus("PENDING"),
			TargetDpus:    ptr.Int32(1),
			AllocatedDpus: ptr.Int32(1),
			LastAllocation: &types.CapacityAllocation{
				Status:                types.CapacityAllocationStatus("PENDING"),
				StatusMessage:         ptr.String("__StatusMessage__"),
				RequestTime:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RequestCompletionTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			LastSuccessfulAllocationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			CreationTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetCapacityReservation.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.GetCapacityReservation(context.Background(), &GetCapacityReservationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCapacityReservation.response", err)
	}
}

func TestCheckResponseSnapshot_GetDataCatalog(t *testing.T) {
	want := &GetDataCatalogOutput{
		DataCatalog: &types.DataCatalog{
			Name:        ptr.String("__Name__"),
			Description: ptr.String("__Description__"),
			Type:        types.DataCatalogType("LAMBDA"),
			Parameters: map[string]string{
				"key0": "__Value__",
			},
			Status:         types.DataCatalogStatus("CREATE_IN_PROGRESS"),
			ConnectionType: types.ConnectionType("DYNAMODB"),
			Error:          ptr.String("__Error__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetDataCatalog.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.GetDataCatalog(context.Background(), &GetDataCatalogInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDataCatalog.response", err)
	}
}

func TestCheckResponseSnapshot_GetDatabase(t *testing.T) {
	want := &GetDatabaseOutput{
		Database: &types.Database{
			Name:        ptr.String("__Name__"),
			Description: ptr.String("__Description__"),
			Parameters: map[string]string{
				"key0": "__Value__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetDatabase.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.GetDatabase(context.Background(), &GetDatabaseInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDatabase.response", err)
	}
}

func TestCheckResponseSnapshot_GetNamedQuery(t *testing.T) {
	want := &GetNamedQueryOutput{
		NamedQuery: &types.NamedQuery{
			Name:         ptr.String("__Name__"),
			Description:  ptr.String("__Description__"),
			Database:     ptr.String("__Database__"),
			QueryString:  ptr.String("__QueryString__"),
			NamedQueryId: ptr.String("__NamedQueryId__"),
			WorkGroup:    ptr.String("__WorkGroup__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetNamedQuery.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.GetNamedQuery(context.Background(), &GetNamedQueryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetNamedQuery.response", err)
	}
}

func TestCheckResponseSnapshot_GetNotebookMetadata(t *testing.T) {
	want := &GetNotebookMetadataOutput{
		NotebookMetadata: &types.NotebookMetadata{
			NotebookId:       ptr.String("__NotebookId__"),
			Name:             ptr.String("__Name__"),
			WorkGroup:        ptr.String("__WorkGroup__"),
			CreationTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Type:             types.NotebookType("IPYNB"),
			LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetNotebookMetadata.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.GetNotebookMetadata(context.Background(), &GetNotebookMetadataInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetNotebookMetadata.response", err)
	}
}

func TestCheckResponseSnapshot_GetPreparedStatement(t *testing.T) {
	want := &GetPreparedStatementOutput{
		PreparedStatement: &types.PreparedStatement{
			StatementName:    ptr.String("__StatementName__"),
			QueryStatement:   ptr.String("__QueryStatement__"),
			WorkGroupName:    ptr.String("__WorkGroupName__"),
			Description:      ptr.String("__Description__"),
			LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetPreparedStatement.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.GetPreparedStatement(context.Background(), &GetPreparedStatementInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPreparedStatement.response", err)
	}
}

func TestCheckResponseSnapshot_GetQueryExecution(t *testing.T) {
	want := &GetQueryExecutionOutput{
		QueryExecution: &types.QueryExecution{
			QueryExecutionId: ptr.String("__QueryExecutionId__"),
			Query:            ptr.String("__Query__"),
			StatementType:    types.StatementType("DDL"),
			ManagedQueryResultsConfiguration: &types.ManagedQueryResultsConfiguration{
				Enabled: true,
				EncryptionConfiguration: &types.ManagedQueryResultsEncryptionConfiguration{
					KmsKey: ptr.String("__KmsKey__"),
				},
			},
			ResultConfiguration: &types.ResultConfiguration{
				OutputLocation: ptr.String("__OutputLocation__"),
				EncryptionConfiguration: &types.EncryptionConfiguration{
					EncryptionOption: types.EncryptionOption("SSE_S3"),
					KmsKey:           ptr.String("__KmsKey__"),
				},
				ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
				AclConfiguration: &types.AclConfiguration{
					S3AclOption: types.S3AclOption("BUCKET_OWNER_FULL_CONTROL"),
				},
			},
			ResultReuseConfiguration: &types.ResultReuseConfiguration{
				ResultReuseByAgeConfiguration: &types.ResultReuseByAgeConfiguration{
					Enabled:         true,
					MaxAgeInMinutes: ptr.Int32(1),
				},
			},
			QueryExecutionContext: &types.QueryExecutionContext{
				Database: ptr.String("__Database__"),
				Catalog:  ptr.String("__Catalog__"),
			},
			Status: &types.QueryExecutionStatus{
				State:              types.QueryExecutionState("QUEUED"),
				StateChangeReason:  ptr.String("__StateChangeReason__"),
				SubmissionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CompletionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AthenaError: &types.AthenaError{
					ErrorCategory: ptr.Int32(1),
					ErrorType:     ptr.Int32(1),
					Retryable:     true,
					ErrorMessage:  ptr.String("__ErrorMessage__"),
				},
			},
			Statistics: &types.QueryExecutionStatistics{
				EngineExecutionTimeInMillis:      ptr.Int64(1),
				DataScannedInBytes:               ptr.Int64(1),
				DataManifestLocation:             ptr.String("__DataManifestLocation__"),
				TotalExecutionTimeInMillis:       ptr.Int64(1),
				QueryQueueTimeInMillis:           ptr.Int64(1),
				ServicePreProcessingTimeInMillis: ptr.Int64(1),
				QueryPlanningTimeInMillis:        ptr.Int64(1),
				ServiceProcessingTimeInMillis:    ptr.Int64(1),
				ResultReuseInformation: &types.ResultReuseInformation{
					ReusedPreviousResult: true,
				},
				DpuCount: ptr.Float64(1.0),
			},
			WorkGroup: ptr.String("__WorkGroup__"),
			EngineVersion: &types.EngineVersion{
				SelectedEngineVersion:  ptr.String("__SelectedEngineVersion__"),
				EffectiveEngineVersion: ptr.String("__EffectiveEngineVersion__"),
			},
			ExecutionParameters: []string{
				"__Member__",
				"__Member__",
			},
			SubstatementType: ptr.String("__SubstatementType__"),
			QueryResultsS3AccessGrantsConfiguration: &types.QueryResultsS3AccessGrantsConfiguration{
				EnableS3AccessGrants:  ptr.Bool(true),
				CreateUserLevelPrefix: ptr.Bool(true),
				AuthenticationType:    types.AuthenticationType("DIRECTORY_IDENTITY"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetQueryExecution.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.GetQueryExecution(context.Background(), &GetQueryExecutionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetQueryExecution.response", err)
	}
}

func TestCheckResponseSnapshot_GetQueryResults(t *testing.T) {
	want := &GetQueryResultsOutput{
		UpdateCount: ptr.Int64(1),
		ResultSet: &types.ResultSet{
			Rows: []types.Row{
				{
					Data: []types.Datum{
						{
							VarCharValue: ptr.String("__VarCharValue__"),
						},
						{
							VarCharValue: ptr.String("__VarCharValue__"),
						},
					},
				},
				{
					Data: []types.Datum{
						{
							VarCharValue: ptr.String("__VarCharValue__"),
						},
						{
							VarCharValue: ptr.String("__VarCharValue__"),
						},
					},
				},
			},
			ResultSetMetadata: &types.ResultSetMetadata{
				ColumnInfo: []types.ColumnInfo{
					{
						CatalogName:   ptr.String("__CatalogName__"),
						SchemaName:    ptr.String("__SchemaName__"),
						TableName:     ptr.String("__TableName__"),
						Name:          ptr.String("__Name__"),
						Label:         ptr.String("__Label__"),
						Type:          ptr.String("__Type__"),
						Precision:     1,
						Scale:         1,
						Nullable:      types.ColumnNullable("NOT_NULL"),
						CaseSensitive: true,
					},
					{
						CatalogName:   ptr.String("__CatalogName__"),
						SchemaName:    ptr.String("__SchemaName__"),
						TableName:     ptr.String("__TableName__"),
						Name:          ptr.String("__Name__"),
						Label:         ptr.String("__Label__"),
						Type:          ptr.String("__Type__"),
						Precision:     1,
						Scale:         1,
						Nullable:      types.ColumnNullable("NOT_NULL"),
						CaseSensitive: true,
					},
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetQueryResults.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.GetQueryResults(context.Background(), &GetQueryResultsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetQueryResults.response", err)
	}
}

func TestCheckResponseSnapshot_GetQueryRuntimeStatistics(t *testing.T) {
	want := &GetQueryRuntimeStatisticsOutput{
		QueryRuntimeStatistics: &types.QueryRuntimeStatistics{
			Timeline: &types.QueryRuntimeStatisticsTimeline{
				QueryQueueTimeInMillis:           ptr.Int64(1),
				ServicePreProcessingTimeInMillis: ptr.Int64(1),
				QueryPlanningTimeInMillis:        ptr.Int64(1),
				EngineExecutionTimeInMillis:      ptr.Int64(1),
				ServiceProcessingTimeInMillis:    ptr.Int64(1),
				TotalExecutionTimeInMillis:       ptr.Int64(1),
			},
			Rows: &types.QueryRuntimeStatisticsRows{
				InputRows:   ptr.Int64(1),
				InputBytes:  ptr.Int64(1),
				OutputBytes: ptr.Int64(1),
				OutputRows:  ptr.Int64(1),
			},
			OutputStage: &types.QueryStage{
				StageId:       ptr.Int64(1),
				State:         ptr.String("__State__"),
				OutputBytes:   ptr.Int64(1),
				OutputRows:    ptr.Int64(1),
				InputBytes:    ptr.Int64(1),
				InputRows:     ptr.Int64(1),
				ExecutionTime: ptr.Int64(1),
				QueryStagePlan: &types.QueryStagePlanNode{
					Name:       ptr.String("__Name__"),
					Identifier: ptr.String("__Identifier__"),
					Children: []types.QueryStagePlanNode{
						{},
						{},
					},
					RemoteSources: []string{
						"__Member__",
						"__Member__",
					},
				},
				SubStages: []types.QueryStage{
					{},
					{},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetQueryRuntimeStatistics.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.GetQueryRuntimeStatistics(context.Background(), &GetQueryRuntimeStatisticsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetQueryRuntimeStatistics.response", err)
	}
}

func TestCheckResponseSnapshot_GetResourceDashboard(t *testing.T) {
	want := &GetResourceDashboardOutput{
		Url: ptr.String("__Url__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetResourceDashboard.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.GetResourceDashboard(context.Background(), &GetResourceDashboardInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetResourceDashboard.response", err)
	}
}

func TestCheckResponseSnapshot_GetSession(t *testing.T) {
	want := &GetSessionOutput{
		SessionId:     ptr.String("__SessionId__"),
		Description:   ptr.String("__Description__"),
		WorkGroup:     ptr.String("__WorkGroup__"),
		EngineVersion: ptr.String("__EngineVersion__"),
		EngineConfiguration: &types.EngineConfiguration{
			CoordinatorDpuSize:     ptr.Int32(1),
			MaxConcurrentDpus:      ptr.Int32(1),
			DefaultExecutorDpuSize: ptr.Int32(1),
			AdditionalConfigs: map[string]string{
				"key0": "__Value__",
			},
			SparkProperties: map[string]string{
				"key0": "__Value__",
			},
			Classifications: []types.Classification{
				{
					Name: ptr.String("__Name__"),
					Properties: map[string]string{
						"key0": "__Value__",
					},
				},
				{
					Name: ptr.String("__Name__"),
					Properties: map[string]string{
						"key0": "__Value__",
					},
				},
			},
		},
		NotebookVersion: ptr.String("__NotebookVersion__"),
		MonitoringConfiguration: &types.MonitoringConfiguration{
			CloudWatchLoggingConfiguration: &types.CloudWatchLoggingConfiguration{
				Enabled:             ptr.Bool(true),
				LogGroup:            ptr.String("__LogGroup__"),
				LogStreamNamePrefix: ptr.String("__LogStreamNamePrefix__"),
				LogTypes: map[string][]string{
					"key0": {
						"__Member__",
						"__Member__",
					},
				},
			},
			ManagedLoggingConfiguration: &types.ManagedLoggingConfiguration{
				Enabled: ptr.Bool(true),
				KmsKey:  ptr.String("__KmsKey__"),
			},
			S3LoggingConfiguration: &types.S3LoggingConfiguration{
				Enabled:     ptr.Bool(true),
				KmsKey:      ptr.String("__KmsKey__"),
				LogLocation: ptr.String("__LogLocation__"),
			},
		},
		SessionConfiguration: &types.SessionConfiguration{
			ExecutionRole:               ptr.String("__ExecutionRole__"),
			WorkingDirectory:            ptr.String("__WorkingDirectory__"),
			IdleTimeoutSeconds:          ptr.Int64(1),
			SessionIdleTimeoutInMinutes: ptr.Int32(1),
			EncryptionConfiguration: &types.EncryptionConfiguration{
				EncryptionOption: types.EncryptionOption("SSE_S3"),
				KmsKey:           ptr.String("__KmsKey__"),
			},
		},
		Status: &types.SessionStatus{
			StartDateTime:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EndDateTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			IdleSinceDateTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			State:                types.SessionState("CREATING"),
			StateChangeReason:    ptr.String("__StateChangeReason__"),
		},
		Statistics: &types.SessionStatistics{
			DpuExecutionInMillis: ptr.Int64(1),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetSession.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.GetSession(context.Background(), &GetSessionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetSession.response", err)
	}
}

func TestCheckResponseSnapshot_GetSessionEndpoint(t *testing.T) {
	want := &GetSessionEndpointOutput{
		EndpointUrl:             ptr.String("__EndpointUrl__"),
		AuthToken:               ptr.String("__AuthToken__"),
		AuthTokenExpirationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetSessionEndpoint.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.GetSessionEndpoint(context.Background(), &GetSessionEndpointInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetSessionEndpoint.response", err)
	}
}

func TestCheckResponseSnapshot_GetSessionStatus(t *testing.T) {
	want := &GetSessionStatusOutput{
		SessionId: ptr.String("__SessionId__"),
		Status: &types.SessionStatus{
			StartDateTime:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastModifiedDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			EndDateTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			IdleSinceDateTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			State:                types.SessionState("CREATING"),
			StateChangeReason:    ptr.String("__StateChangeReason__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetSessionStatus.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.GetSessionStatus(context.Background(), &GetSessionStatusInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetSessionStatus.response", err)
	}
}

func TestCheckResponseSnapshot_GetTableMetadata(t *testing.T) {
	want := &GetTableMetadataOutput{
		TableMetadata: &types.TableMetadata{
			Name:           ptr.String("__Name__"),
			CreateTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			LastAccessTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			TableType:      ptr.String("__TableType__"),
			Columns: []types.Column{
				{
					Name:    ptr.String("__Name__"),
					Type:    ptr.String("__Type__"),
					Comment: ptr.String("__Comment__"),
				},
				{
					Name:    ptr.String("__Name__"),
					Type:    ptr.String("__Type__"),
					Comment: ptr.String("__Comment__"),
				},
			},
			PartitionKeys: []types.Column{
				{
					Name:    ptr.String("__Name__"),
					Type:    ptr.String("__Type__"),
					Comment: ptr.String("__Comment__"),
				},
				{
					Name:    ptr.String("__Name__"),
					Type:    ptr.String("__Type__"),
					Comment: ptr.String("__Comment__"),
				},
			},
			Parameters: map[string]string{
				"key0": "__Value__",
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetTableMetadata.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.GetTableMetadata(context.Background(), &GetTableMetadataInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetTableMetadata.response", err)
	}
}

func TestCheckResponseSnapshot_GetWorkGroup(t *testing.T) {
	want := &GetWorkGroupOutput{
		WorkGroup: &types.WorkGroup{
			Name:  ptr.String("__Name__"),
			State: types.WorkGroupState("ENABLED"),
			Configuration: &types.WorkGroupConfiguration{
				ResultConfiguration: &types.ResultConfiguration{
					OutputLocation: ptr.String("__OutputLocation__"),
					EncryptionConfiguration: &types.EncryptionConfiguration{
						EncryptionOption: types.EncryptionOption("SSE_S3"),
						KmsKey:           ptr.String("__KmsKey__"),
					},
					ExpectedBucketOwner: ptr.String("__ExpectedBucketOwner__"),
					AclConfiguration: &types.AclConfiguration{
						S3AclOption: types.S3AclOption("BUCKET_OWNER_FULL_CONTROL"),
					},
				},
				ManagedQueryResultsConfiguration: &types.ManagedQueryResultsConfiguration{
					Enabled: true,
					EncryptionConfiguration: &types.ManagedQueryResultsEncryptionConfiguration{
						KmsKey: ptr.String("__KmsKey__"),
					},
				},
				EnforceWorkGroupConfiguration:   ptr.Bool(true),
				PublishCloudWatchMetricsEnabled: ptr.Bool(true),
				BytesScannedCutoffPerQuery:      ptr.Int64(1),
				RequesterPaysEnabled:            ptr.Bool(true),
				EngineVersion: &types.EngineVersion{
					SelectedEngineVersion:  ptr.String("__SelectedEngineVersion__"),
					EffectiveEngineVersion: ptr.String("__EffectiveEngineVersion__"),
				},
				AdditionalConfiguration: ptr.String("__AdditionalConfiguration__"),
				ExecutionRole:           ptr.String("__ExecutionRole__"),
				MonitoringConfiguration: &types.MonitoringConfiguration{
					CloudWatchLoggingConfiguration: &types.CloudWatchLoggingConfiguration{
						Enabled:             ptr.Bool(true),
						LogGroup:            ptr.String("__LogGroup__"),
						LogStreamNamePrefix: ptr.String("__LogStreamNamePrefix__"),
						LogTypes: map[string][]string{
							"key0": {
								"__Member__",
								"__Member__",
							},
						},
					},
					ManagedLoggingConfiguration: &types.ManagedLoggingConfiguration{
						Enabled: ptr.Bool(true),
						KmsKey:  ptr.String("__KmsKey__"),
					},
					S3LoggingConfiguration: &types.S3LoggingConfiguration{
						Enabled:     ptr.Bool(true),
						KmsKey:      ptr.String("__KmsKey__"),
						LogLocation: ptr.String("__LogLocation__"),
					},
				},
				EngineConfiguration: &types.EngineConfiguration{
					CoordinatorDpuSize:     ptr.Int32(1),
					MaxConcurrentDpus:      ptr.Int32(1),
					DefaultExecutorDpuSize: ptr.Int32(1),
					AdditionalConfigs: map[string]string{
						"key0": "__Value__",
					},
					SparkProperties: map[string]string{
						"key0": "__Value__",
					},
					Classifications: []types.Classification{
						{
							Name: ptr.String("__Name__"),
							Properties: map[string]string{
								"key0": "__Value__",
							},
						},
						{
							Name: ptr.String("__Name__"),
							Properties: map[string]string{
								"key0": "__Value__",
							},
						},
					},
				},
				CustomerContentEncryptionConfiguration: &types.CustomerContentEncryptionConfiguration{
					KmsKey: ptr.String("__KmsKey__"),
				},
				EnableMinimumEncryptionConfiguration: ptr.Bool(true),
				IdentityCenterConfiguration: &types.IdentityCenterConfiguration{
					EnableIdentityCenter:      ptr.Bool(true),
					IdentityCenterInstanceArn: ptr.String("__IdentityCenterInstanceArn__"),
				},
				QueryResultsS3AccessGrantsConfiguration: &types.QueryResultsS3AccessGrantsConfiguration{
					EnableS3AccessGrants:  ptr.Bool(true),
					CreateUserLevelPrefix: ptr.Bool(true),
					AuthenticationType:    types.AuthenticationType("DIRECTORY_IDENTITY"),
				},
			},
			Description:                  ptr.String("__Description__"),
			CreationTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			IdentityCenterApplicationArn: ptr.String("__IdentityCenterApplicationArn__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetWorkGroup.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.GetWorkGroup(context.Background(), &GetWorkGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetWorkGroup.response", err)
	}
}

func TestCheckResponseSnapshot_ImportNotebook(t *testing.T) {
	want := &ImportNotebookOutput{
		NotebookId: ptr.String("__NotebookId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ImportNotebook.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.ImportNotebook(context.Background(), &ImportNotebookInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ImportNotebook.response", err)
	}
}

func TestCheckResponseSnapshot_ListApplicationDPUSizes(t *testing.T) {
	want := &ListApplicationDPUSizesOutput{
		ApplicationDPUSizes: []types.ApplicationDPUSizes{
			{
				ApplicationRuntimeId: ptr.String("__ApplicationRuntimeId__"),
				SupportedDPUSizes: []int32{
					1,
					1,
				},
			},
			{
				ApplicationRuntimeId: ptr.String("__ApplicationRuntimeId__"),
				SupportedDPUSizes: []int32{
					1,
					1,
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListApplicationDPUSizes.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.ListApplicationDPUSizes(context.Background(), &ListApplicationDPUSizesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListApplicationDPUSizes.response", err)
	}
}

func TestCheckResponseSnapshot_ListCalculationExecutions(t *testing.T) {
	want := &ListCalculationExecutionsOutput{
		NextToken: ptr.String("__NextToken__"),
		Calculations: []types.CalculationSummary{
			{
				CalculationExecutionId: ptr.String("__CalculationExecutionId__"),
				Description:            ptr.String("__Description__"),
				Status: &types.CalculationStatus{
					SubmissionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CompletionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					State:              types.CalculationExecutionState("CREATING"),
					StateChangeReason:  ptr.String("__StateChangeReason__"),
				},
			},
			{
				CalculationExecutionId: ptr.String("__CalculationExecutionId__"),
				Description:            ptr.String("__Description__"),
				Status: &types.CalculationStatus{
					SubmissionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					CompletionDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					State:              types.CalculationExecutionState("CREATING"),
					StateChangeReason:  ptr.String("__StateChangeReason__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListCalculationExecutions.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.ListCalculationExecutions(context.Background(), &ListCalculationExecutionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListCalculationExecutions.response", err)
	}
}

func TestCheckResponseSnapshot_ListCapacityReservations(t *testing.T) {
	want := &ListCapacityReservationsOutput{
		NextToken: ptr.String("__NextToken__"),
		CapacityReservations: []types.CapacityReservation{
			{
				Name:          ptr.String("__Name__"),
				Status:        types.CapacityReservationStatus("PENDING"),
				TargetDpus:    ptr.Int32(1),
				AllocatedDpus: ptr.Int32(1),
				LastAllocation: &types.CapacityAllocation{
					Status:                types.CapacityAllocationStatus("PENDING"),
					StatusMessage:         ptr.String("__StatusMessage__"),
					RequestTime:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					RequestCompletionTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				LastSuccessfulAllocationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreationTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				Name:          ptr.String("__Name__"),
				Status:        types.CapacityReservationStatus("PENDING"),
				TargetDpus:    ptr.Int32(1),
				AllocatedDpus: ptr.Int32(1),
				LastAllocation: &types.CapacityAllocation{
					Status:                types.CapacityAllocationStatus("PENDING"),
					StatusMessage:         ptr.String("__StatusMessage__"),
					RequestTime:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					RequestCompletionTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				},
				LastSuccessfulAllocationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreationTime:                 ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListCapacityReservations.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.ListCapacityReservations(context.Background(), &ListCapacityReservationsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListCapacityReservations.response", err)
	}
}

func TestCheckResponseSnapshot_ListDataCatalogs(t *testing.T) {
	want := &ListDataCatalogsOutput{
		DataCatalogsSummary: []types.DataCatalogSummary{
			{
				CatalogName:    ptr.String("__CatalogName__"),
				Type:           types.DataCatalogType("LAMBDA"),
				Status:         types.DataCatalogStatus("CREATE_IN_PROGRESS"),
				ConnectionType: types.ConnectionType("DYNAMODB"),
				Error:          ptr.String("__Error__"),
			},
			{
				CatalogName:    ptr.String("__CatalogName__"),
				Type:           types.DataCatalogType("LAMBDA"),
				Status:         types.DataCatalogStatus("CREATE_IN_PROGRESS"),
				ConnectionType: types.ConnectionType("DYNAMODB"),
				Error:          ptr.String("__Error__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListDataCatalogs.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.ListDataCatalogs(context.Background(), &ListDataCatalogsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListDataCatalogs.response", err)
	}
}

func TestCheckResponseSnapshot_ListDatabases(t *testing.T) {
	want := &ListDatabasesOutput{
		DatabaseList: []types.Database{
			{
				Name:        ptr.String("__Name__"),
				Description: ptr.String("__Description__"),
				Parameters: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				Name:        ptr.String("__Name__"),
				Description: ptr.String("__Description__"),
				Parameters: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListDatabases.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.ListDatabases(context.Background(), &ListDatabasesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListDatabases.response", err)
	}
}

func TestCheckResponseSnapshot_ListEngineVersions(t *testing.T) {
	want := &ListEngineVersionsOutput{
		EngineVersions: []types.EngineVersion{
			{
				SelectedEngineVersion:  ptr.String("__SelectedEngineVersion__"),
				EffectiveEngineVersion: ptr.String("__EffectiveEngineVersion__"),
			},
			{
				SelectedEngineVersion:  ptr.String("__SelectedEngineVersion__"),
				EffectiveEngineVersion: ptr.String("__EffectiveEngineVersion__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListEngineVersions.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.ListEngineVersions(context.Background(), &ListEngineVersionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListEngineVersions.response", err)
	}
}

func TestCheckResponseSnapshot_ListExecutors(t *testing.T) {
	want := &ListExecutorsOutput{
		SessionId: ptr.String("__SessionId__"),
		NextToken: ptr.String("__NextToken__"),
		ExecutorsSummary: []types.ExecutorsSummary{
			{
				ExecutorId:          ptr.String("__ExecutorId__"),
				ExecutorType:        types.ExecutorType("COORDINATOR"),
				StartDateTime:       ptr.Int64(1),
				TerminationDateTime: ptr.Int64(1),
				ExecutorState:       types.ExecutorState("CREATING"),
				ExecutorSize:        ptr.Int64(1),
			},
			{
				ExecutorId:          ptr.String("__ExecutorId__"),
				ExecutorType:        types.ExecutorType("COORDINATOR"),
				StartDateTime:       ptr.Int64(1),
				TerminationDateTime: ptr.Int64(1),
				ExecutorState:       types.ExecutorState("CREATING"),
				ExecutorSize:        ptr.Int64(1),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListExecutors.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.ListExecutors(context.Background(), &ListExecutorsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListExecutors.response", err)
	}
}

func TestCheckResponseSnapshot_ListNamedQueries(t *testing.T) {
	want := &ListNamedQueriesOutput{
		NamedQueryIds: []string{
			"__Member__",
			"__Member__",
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListNamedQueries.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.ListNamedQueries(context.Background(), &ListNamedQueriesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListNamedQueries.response", err)
	}
}

func TestCheckResponseSnapshot_ListNotebookMetadata(t *testing.T) {
	want := &ListNotebookMetadataOutput{
		NextToken: ptr.String("__NextToken__"),
		NotebookMetadataList: []types.NotebookMetadata{
			{
				NotebookId:       ptr.String("__NotebookId__"),
				Name:             ptr.String("__Name__"),
				WorkGroup:        ptr.String("__WorkGroup__"),
				CreationTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Type:             types.NotebookType("IPYNB"),
				LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				NotebookId:       ptr.String("__NotebookId__"),
				Name:             ptr.String("__Name__"),
				WorkGroup:        ptr.String("__WorkGroup__"),
				CreationTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Type:             types.NotebookType("IPYNB"),
				LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListNotebookMetadata.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.ListNotebookMetadata(context.Background(), &ListNotebookMetadataInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListNotebookMetadata.response", err)
	}
}

func TestCheckResponseSnapshot_ListNotebookSessions(t *testing.T) {
	want := &ListNotebookSessionsOutput{
		NotebookSessionsList: []types.NotebookSessionSummary{
			{
				SessionId:    ptr.String("__SessionId__"),
				CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				SessionId:    ptr.String("__SessionId__"),
				CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListNotebookSessions.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.ListNotebookSessions(context.Background(), &ListNotebookSessionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListNotebookSessions.response", err)
	}
}

func TestCheckResponseSnapshot_ListPreparedStatements(t *testing.T) {
	want := &ListPreparedStatementsOutput{
		PreparedStatements: []types.PreparedStatementSummary{
			{
				StatementName:    ptr.String("__StatementName__"),
				LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				StatementName:    ptr.String("__StatementName__"),
				LastModifiedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListPreparedStatements.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.ListPreparedStatements(context.Background(), &ListPreparedStatementsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListPreparedStatements.response", err)
	}
}

func TestCheckResponseSnapshot_ListQueryExecutions(t *testing.T) {
	want := &ListQueryExecutionsOutput{
		QueryExecutionIds: []string{
			"__Member__",
			"__Member__",
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListQueryExecutions.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.ListQueryExecutions(context.Background(), &ListQueryExecutionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListQueryExecutions.response", err)
	}
}

func TestCheckResponseSnapshot_ListSessions(t *testing.T) {
	want := &ListSessionsOutput{
		NextToken: ptr.String("__NextToken__"),
		Sessions: []types.SessionSummary{
			{
				SessionId:   ptr.String("__SessionId__"),
				Description: ptr.String("__Description__"),
				EngineVersion: &types.EngineVersion{
					SelectedEngineVersion:  ptr.String("__SelectedEngineVersion__"),
					EffectiveEngineVersion: ptr.String("__EffectiveEngineVersion__"),
				},
				NotebookVersion: ptr.String("__NotebookVersion__"),
				Status: &types.SessionStatus{
					StartDateTime:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					EndDateTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					IdleSinceDateTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					State:                types.SessionState("CREATING"),
					StateChangeReason:    ptr.String("__StateChangeReason__"),
				},
			},
			{
				SessionId:   ptr.String("__SessionId__"),
				Description: ptr.String("__Description__"),
				EngineVersion: &types.EngineVersion{
					SelectedEngineVersion:  ptr.String("__SelectedEngineVersion__"),
					EffectiveEngineVersion: ptr.String("__EffectiveEngineVersion__"),
				},
				NotebookVersion: ptr.String("__NotebookVersion__"),
				Status: &types.SessionStatus{
					StartDateTime:        ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					LastModifiedDateTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					EndDateTime:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					IdleSinceDateTime:    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					State:                types.SessionState("CREATING"),
					StateChangeReason:    ptr.String("__StateChangeReason__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListSessions.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.ListSessions(context.Background(), &ListSessionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListSessions.response", err)
	}
}

func TestCheckResponseSnapshot_ListTableMetadata(t *testing.T) {
	want := &ListTableMetadataOutput{
		TableMetadataList: []types.TableMetadata{
			{
				Name:           ptr.String("__Name__"),
				CreateTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastAccessTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				TableType:      ptr.String("__TableType__"),
				Columns: []types.Column{
					{
						Name:    ptr.String("__Name__"),
						Type:    ptr.String("__Type__"),
						Comment: ptr.String("__Comment__"),
					},
					{
						Name:    ptr.String("__Name__"),
						Type:    ptr.String("__Type__"),
						Comment: ptr.String("__Comment__"),
					},
				},
				PartitionKeys: []types.Column{
					{
						Name:    ptr.String("__Name__"),
						Type:    ptr.String("__Type__"),
						Comment: ptr.String("__Comment__"),
					},
					{
						Name:    ptr.String("__Name__"),
						Type:    ptr.String("__Type__"),
						Comment: ptr.String("__Comment__"),
					},
				},
				Parameters: map[string]string{
					"key0": "__Value__",
				},
			},
			{
				Name:           ptr.String("__Name__"),
				CreateTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				LastAccessTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				TableType:      ptr.String("__TableType__"),
				Columns: []types.Column{
					{
						Name:    ptr.String("__Name__"),
						Type:    ptr.String("__Type__"),
						Comment: ptr.String("__Comment__"),
					},
					{
						Name:    ptr.String("__Name__"),
						Type:    ptr.String("__Type__"),
						Comment: ptr.String("__Comment__"),
					},
				},
				PartitionKeys: []types.Column{
					{
						Name:    ptr.String("__Name__"),
						Type:    ptr.String("__Type__"),
						Comment: ptr.String("__Comment__"),
					},
					{
						Name:    ptr.String("__Name__"),
						Type:    ptr.String("__Type__"),
						Comment: ptr.String("__Comment__"),
					},
				},
				Parameters: map[string]string{
					"key0": "__Value__",
				},
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListTableMetadata.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.ListTableMetadata(context.Background(), &ListTableMetadataInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListTableMetadata.response", err)
	}
}

func TestCheckResponseSnapshot_ListTagsForResource(t *testing.T) {
	want := &ListTagsForResourceOutput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListTagsForResource.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.ListTagsForResource(context.Background(), &ListTagsForResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListTagsForResource.response", err)
	}
}

func TestCheckResponseSnapshot_ListWorkGroups(t *testing.T) {
	want := &ListWorkGroupsOutput{
		WorkGroups: []types.WorkGroupSummary{
			{
				Name:         ptr.String("__Name__"),
				State:        types.WorkGroupState("ENABLED"),
				Description:  ptr.String("__Description__"),
				CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EngineVersion: &types.EngineVersion{
					SelectedEngineVersion:  ptr.String("__SelectedEngineVersion__"),
					EffectiveEngineVersion: ptr.String("__EffectiveEngineVersion__"),
				},
				IdentityCenterApplicationArn: ptr.String("__IdentityCenterApplicationArn__"),
			},
			{
				Name:         ptr.String("__Name__"),
				State:        types.WorkGroupState("ENABLED"),
				Description:  ptr.String("__Description__"),
				CreationTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				EngineVersion: &types.EngineVersion{
					SelectedEngineVersion:  ptr.String("__SelectedEngineVersion__"),
					EffectiveEngineVersion: ptr.String("__EffectiveEngineVersion__"),
				},
				IdentityCenterApplicationArn: ptr.String("__IdentityCenterApplicationArn__"),
			},
		},
		NextToken: ptr.String("__NextToken__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListWorkGroups.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.ListWorkGroups(context.Background(), &ListWorkGroupsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListWorkGroups.response", err)
	}
}

func TestCheckResponseSnapshot_PutCapacityAssignmentConfiguration(t *testing.T) {
	want := &PutCapacityAssignmentConfigurationOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutCapacityAssignmentConfiguration.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.PutCapacityAssignmentConfiguration(context.Background(), &PutCapacityAssignmentConfigurationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutCapacityAssignmentConfiguration.response", err)
	}
}

func TestCheckResponseSnapshot_StartCalculationExecution(t *testing.T) {
	want := &StartCalculationExecutionOutput{
		CalculationExecutionId: ptr.String("__CalculationExecutionId__"),
		State:                  types.CalculationExecutionState("CREATING"),
	}
	status, header, body, err := serdeRespReadSnapshot("StartCalculationExecution.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.StartCalculationExecution(context.Background(), &StartCalculationExecutionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartCalculationExecution.response", err)
	}
}

func TestCheckResponseSnapshot_StartQueryExecution(t *testing.T) {
	want := &StartQueryExecutionOutput{
		QueryExecutionId: ptr.String("__QueryExecutionId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("StartQueryExecution.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.StartQueryExecution(context.Background(), &StartQueryExecutionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartQueryExecution.response", err)
	}
}

func TestCheckResponseSnapshot_StartSession(t *testing.T) {
	want := &StartSessionOutput{
		SessionId: ptr.String("__SessionId__"),
		State:     types.SessionState("CREATING"),
	}
	status, header, body, err := serdeRespReadSnapshot("StartSession.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.StartSession(context.Background(), &StartSessionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StartSession.response", err)
	}
}

func TestCheckResponseSnapshot_StopCalculationExecution(t *testing.T) {
	want := &StopCalculationExecutionOutput{
		State: types.CalculationExecutionState("CREATING"),
	}
	status, header, body, err := serdeRespReadSnapshot("StopCalculationExecution.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.StopCalculationExecution(context.Background(), &StopCalculationExecutionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StopCalculationExecution.response", err)
	}
}

func TestCheckResponseSnapshot_StopQueryExecution(t *testing.T) {
	want := &StopQueryExecutionOutput{}
	status, header, body, err := serdeRespReadSnapshot("StopQueryExecution.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.StopQueryExecution(context.Background(), &StopQueryExecutionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "StopQueryExecution.response", err)
	}
}

func TestCheckResponseSnapshot_TagResource(t *testing.T) {
	want := &TagResourceOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagResource.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.TagResource(context.Background(), &TagResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagResource.response", err)
	}
}

func TestCheckResponseSnapshot_TerminateSession(t *testing.T) {
	want := &TerminateSessionOutput{
		State: types.SessionState("CREATING"),
	}
	status, header, body, err := serdeRespReadSnapshot("TerminateSession.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.TerminateSession(context.Background(), &TerminateSessionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TerminateSession.response", err)
	}
}

func TestCheckResponseSnapshot_UntagResource(t *testing.T) {
	want := &UntagResourceOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagResource.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.UntagResource(context.Background(), &UntagResourceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagResource.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateCapacityReservation(t *testing.T) {
	want := &UpdateCapacityReservationOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateCapacityReservation.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.UpdateCapacityReservation(context.Background(), &UpdateCapacityReservationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateCapacityReservation.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateDataCatalog(t *testing.T) {
	want := &UpdateDataCatalogOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateDataCatalog.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.UpdateDataCatalog(context.Background(), &UpdateDataCatalogInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateDataCatalog.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateNamedQuery(t *testing.T) {
	want := &UpdateNamedQueryOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateNamedQuery.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.UpdateNamedQuery(context.Background(), &UpdateNamedQueryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateNamedQuery.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateNotebook(t *testing.T) {
	want := &UpdateNotebookOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateNotebook.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.UpdateNotebook(context.Background(), &UpdateNotebookInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateNotebook.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateNotebookMetadata(t *testing.T) {
	want := &UpdateNotebookMetadataOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateNotebookMetadata.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.UpdateNotebookMetadata(context.Background(), &UpdateNotebookMetadataInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateNotebookMetadata.response", err)
	}
}

func TestCheckResponseSnapshot_UpdatePreparedStatement(t *testing.T) {
	want := &UpdatePreparedStatementOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdatePreparedStatement.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.UpdatePreparedStatement(context.Background(), &UpdatePreparedStatementInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdatePreparedStatement.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateWorkGroup(t *testing.T) {
	want := &UpdateWorkGroupOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateWorkGroup.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.UpdateWorkGroup(context.Background(), &UpdateWorkGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateWorkGroup.response", err)
	}
}

func TestCheckResponseSnapshot_Error_InternalServerException(t *testing.T) {
	want := &types.InternalServerException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InternalServerException.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.BatchGetNamedQuery(context.Background(), &BatchGetNamedQueryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InternalServerException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InternalServerException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InternalServerException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidRequestException(t *testing.T) {
	want := &types.InvalidRequestException{
		AthenaErrorCode: ptr.String("__AthenaErrorCode__"),
		Message:         ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidRequestException.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.BatchGetNamedQuery(context.Background(), &BatchGetNamedQueryInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidRequestException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidRequestException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidRequestException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MetadataException(t *testing.T) {
	want := &types.MetadataException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MetadataException.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.GetDatabase(context.Background(), &GetDatabaseInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MetadataException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MetadataException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MetadataException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ResourceNotFoundException(t *testing.T) {
	want := &types.ResourceNotFoundException{
		Message:      ptr.String("__Message__"),
		ResourceName: ptr.String("__ResourceName__"),
	}
	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.CreatePresignedNotebookUrl(context.Background(), &CreatePresignedNotebookUrlInput{})
	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_SessionAlreadyExistsException(t *testing.T) {
	want := &types.SessionAlreadyExistsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SessionAlreadyExistsException.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.StartSession(context.Background(), &StartSessionInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.SessionAlreadyExistsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.SessionAlreadyExistsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "SessionAlreadyExistsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_TooManyRequestsException(t *testing.T) {
	want := &types.TooManyRequestsException{
		Message: ptr.String("__Message__"),
		Reason:  types.ThrottleReason("CONCURRENT_QUERY_LIMIT_EXCEEDED"),
	}
	status, header, body, err := serdeRespReadSnapshot("TooManyRequestsException.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.CreateNotebook(context.Background(), &CreateNotebookInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.TooManyRequestsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.TooManyRequestsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "TooManyRequestsException.error", err)
	}
}
