func TestPutDateValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.PutDateValid(context.Background(), to.TimePtrArray(time.Date(2000, 12, 01, 0, 0, 0, 0, time.UTC),
		time.Date(1980, 01, 02, 0, 0, 0, 0, time.UTC),
		time.Date(1492, 10, 12, 0, 0, 0, 0, time.UTC)), nil)
	if err != nil {
		t.Fatal(err)
	}
	if s := resp.RawResponse.StatusCode; s != http.StatusOK {
		t.Fatalf("unexpected status code %d", s)
	}
}
PutDateValid - Set array value  ['2000-12-01', '1980-01-02', '1492-10-12']
package arraygroup
import (
	"context"
	"net/http"
	"reflect"
	"testing"
	"time"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/google/go-cmp/cmp"
)
func newArrayClient() *ArrayClient {
	return NewArrayClient(NewDefaultConnection(nil))
}
func TestGetArrayEmpty(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetArrayEmpty(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if resp.StringArrayArray == nil {
		t.Fatal("unexpected nil array")
	}
	if r := cmp.Diff(len(resp.StringArrayArray), 0); r != "" {
		t.Fatal(r)
	}
}
func TestGetArrayItemEmpty(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetArrayItemEmpty(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.StringArrayArray, [][]*string{
		to.StringPtrArray("1", "2", "3"),
		{},
		to.StringPtrArray("7", "8", "9"),
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetArrayItemNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetArrayItemNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.StringArrayArray, [][]*string{
		to.StringPtrArray("1", "2", "3"),
		nil,
		to.StringPtrArray("7", "8", "9"),
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetArrayNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetArrayNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if resp.StringArrayArray != nil {
		t.Fatal("expected nil array")
	}
}
func TestGetArrayValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetArrayValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.StringArrayArray, [][]*string{
		to.StringPtrArray("1", "2", "3"),
		to.StringPtrArray("4", "5", "6"),
		to.StringPtrArray("7", "8", "9"),
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetBase64URL(t *testing.T) {
	t.Skip("decoding fails")
	client := newArrayClient()
	resp, err := client.GetBase64URL(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.ByteArrayArray, [][]byte{
		{0},
		{0},
		{0},
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetBooleanInvalidNull(t *testing.T) {
	t.Skip("unmarshalling succeeds")
	client := newArrayClient()
	resp, err := client.GetBooleanInvalidNull(context.Background(), nil)
	if err == nil {
		t.Fatal("unexpected nil error")
	}
	if !reflect.ValueOf(resp).IsZero() {
		t.Fatal("expected empty response")
	}
}
func TestGetBooleanInvalidString(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetBooleanInvalidString(context.Background(), nil)
	if err == nil {
		t.Fatal("unexpected nil error")
	}
	if !reflect.ValueOf(resp).IsZero() {
		t.Fatal("expected empty response")
	}
}
func TestGetBooleanTfft(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetBooleanTfft(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.BoolArray, to.BoolPtrArray(true, false, false, true)); r != "" {
		t.Fatal(r)
	}
}
func TestGetByteInvalidNull(t *testing.T) {
	t.Skip("needs investigation")
	client := newArrayClient()
	resp, err := client.GetByteInvalidNull(context.Background(), nil)
	if err == nil {
		t.Fatal("unexpected nil error")
	}
	if !reflect.ValueOf(resp).IsZero() {
		t.Fatal("expected empty response")
	}
}
func TestGetByteValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetByteValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.ByteArrayArray, [][]byte{
		{255, 255, 255, 250},
		{1, 2, 3},
		{37, 41, 67},
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetComplexEmpty(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetComplexEmpty(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if resp.ProductArray == nil {
		t.Fatal("unexpected nil array")
	}
	if r := cmp.Diff(len(resp.ProductArray), 0); r != "" {
		t.Fatal(r)
	}
}
func TestGetComplexItemEmpty(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetComplexItemEmpty(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.ProductArray, []*Product{
		{Integer: to.Int32Ptr(1), String: to.StringPtr("2")},
		{},
		{Integer: to.Int32Ptr(5), String: to.StringPtr("6")},
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetComplexItemNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetComplexItemNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.ProductArray, []*Product{
		{Integer: to.Int32Ptr(1), String: to.StringPtr("2")},
		nil,
		{Integer: to.Int32Ptr(5), String: to.StringPtr("6")},
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetComplexNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetComplexNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if resp.ProductArray != nil {
		t.Fatal("expected nil array")
	}
}
func TestGetComplexValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetComplexValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.ProductArray, []*Product{
		{Integer: to.Int32Ptr(1), String: to.StringPtr("2")},
		{Integer: to.Int32Ptr(3), String: to.StringPtr("4")},
		{Integer: to.Int32Ptr(5), String: to.StringPtr("6")},
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetDateInvalidChars(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDateInvalidChars(context.Background(), nil)
	if err == nil {
		t.Fatal("unexpected nil error")
	}
	if !reflect.ValueOf(resp).IsZero() {
		t.Fatal("expected empty response")
	}
}
func TestGetDateInvalidNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDateInvalidNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	v1 := time.Date(2012, 1, 1, 0, 0, 0, 0, time.UTC)
	v3 := time.Date(1776, 7, 4, 0, 0, 0, 0, time.UTC)
	if r := cmp.Diff(resp.TimeArray, []*time.Time{
		&v1,
		nil,
		&v3,
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetDateTimeInvalidChars(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDateTimeInvalidChars(context.Background(), nil)
	if err == nil {
		t.Fatal("unexpected nil error")
	}
	if !reflect.ValueOf(resp).IsZero() {
		t.Fatal("expected empty response")
	}
}
func TestGetDateTimeInvalidNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDateTimeInvalidNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	v1, _ := time.Parse(time.RFC1123, "Fri, 01 Dec 2000 00:00:01 GMT")
	if r := cmp.Diff(resp.TimeArray, []*time.Time{
		&v1,
		nil,
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetDateTimeRFC1123Valid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDateTimeRFC1123Valid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	v1, _ := time.Parse(time.RFC1123, "Fri, 01 Dec 2000 00:00:01 GMT")
	v2, _ := time.Parse(time.RFC1123, "Wed, 02 Jan 1980 00:11:35 GMT")
	v3, _ := time.Parse(time.RFC1123, "Wed, 12 Oct 1492 10:15:01 GMT")
	if r := cmp.Diff(resp.TimeArray, []*time.Time{
		&v1,
		&v2,
		&v3,
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetDateTimeValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDateTimeValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	v1, _ := time.Parse(time.RFC3339, "2000-12-01T00:00:01Z")
	v2, _ := time.Parse(time.RFC3339, "1980-01-02T01:11:35+01:00")
	v3, _ := time.Parse(time.RFC3339, "1492-10-12T02:15:01-08:00")
	if r := cmp.Diff(resp.TimeArray, []*time.Time{
		&v1,
		&v2,
		&v3,
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetDateValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDateValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.TimeArray, to.TimePtrArray(
		time.Date(2000, time.December, 01, 0, 0, 0, 0, time.UTC),
		time.Date(1980, time.January, 02, 0, 0, 0, 0, time.UTC),
		time.Date(1492, time.October, 12, 0, 0, 0, 0, time.UTC),
	)); r != "" {
		t.Fatal(r)
	}
}
func TestGetDictionaryEmpty(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDictionaryEmpty(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.MapOfStringArray, []map[string]*string{}); r != "" {
		t.Fatal(r)
	}
}
func TestGetDictionaryItemEmpty(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDictionaryItemEmpty(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.MapOfStringArray, []map[string]*string{
		{
			"1": to.StringPtr("one"),
			"2": to.StringPtr("two"),
			"3": to.StringPtr("three"),
		},
		{},
		{
			"7": to.StringPtr("seven"),
			"8": to.StringPtr("eight"),
			"9": to.StringPtr("nine"),
		},
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetDictionaryItemNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDictionaryItemNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.MapOfStringArray, []map[string]*string{
		{
			"1": to.StringPtr("one"),
			"2": to.StringPtr("two"),
			"3": to.StringPtr("three"),
		},
		nil,
		{
			"7": to.StringPtr("seven"),
			"8": to.StringPtr("eight"),
			"9": to.StringPtr("nine"),
		},
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetDictionaryNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDictionaryNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if resp.MapOfStringArray != nil {
		t.Fatal("expected nil dictionary")
	}
}
func TestGetDictionaryValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDictionaryValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.MapOfStringArray, []map[string]*string{
		{
			"1": to.StringPtr("one"),
			"2": to.StringPtr("two"),
			"3": to.StringPtr("three"),
		},
		{
			"4": to.StringPtr("four"),
			"5": to.StringPtr("five"),
			"6": to.StringPtr("six"),
		},
		{
			"7": to.StringPtr("seven"),
			"8": to.StringPtr("eight"),
			"9": to.StringPtr("nine"),
		},
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetDoubleInvalidNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDoubleInvalidNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.Float64Array, []*float64{
		to.Float64Ptr(0),
		nil,
		to.Float64Ptr(-1.2e20),
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetDoubleInvalidString(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDoubleInvalidString(context.Background(), nil)
	if err == nil {
		t.Fatal("unexpected nil error")
	}
	if !reflect.ValueOf(resp).IsZero() {
		t.Fatal("expected empty response")
	}
}
func TestGetDoubleValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDoubleValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.Float64Array, to.Float64PtrArray(0, -0.01, -1.2e20)); r != "" {
		t.Fatal(r)
	}
}
func TestGetDurationValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetDurationValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.StringArray, to.StringPtrArray("P123DT22H14M12.011S", "P5DT1H0M0S")); r != "" {
		t.Fatal(r)
	}
}
func TestGetEmpty(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetEmpty(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if resp.Int32Array == nil {
		t.Fatal("unexpected nil array")
	}
	if r := cmp.Diff(len(resp.Int32Array), 0); r != "" {
		t.Fatal(r)
	}
}
func TestGetEnumValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetEnumValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.FooEnumArray, []*FooEnum{
		FooEnumFoo1.ToPtr(), FooEnumFoo2.ToPtr(), FooEnumFoo3.ToPtr()}); r != "" {
		t.Fatal(r)
	}
}
func TestGetFloatInvalidNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetFloatInvalidNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.Float32Array, []*float32{
		to.Float32Ptr(0),
		nil,
		to.Float32Ptr(-1.2e20),
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetFloatInvalidString(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetFloatInvalidString(context.Background(), nil)
	if err == nil {
		t.Fatal("unexpected nil error")
	}
	if !reflect.ValueOf(resp).IsZero() {
		t.Fatal("expected empty response")
	}
}
func TestGetFloatValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetFloatValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.Float32Array, to.Float32PtrArray(0, -0.01, -1.2e20)); r != "" {
		t.Fatal(r)
	}
}
func TestGetIntInvalidNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetIntInvalidNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.Int32Array, []*int32{
		to.Int32Ptr(1),
		nil,
		to.Int32Ptr(0),
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetIntInvalidString(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetIntInvalidString(context.Background(), nil)
	if err == nil {
		t.Fatal("unexpected nil error")
	}
	if !reflect.ValueOf(resp).IsZero() {
		t.Fatal("expected empty response")
	}
}
func TestGetIntegerValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetIntegerValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.Int32Array, to.Int32PtrArray(1, -1, 3, 300)); r != "" {
		t.Fatal(r)
	}
}
func TestGetInvalid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetInvalid(context.Background(), nil)
	if err == nil {
		t.Fatal("unexpected nil error")
	}
	if !reflect.ValueOf(resp).IsZero() {
		t.Fatal("expected empty response")
	}
}
func TestGetLongInvalidNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetLongInvalidNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.Int64Array, []*int64{
		to.Int64Ptr(1),
		nil,
		to.Int64Ptr(0),
	}); r != "" {
		t.Fatal(r)
	}
}
func TestGetLongInvalidString(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetLongInvalidString(context.Background(), nil)
	if err == nil {
		t.Fatal("unexpected nil error")
	}
	if !reflect.ValueOf(resp).IsZero() {
		t.Fatal("expected empty response")
	}
}
func TestGetLongValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetLongValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.Int64Array, to.Int64PtrArray(1, -1, 3, 300)); r != "" {
		t.Fatal(r)
	}
}
func TestGetNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if resp.Int32Array != nil {
		t.Fatal("expected nil array")
	}
}
func TestGetStringEnumValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetStringEnumValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.Enum0Array, []*Enum0{
		Enum0Foo1.ToPtr(), Enum0Foo2.ToPtr(), Enum0Foo3.ToPtr()}); r != "" {
		t.Fatal(r)
	}
}
func TestGetStringValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetStringValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.StringArray, to.StringPtrArray("foo1", "foo2", "foo3")); r != "" {
		t.Fatal(r)
	}
}
func TestGetStringWithInvalid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetStringWithInvalid(context.Background(), nil)
	if err == nil {
		t.Fatal("unexpected nil error")
	}
	if !reflect.ValueOf(resp).IsZero() {
		t.Fatal("expected empty response")
	}
}
func TestGetStringWithNull(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetStringWithNull(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.StringArray, []*string{to.StringPtr("foo"), nil, to.StringPtr("foo2")}); r != "" {
		t.Fatal(r)
	}
}
func TestGetUUIDInvalidChars(t *testing.T) {
	t.Skip("no strongly-typed UUID")
}
func TestGetUUIDValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.GetUUIDValid(context.Background(), nil)
	if err != nil {
		t.Fatal(err)
	}
	if r := cmp.Diff(resp.StringArray, to.StringPtrArray("6dcc7237-45fe-45c4-8a6b-3a8a3f625652", "d1399005-30f7-40d6-8da6-dd7c89ad34db", "f42f6aa1-a5bc-4ddf-907e-5f915de43205")); r != "" {
		t.Fatal(r)
	}
}
func TestPutArrayValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.PutArrayValid(context.Background(), [][]*string{
		to.StringPtrArray("1", "2", "3"),
		to.StringPtrArray("4", "5", "6"),
		to.StringPtrArray("7", "8", "9"),
	}, nil)
	if err != nil {
		t.Fatal(err)
	}
	if s := resp.RawResponse.StatusCode; s != http.StatusOK {
		t.Fatalf("unexpected status code %d", s)
	}
}
func TestPutBooleanTfft(t *testing.T) {
	client := newArrayClient()
	resp, err := client.PutBooleanTfft(context.Background(), to.BoolPtrArray(true, false, false, true), nil)
	if err != nil {
		t.Fatal(err)
	}
	if s := resp.RawResponse.StatusCode; s != http.StatusOK {
		t.Fatalf("unexpected status code %d", s)
	}
}
func TestPutByteValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.PutByteValid(context.Background(), [][]byte{
		{0xFF, 0xFF, 0xFF, 0xFA},
		{0x01, 0x02, 0x03},
		{0x25, 0x29, 0x43},
	}, nil)
	if err != nil {
		t.Fatal(err)
	}
	if s := resp.RawResponse.StatusCode; s != http.StatusOK {
		t.Fatalf("unexpected status code %d", s)
	}
}
func TestPutComplexValid(t *testing.T) {
	client := newArrayClient()
	resp, err := client.PutComplexValid(context.Background(), []*Product{
		{Integer: to.Int32Ptr(1), String: to.StringPtr("2")},
		{Integer: to.Int32Ptr(3), String: to.StringPtr("4")},
		{Integer: to.Int32Ptr(5), String: to.StringPtr("6")},
	}, nil)
	if err != nil {
		t.Fatal(err)
	}
	if s := resp.RawResponse.StatusCode; s != http.StatusOK {
		t.Fatalf("unexpected status code %d", s)
	}
}
func TestPutDateTimeRFC1123Valid(t *testing.T) {
	client := newArrayClient()
	v1, _ := time.Parse(time.RFC1123, "Fri, 01 Dec 2000 00:00:01 GMT")
	v2, _ := time.Parse(time.RFC1123, "Wed, 02 Jan 1980 00:11:35 GMT")
	v3, _ := time.Parse(time.RFC1123, "Wed, 12 Oct 1492 10:15:01 GMT")
	resp, err := client.PutDateTimeRFC1123Valid(context.Background(), []*time.Time{&v1, &v2, &v3}, nil)
	if err != nil {
		t.Fatal(err)
	}
	if s := resp.RawResponse.StatusCode; s != http.StatusOK {
		t.Fatalf("unexpected status code %d", s)
	}
}
func TestPutDateTimeValid(t *testing.T) {
	client := newArrayClient()
	v1, _ := time.Parse(time.RFC3339, "2000-12-01T00:00:01Z")
	v2, _ := time.Parse(time.RFC3339, "1980-01-02T00:11:35Z")
	v3, _ := time.Parse(time.RFC3339, "1492-10-12T10:15:01Z")
	resp, err := client.PutDateTimeValid(context.Background(), []*time.Time{&v1, &v2, &v3}, nil)
	if err != nil {
		t.Fatal(err)
	}
	if s := resp.RawResponse.StatusCode; s != http.StatusOK {
		t.Fatalf("unexpected status code %d", s)
	}
}