From 156eb63cda004ef301c45c57369061125b8a0515 Mon Sep 17 00:00:00 2001 From: Jason Song Date: Wed, 14 Oct 2020 15:01:46 +0800 Subject: [PATCH 1/2] feat: Clone --- gen_int64_seq.go | 7 +++++++ gen_int64_seq_test.go | 30 ++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+) diff --git a/gen_int64_seq.go b/gen_int64_seq.go index 380f251..000827a 100644 --- a/gen_int64_seq.go +++ b/gen_int64_seq.go @@ -386,3 +386,10 @@ func (s *Int64Seq) Trim(fn func(i int, v Int64) bool) error { } return nil } + +func (s *Int64Seq) Clone() *Int64Seq { + if s == nil { + return nil + } + return newInt64Seq(s.slice) +} diff --git a/gen_int64_seq_test.go b/gen_int64_seq_test.go index 7ce82cc..48358b5 100644 --- a/gen_int64_seq_test.go +++ b/gen_int64_seq_test.go @@ -923,3 +923,33 @@ func TestInt64Seq_Trim(t *testing.T) { }) } } + +func TestInt64Seq_Clone(t *testing.T) { + data := RandomInt64s(10) + Sort(data) + tests := []struct { + name string + seq *Int64Seq + want *Int64Seq + }{ + { + name: "regular", + seq: NewInt64Seq(data), + want: &Int64Seq{ + slice: data, + }, + }, + { + name: "nil", + seq: nil, + want: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.seq.Clone(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Clone() = %v, want %v", got, tt.want) + } + }) + } +} From 9be15abc8947a3c91a7ac80a23c9b88388e6add5 Mon Sep 17 00:00:00 2001 From: Jason Song Date: Wed, 14 Oct 2020 15:03:07 +0800 Subject: [PATCH 2/2] chore: generate --- cmd/generate/gen_x_seq.go.tmpl | 7 +++++++ cmd/generate/gen_x_seq_test.go.tmpl | 30 +++++++++++++++++++++++++++++ gen_float64_seq.go | 7 +++++++ gen_float64_seq_test.go | 30 +++++++++++++++++++++++++++++ gen_int_seq.go | 7 +++++++ gen_int_seq_test.go | 30 +++++++++++++++++++++++++++++ gen_uint64_seq.go | 7 +++++++ gen_uint64_seq_test.go | 30 +++++++++++++++++++++++++++++ 8 files changed, 148 insertions(+) diff --git a/cmd/generate/gen_x_seq.go.tmpl b/cmd/generate/gen_x_seq.go.tmpl index d02efba..fc55be5 100644 --- a/cmd/generate/gen_x_seq.go.tmpl +++ b/cmd/generate/gen_x_seq.go.tmpl @@ -384,3 +384,10 @@ func (s *{{.Name}}Seq) Trim(fn func(i int, v {{.Name}}) bool) error { } return nil } + +func (s *{{.Name}}Seq) Clone() *{{.Name}}Seq { + if s == nil { + return nil + } + return new{{.Name}}Seq(s.slice) +} diff --git a/cmd/generate/gen_x_seq_test.go.tmpl b/cmd/generate/gen_x_seq_test.go.tmpl index e90d81c..e31b2f2 100644 --- a/cmd/generate/gen_x_seq_test.go.tmpl +++ b/cmd/generate/gen_x_seq_test.go.tmpl @@ -921,3 +921,33 @@ func Test{{.Name}}Seq_Trim(t *testing.T) { }) } } + +func Test{{.Name}}Seq_Clone(t *testing.T) { + data := Random{{.Name}}s(10) + Sort(data) + tests := []struct { + name string + seq *{{.Name}}Seq + want *{{.Name}}Seq + }{ + { + name: "regular", + seq: New{{.Name}}Seq(data), + want: &{{.Name}}Seq{ + slice: data, + }, + }, + { + name: "nil", + seq: nil, + want: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.seq.Clone(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Clone() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/gen_float64_seq.go b/gen_float64_seq.go index 3dcbfb6..02220a5 100644 --- a/gen_float64_seq.go +++ b/gen_float64_seq.go @@ -386,3 +386,10 @@ func (s *Float64Seq) Trim(fn func(i int, v Float64) bool) error { } return nil } + +func (s *Float64Seq) Clone() *Float64Seq { + if s == nil { + return nil + } + return newFloat64Seq(s.slice) +} diff --git a/gen_float64_seq_test.go b/gen_float64_seq_test.go index 95b6f70..8d5658c 100644 --- a/gen_float64_seq_test.go +++ b/gen_float64_seq_test.go @@ -923,3 +923,33 @@ func TestFloat64Seq_Trim(t *testing.T) { }) } } + +func TestFloat64Seq_Clone(t *testing.T) { + data := RandomFloat64s(10) + Sort(data) + tests := []struct { + name string + seq *Float64Seq + want *Float64Seq + }{ + { + name: "regular", + seq: NewFloat64Seq(data), + want: &Float64Seq{ + slice: data, + }, + }, + { + name: "nil", + seq: nil, + want: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.seq.Clone(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Clone() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/gen_int_seq.go b/gen_int_seq.go index 105558c..e56c2f2 100644 --- a/gen_int_seq.go +++ b/gen_int_seq.go @@ -386,3 +386,10 @@ func (s *IntSeq) Trim(fn func(i int, v Int) bool) error { } return nil } + +func (s *IntSeq) Clone() *IntSeq { + if s == nil { + return nil + } + return newIntSeq(s.slice) +} diff --git a/gen_int_seq_test.go b/gen_int_seq_test.go index fcb4236..249274b 100644 --- a/gen_int_seq_test.go +++ b/gen_int_seq_test.go @@ -923,3 +923,33 @@ func TestIntSeq_Trim(t *testing.T) { }) } } + +func TestIntSeq_Clone(t *testing.T) { + data := RandomInts(10) + Sort(data) + tests := []struct { + name string + seq *IntSeq + want *IntSeq + }{ + { + name: "regular", + seq: NewIntSeq(data), + want: &IntSeq{ + slice: data, + }, + }, + { + name: "nil", + seq: nil, + want: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.seq.Clone(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Clone() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/gen_uint64_seq.go b/gen_uint64_seq.go index 63ce06f..94fe662 100644 --- a/gen_uint64_seq.go +++ b/gen_uint64_seq.go @@ -386,3 +386,10 @@ func (s *Uint64Seq) Trim(fn func(i int, v Uint64) bool) error { } return nil } + +func (s *Uint64Seq) Clone() *Uint64Seq { + if s == nil { + return nil + } + return newUint64Seq(s.slice) +} diff --git a/gen_uint64_seq_test.go b/gen_uint64_seq_test.go index 9ff3269..1e96625 100644 --- a/gen_uint64_seq_test.go +++ b/gen_uint64_seq_test.go @@ -923,3 +923,33 @@ func TestUint64Seq_Trim(t *testing.T) { }) } } + +func TestUint64Seq_Clone(t *testing.T) { + data := RandomUint64s(10) + Sort(data) + tests := []struct { + name string + seq *Uint64Seq + want *Uint64Seq + }{ + { + name: "regular", + seq: NewUint64Seq(data), + want: &Uint64Seq{ + slice: data, + }, + }, + { + name: "nil", + seq: nil, + want: nil, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.seq.Clone(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Clone() = %v, want %v", got, tt.want) + } + }) + } +}