mirror of https://github.com/stretchr/testify.git
287 lines
6.7 KiB
Plaintext
287 lines
6.7 KiB
Plaintext
/*
|
|
{4} ({1} and []{1})
|
|
--------------------------------------------------
|
|
*/
|
|
|
|
// {4} gets the value as a {1}, returns the optionalDefault
|
|
// value or a system default object if the value is the wrong type.
|
|
func (v *Value) {4}(optionalDefault ...{1}) {1} {
|
|
if s, ok := v.data.({1}); ok {
|
|
return s
|
|
}
|
|
if len(optionalDefault) == 1 {
|
|
return optionalDefault[0]
|
|
}
|
|
return {3}
|
|
}
|
|
|
|
// Must{4} gets the value as a {1}.
|
|
//
|
|
// Panics if the object is not a {1}.
|
|
func (v *Value) Must{4}() {1} {
|
|
return v.data.({1})
|
|
}
|
|
|
|
// {4}Slice gets the value as a []{1}, returns the optionalDefault
|
|
// value or nil if the value is not a []{1}.
|
|
func (v *Value) {4}Slice(optionalDefault ...[]{1}) []{1} {
|
|
if s, ok := v.data.([]{1}); ok {
|
|
return s
|
|
}
|
|
if len(optionalDefault) == 1 {
|
|
return optionalDefault[0]
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Must{4}Slice gets the value as a []{1}.
|
|
//
|
|
// Panics if the object is not a []{1}.
|
|
func (v *Value) Must{4}Slice() []{1} {
|
|
return v.data.([]{1})
|
|
}
|
|
|
|
// Is{4} gets whether the object contained is a {1} or not.
|
|
func (v *Value) Is{4}() bool {
|
|
_, ok := v.data.({1})
|
|
return ok
|
|
}
|
|
|
|
// Is{4}Slice gets whether the object contained is a []{1} or not.
|
|
func (v *Value) Is{4}Slice() bool {
|
|
_, ok := v.data.([]{1})
|
|
return ok
|
|
}
|
|
|
|
// Each{4} calls the specified callback for each object
|
|
// in the []{1}.
|
|
//
|
|
// Panics if the object is the wrong type.
|
|
func (v *Value) Each{4}(callback func(int, {1}) bool) *Value {
|
|
|
|
for index, val := range v.Must{4}Slice() {
|
|
carryon := callback(index, val)
|
|
if carryon == false {
|
|
break
|
|
}
|
|
}
|
|
|
|
return v
|
|
|
|
}
|
|
|
|
// Where{4} uses the specified decider function to select items
|
|
// from the []{1}. The object contained in the result will contain
|
|
// only the selected items.
|
|
func (v *Value) Where{4}(decider func(int, {1}) bool) *Value {
|
|
|
|
var selected []{1}
|
|
|
|
v.Each{4}(func(index int, val {1}) bool {
|
|
shouldSelect := decider(index, val)
|
|
if shouldSelect == false {
|
|
selected = append(selected, val)
|
|
}
|
|
return true
|
|
})
|
|
|
|
return &Value{data:selected}
|
|
|
|
}
|
|
|
|
// Group{4} uses the specified grouper function to group the items
|
|
// keyed by the return of the grouper. The object contained in the
|
|
// result will contain a map[string][]{1}.
|
|
func (v *Value) Group{4}(grouper func(int, {1}) string) *Value {
|
|
|
|
groups := make(map[string][]{1})
|
|
|
|
v.Each{4}(func(index int, val {1}) bool {
|
|
group := grouper(index, val)
|
|
if _, ok := groups[group]; !ok {
|
|
groups[group] = make([]{1}, 0)
|
|
}
|
|
groups[group] = append(groups[group], val)
|
|
return true
|
|
})
|
|
|
|
return &Value{data:groups}
|
|
|
|
}
|
|
|
|
// Replace{4} uses the specified function to replace each {1}s
|
|
// by iterating each item. The data in the returned result will be a
|
|
// []{1} containing the replaced items.
|
|
func (v *Value) Replace{4}(replacer func(int, {1}) {1}) *Value {
|
|
|
|
arr := v.Must{4}Slice()
|
|
replaced := make([]{1}, len(arr))
|
|
|
|
v.Each{4}(func(index int, val {1}) bool {
|
|
replaced[index] = replacer(index, val)
|
|
return true
|
|
})
|
|
|
|
return &Value{data:replaced}
|
|
|
|
}
|
|
|
|
// Collect{4} uses the specified collector function to collect a value
|
|
// for each of the {1}s in the slice. The data returned will be a
|
|
// []interface{}.
|
|
func (v *Value) Collect{4}(collector func(int, {1}) interface{}) *Value {
|
|
|
|
arr := v.Must{4}Slice()
|
|
collected := make([]interface{}, len(arr))
|
|
|
|
v.Each{4}(func(index int, val {1}) bool {
|
|
collected[index] = collector(index, val)
|
|
return true
|
|
})
|
|
|
|
return &Value{data:collected}
|
|
}
|
|
|
|
// ************************************************************
|
|
// TESTS
|
|
// ************************************************************
|
|
|
|
func Test{4}(t *testing.T) {
|
|
|
|
val := {1}( {2} )
|
|
m := map[string]interface{}{"value": val, "nothing": nil}
|
|
assert.Equal(t, val, New(m).Get("value").{4}())
|
|
assert.Equal(t, val, New(m).Get("value").Must{4}())
|
|
assert.Equal(t, {1}({3}), New(m).Get("nothing").{4}())
|
|
assert.Equal(t, val, New(m).Get("nothing").{4}({2}))
|
|
|
|
assert.Panics(t, func() {
|
|
New(m).Get("age").Must{4}()
|
|
})
|
|
|
|
}
|
|
|
|
func Test{4}Slice(t *testing.T) {
|
|
|
|
val := {1}( {2} )
|
|
m := map[string]interface{}{"value": []{1}{ val }, "nothing": nil}
|
|
assert.Equal(t, val, New(m).Get("value").{4}Slice()[0])
|
|
assert.Equal(t, val, New(m).Get("value").Must{4}Slice()[0])
|
|
assert.Equal(t, []{1}(nil), New(m).Get("nothing").{4}Slice())
|
|
assert.Equal(t, val, New(m).Get("nothing").{4}Slice( []{1}{ {1}({2}) } )[0])
|
|
|
|
assert.Panics(t, func() {
|
|
New(m).Get("nothing").Must{4}Slice()
|
|
})
|
|
|
|
}
|
|
|
|
func TestIs{4}(t *testing.T) {
|
|
|
|
var v *Value
|
|
|
|
v = &Value{data: {1}({2})}
|
|
assert.True(t, v.Is{4}())
|
|
|
|
v = &Value{data: []{1}{ {1}({2}) }}
|
|
assert.True(t, v.Is{4}Slice())
|
|
|
|
}
|
|
|
|
func TestEach{4}(t *testing.T) {
|
|
|
|
v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
|
|
count := 0
|
|
replacedVals := make([]{1}, 0)
|
|
assert.Equal(t, v, v.Each{4}(func(i int, val {1}) bool {
|
|
|
|
count++
|
|
replacedVals = append(replacedVals, val)
|
|
|
|
// abort early
|
|
if i == 2 {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
|
|
}))
|
|
|
|
assert.Equal(t, count, 3)
|
|
assert.Equal(t, replacedVals[0], v.Must{4}Slice()[0])
|
|
assert.Equal(t, replacedVals[1], v.Must{4}Slice()[1])
|
|
assert.Equal(t, replacedVals[2], v.Must{4}Slice()[2])
|
|
|
|
}
|
|
|
|
func TestWhere{4}(t *testing.T) {
|
|
|
|
v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
|
|
|
|
selected := v.Where{4}(func(i int, val {1}) bool {
|
|
return i%2==0
|
|
}).Must{4}Slice()
|
|
|
|
assert.Equal(t, 3, len(selected))
|
|
|
|
}
|
|
|
|
func TestGroup{4}(t *testing.T) {
|
|
|
|
v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
|
|
|
|
grouped := v.Group{4}(func(i int, val {1}) string {
|
|
return fmt.Sprintf("%v", i%2==0)
|
|
}).data.(map[string][]{1})
|
|
|
|
assert.Equal(t, 2, len(grouped))
|
|
assert.Equal(t, 3, len(grouped["true"]))
|
|
assert.Equal(t, 3, len(grouped["false"]))
|
|
|
|
}
|
|
|
|
func TestReplace{4}(t *testing.T) {
|
|
|
|
v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
|
|
|
|
rawArr := v.Must{4}Slice()
|
|
|
|
replaced := v.Replace{4}(func(index int, val {1}) {1} {
|
|
if index < len(rawArr)-1 {
|
|
return rawArr[index+1]
|
|
}
|
|
return rawArr[0]
|
|
})
|
|
|
|
replacedArr := replaced.Must{4}Slice()
|
|
if assert.Equal(t, 6, len(replacedArr)) {
|
|
assert.Equal(t, replacedArr[0], rawArr[1])
|
|
assert.Equal(t, replacedArr[1], rawArr[2])
|
|
assert.Equal(t, replacedArr[2], rawArr[3])
|
|
assert.Equal(t, replacedArr[3], rawArr[4])
|
|
assert.Equal(t, replacedArr[4], rawArr[5])
|
|
assert.Equal(t, replacedArr[5], rawArr[0])
|
|
}
|
|
|
|
}
|
|
|
|
func TestCollect{4}(t *testing.T) {
|
|
|
|
v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
|
|
|
|
collected := v.Collect{4}(func(index int, val {1}) interface{} {
|
|
return index
|
|
})
|
|
|
|
collectedArr := collected.MustInterSlice()
|
|
if assert.Equal(t, 6, len(collectedArr)) {
|
|
assert.Equal(t, collectedArr[0], 0)
|
|
assert.Equal(t, collectedArr[1], 1)
|
|
assert.Equal(t, collectedArr[2], 2)
|
|
assert.Equal(t, collectedArr[3], 3)
|
|
assert.Equal(t, collectedArr[4], 4)
|
|
assert.Equal(t, collectedArr[5], 5)
|
|
}
|
|
|
|
}
|