diff --git a/cmd/generate/gen_x_seq_test.go.tmpl b/cmd/generate/gen_x_seq_test.go.tmpl
index 101e224..f6bf9dd 100644
--- a/cmd/generate/gen_x_seq_test.go.tmpl
+++ b/cmd/generate/gen_x_seq_test.go.tmpl
@@ -825,6 +825,60 @@ func Test{{.Name}}Seq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice {{.Name}}s) *{{.Type}} {
+					ret := {{.Type}}(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice {{.Name}}s) *{{.Type}} {
+					ret := {{.Type}}(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice {{.Name}}s) *{{.Type}} {
+					ret := {{.Type}}(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/gen_float32_seq_test.go b/gen_float32_seq_test.go
index 835854e..2051be2 100644
--- a/gen_float32_seq_test.go
+++ b/gen_float32_seq_test.go
@@ -827,6 +827,60 @@ func TestFloat32Seq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Float32s) *float32 {
+					ret := float32(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Float32s) *float32 {
+					ret := float32(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice Float32s) *float32 {
+					ret := float32(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/gen_float64_seq_test.go b/gen_float64_seq_test.go
index 0cbe7a2..58ade60 100644
--- a/gen_float64_seq_test.go
+++ b/gen_float64_seq_test.go
@@ -827,6 +827,60 @@ func TestFloat64Seq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Float64s) *float64 {
+					ret := float64(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Float64s) *float64 {
+					ret := float64(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice Float64s) *float64 {
+					ret := float64(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/gen_int16_seq_test.go b/gen_int16_seq_test.go
index a3beb12..b4ce47e 100644
--- a/gen_int16_seq_test.go
+++ b/gen_int16_seq_test.go
@@ -827,6 +827,60 @@ func TestInt16Seq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Int16s) *int16 {
+					ret := int16(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Int16s) *int16 {
+					ret := int16(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice Int16s) *int16 {
+					ret := int16(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/gen_int32_seq_test.go b/gen_int32_seq_test.go
index 8df6349..35ac3cf 100644
--- a/gen_int32_seq_test.go
+++ b/gen_int32_seq_test.go
@@ -827,6 +827,60 @@ func TestInt32Seq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Int32s) *int32 {
+					ret := int32(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Int32s) *int32 {
+					ret := int32(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice Int32s) *int32 {
+					ret := int32(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/gen_int64_seq_test.go b/gen_int64_seq_test.go
index 6731629..293ed81 100644
--- a/gen_int64_seq_test.go
+++ b/gen_int64_seq_test.go
@@ -827,6 +827,60 @@ func TestInt64Seq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Int64s) *int64 {
+					ret := int64(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Int64s) *int64 {
+					ret := int64(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice Int64s) *int64 {
+					ret := int64(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/gen_int8_seq_test.go b/gen_int8_seq_test.go
index df8d9f9..ae2c8d6 100644
--- a/gen_int8_seq_test.go
+++ b/gen_int8_seq_test.go
@@ -827,6 +827,60 @@ func TestInt8Seq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Int8s) *int8 {
+					ret := int8(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Int8s) *int8 {
+					ret := int8(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice Int8s) *int8 {
+					ret := int8(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/gen_int_seq_test.go b/gen_int_seq_test.go
index 5f44ca8..d9897c5 100644
--- a/gen_int_seq_test.go
+++ b/gen_int_seq_test.go
@@ -827,6 +827,60 @@ func TestIntSeq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Ints) *int {
+					ret := int(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Ints) *int {
+					ret := int(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice Ints) *int {
+					ret := int(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/gen_uint16_seq_test.go b/gen_uint16_seq_test.go
index b3a7760..5442f6c 100644
--- a/gen_uint16_seq_test.go
+++ b/gen_uint16_seq_test.go
@@ -827,6 +827,60 @@ func TestUint16Seq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Uint16s) *uint16 {
+					ret := uint16(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Uint16s) *uint16 {
+					ret := uint16(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice Uint16s) *uint16 {
+					ret := uint16(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/gen_uint32_seq_test.go b/gen_uint32_seq_test.go
index 4a7d81f..e6829c6 100644
--- a/gen_uint32_seq_test.go
+++ b/gen_uint32_seq_test.go
@@ -827,6 +827,60 @@ func TestUint32Seq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Uint32s) *uint32 {
+					ret := uint32(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Uint32s) *uint32 {
+					ret := uint32(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice Uint32s) *uint32 {
+					ret := uint32(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/gen_uint64_seq_test.go b/gen_uint64_seq_test.go
index f9ab332..d7be2c1 100644
--- a/gen_uint64_seq_test.go
+++ b/gen_uint64_seq_test.go
@@ -827,6 +827,60 @@ func TestUint64Seq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Uint64s) *uint64 {
+					ret := uint64(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Uint64s) *uint64 {
+					ret := uint64(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice Uint64s) *uint64 {
+					ret := uint64(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/gen_uint8_seq_test.go b/gen_uint8_seq_test.go
index 493f4ac..e5d9011 100644
--- a/gen_uint8_seq_test.go
+++ b/gen_uint8_seq_test.go
@@ -827,6 +827,60 @@ func TestUint8Seq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Uint8s) *uint8 {
+					ret := uint8(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Uint8s) *uint8 {
+					ret := uint8(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice Uint8s) *uint8 {
+					ret := uint8(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/gen_uint_seq_test.go b/gen_uint_seq_test.go
index d94ba01..4b5c973 100644
--- a/gen_uint_seq_test.go
+++ b/gen_uint_seq_test.go
@@ -827,6 +827,60 @@ func TestUintSeq_Aggregate(t *testing.T) {
 			},
 			wantErr: false,
 		},
+		{
+			name: "shorter interval with zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Uints) *uint {
+					ret := uint(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: 0,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "shorter interval with non zero duraion",
+			args: args{
+				fn: func(t time.Time, slice Uints) *uint {
+					ret := uint(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: BeginAt(now).EndAt(end),
+			},
+			wantErr: false,
+		},
+		{
+			name: "miss begin",
+			args: args{
+				fn: func(t time.Time, slice Uints) *uint {
+					ret := uint(t.Hour())
+					if len(slice) != 0 {
+						ret = 0
+					}
+					for _, v := range slice {
+						ret += v.Value
+					}
+					return &ret
+				},
+				duration: time.Minute,
+				interval: EndAt(end),
+			},
+			wantErr: false,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
diff --git a/interval_test.go b/interval_test.go
index 6768b0d..b4f9052 100644
--- a/interval_test.go
+++ b/interval_test.go
@@ -121,6 +121,14 @@ func TestInterval_Contain(t *testing.T) {
 			},
 			want: false,
 		},
+		{
+			name:     "EndAt",
+			interval: EndAt(now),
+			args: args{
+				t: now,
+			},
+			want: true,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {