clear_gen_test.go

package hit_test

import (
	"testing"

	"errors"

	. "github.com/Eun/go-hit"
	"github.com/stretchr/testify/require"
)

// ⚠️⚠️⚠️ This file was autogenerated by generators/clear/tests ⚠️⚠️⚠️ //

func storeSteps(steps *[]IStep) IStep {
	return Custom(StepTime(CleanStep), func(hit Hit) error {
		*steps = hit.Steps()
		return nil
	})
}
func expectSteps(t *testing.T, expectSteps *[]IStep, removedStepsCount int) IStep {
	return Custom(BeforeExpectStep, func(hit Hit) error {
		require.Len(t, hit.Steps(), len(*expectSteps)-removedStepsCount)
		return errors.New("TestOK")
	})
}

func TestGenClear_Generic_Send(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Bool(false),
			Send().Body().Bool(true),
			storeSteps(&steps),
			Clear().Send(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send()),
		PtrStr("unable to find a step with Send()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_SendBody(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Bool(false),
			Send().Body().Bool(true),
			storeSteps(&steps),
			Clear().Send().Body(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body()),
		PtrStr("unable to find a step with Send().Body()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_SendBodyBool(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Bool(false),
			Send().Body().Bool(true),
			storeSteps(&steps),
			Clear().Send().Body().Bool(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Bool()),
		PtrStr("unable to find a step with Send().Body().Bool()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyBool(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Bool(false),
			Send().Body().Bool(true),
			storeSteps(&steps),
			Clear().Send().Body().Bool(false),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyBytes(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Bytes([]uint8{0x1, 0x2}),
			Send().Body().Bytes([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Send().Body().Bytes(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Bytes()),
		PtrStr("unable to find a step with Send().Body().Bytes()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyBytes(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Bytes([]uint8{0x1, 0x2}),
			Send().Body().Bytes([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Send().Body().Bytes([]uint8{0x1, 0x2}),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyFloat32(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Float32(1.000000),
			Send().Body().Float32(3.000000),
			storeSteps(&steps),
			Clear().Send().Body().Float32(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Float32()),
		PtrStr("unable to find a step with Send().Body().Float32()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyFloat32(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Float32(1.000000),
			Send().Body().Float32(3.000000),
			storeSteps(&steps),
			Clear().Send().Body().Float32(1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyFloat64(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Float64(1.000000),
			Send().Body().Float64(3.000000),
			storeSteps(&steps),
			Clear().Send().Body().Float64(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Float64()),
		PtrStr("unable to find a step with Send().Body().Float64()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyFloat64(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Float64(1.000000),
			Send().Body().Float64(3.000000),
			storeSteps(&steps),
			Clear().Send().Body().Float64(1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyFormValues(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().FormValues("Foo-Bar").Add("Foo", "Baz"),
			Send().Body().FormValues("Hello-World").Add("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Send().Body().FormValues(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().FormValues()),
		PtrStr("unable to find a step with Send().Body().FormValues()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_SendBodyFormValuesAdd(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().FormValues("Foo-Bar").Add("Foo", "Baz"),
			Send().Body().FormValues("Hello-World").Add("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Send().Body().FormValues().Add(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().FormValues().Add()),
		PtrStr("unable to find a step with Send().Body().FormValues().Add()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyFormValuesAdd(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().FormValues("Foo-Bar").Add("Foo", "Baz"),
			Send().Body().FormValues("Hello-World").Add("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Send().Body().FormValues("Foo-Bar").Add("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyInt(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Int(2),
			Send().Body().Int(3),
			storeSteps(&steps),
			Clear().Send().Body().Int(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Int()),
		PtrStr("unable to find a step with Send().Body().Int()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyInt(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Int(2),
			Send().Body().Int(3),
			storeSteps(&steps),
			Clear().Send().Body().Int(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyInt16(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Int16(2),
			Send().Body().Int16(3),
			storeSteps(&steps),
			Clear().Send().Body().Int16(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Int16()),
		PtrStr("unable to find a step with Send().Body().Int16()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyInt16(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Int16(2),
			Send().Body().Int16(3),
			storeSteps(&steps),
			Clear().Send().Body().Int16(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyInt32(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Int32(2),
			Send().Body().Int32(3),
			storeSteps(&steps),
			Clear().Send().Body().Int32(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Int32()),
		PtrStr("unable to find a step with Send().Body().Int32()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyInt32(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Int32(2),
			Send().Body().Int32(3),
			storeSteps(&steps),
			Clear().Send().Body().Int32(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyInt64(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Int64(2),
			Send().Body().Int64(3),
			storeSteps(&steps),
			Clear().Send().Body().Int64(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Int64()),
		PtrStr("unable to find a step with Send().Body().Int64()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyInt64(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Int64(2),
			Send().Body().Int64(3),
			storeSteps(&steps),
			Clear().Send().Body().Int64(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyInt8(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Int8(2),
			Send().Body().Int8(3),
			storeSteps(&steps),
			Clear().Send().Body().Int8(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Int8()),
		PtrStr("unable to find a step with Send().Body().Int8()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyInt8(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Int8(2),
			Send().Body().Int8(3),
			storeSteps(&steps),
			Clear().Send().Body().Int8(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyJSON(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().JSON("Foo-Taz"),
			Send().Body().JSON("Hello-Universe"),
			storeSteps(&steps),
			Clear().Send().Body().JSON(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().JSON()),
		PtrStr("unable to find a step with Send().Body().JSON()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyJSON(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().JSON("Foo-Taz"),
			Send().Body().JSON("Hello-Universe"),
			storeSteps(&steps),
			Clear().Send().Body().JSON("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyString(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().String("Foo-Bar"),
			Send().Body().String("Hello-World"),
			storeSteps(&steps),
			Clear().Send().Body().String(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().String()),
		PtrStr("unable to find a step with Send().Body().String()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyString(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().String("Foo-Bar"),
			Send().Body().String("Hello-World"),
			storeSteps(&steps),
			Clear().Send().Body().String("Foo-Bar"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyUint(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Uint(0x2),
			Send().Body().Uint(0x3),
			storeSteps(&steps),
			Clear().Send().Body().Uint(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Uint()),
		PtrStr("unable to find a step with Send().Body().Uint()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyUint(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Uint(0x2),
			Send().Body().Uint(0x3),
			storeSteps(&steps),
			Clear().Send().Body().Uint(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyUint16(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Uint16(0x2),
			Send().Body().Uint16(0x3),
			storeSteps(&steps),
			Clear().Send().Body().Uint16(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Uint16()),
		PtrStr("unable to find a step with Send().Body().Uint16()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyUint16(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Uint16(0x2),
			Send().Body().Uint16(0x3),
			storeSteps(&steps),
			Clear().Send().Body().Uint16(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyUint32(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Uint32(0x2),
			Send().Body().Uint32(0x3),
			storeSteps(&steps),
			Clear().Send().Body().Uint32(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Uint32()),
		PtrStr("unable to find a step with Send().Body().Uint32()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyUint32(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Uint32(0x2),
			Send().Body().Uint32(0x3),
			storeSteps(&steps),
			Clear().Send().Body().Uint32(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyUint64(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Uint64(0x2),
			Send().Body().Uint64(0x3),
			storeSteps(&steps),
			Clear().Send().Body().Uint64(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Uint64()),
		PtrStr("unable to find a step with Send().Body().Uint64()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyUint64(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Uint64(0x2),
			Send().Body().Uint64(0x3),
			storeSteps(&steps),
			Clear().Send().Body().Uint64(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyUint8(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Uint8(0x2),
			Send().Body().Uint8(0x3),
			storeSteps(&steps),
			Clear().Send().Body().Uint8(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().Uint8()),
		PtrStr("unable to find a step with Send().Body().Uint8()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyUint8(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().Uint8(0x2),
			Send().Body().Uint8(0x3),
			storeSteps(&steps),
			Clear().Send().Body().Uint8(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendBodyXML(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().XML("Foo-Taz"),
			Send().Body().XML("Hello-Universe"),
			storeSteps(&steps),
			Clear().Send().Body().XML(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Body().XML()),
		PtrStr("unable to find a step with Send().Body().XML()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendBodyXML(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Body().XML("Foo-Taz"),
			Send().Body().XML("Hello-Universe"),
			storeSteps(&steps),
			Clear().Send().Body().XML("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendHeaders(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Headers("Foo-Bar").Add("Foo", "Baz"),
			Send().Headers("Hello-World").Add("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Send().Headers(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Headers()),
		PtrStr("unable to find a step with Send().Headers()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_SendHeadersAdd(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Headers("Foo-Bar").Add("Foo", "Baz"),
			Send().Headers("Hello-World").Add("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Send().Headers().Add(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Headers().Add()),
		PtrStr("unable to find a step with Send().Headers().Add()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendHeadersAdd(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Headers("Foo-Bar").Add("Foo", "Baz"),
			Send().Headers("Hello-World").Add("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Send().Headers("Foo-Bar").Add("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_SendTrailers(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Trailers("Foo-Bar").Add("Foo", "Baz"),
			Send().Trailers("Hello-World").Add("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Send().Trailers(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Trailers()),
		PtrStr("unable to find a step with Send().Trailers()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_SendTrailersAdd(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Trailers("Foo-Bar").Add("Foo", "Baz"),
			Send().Trailers("Hello-World").Add("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Send().Trailers().Add(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Send().Trailers().Add()),
		PtrStr("unable to find a step with Send().Trailers().Add()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_SendTrailersAdd(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Send().Trailers("Foo-Bar").Add("Foo", "Baz"),
			Send().Trailers("Hello-World").Add("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Send().Trailers("Foo-Bar").Add("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_Expect(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Contains([]uint8{0x1, 0x2}),
			Expect().Body().Bytes().Contains([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Expect(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect()),
		PtrStr("unable to find a step with Expect()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBody(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Contains([]uint8{0x1, 0x2}),
			Expect().Body().Bytes().Contains([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Expect().Body(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body()),
		PtrStr("unable to find a step with Expect().Body()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyBytes(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Contains([]uint8{0x1, 0x2}),
			Expect().Body().Bytes().Contains([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes()),
		PtrStr("unable to find a step with Expect().Body().Bytes()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Contains([]uint8{0x1, 0x2}),
			Expect().Body().Bytes().Contains([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Contains()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Contains([]uint8{0x1, 0x2}),
			Expect().Body().Bytes().Contains([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Contains([]uint8{0x1, 0x2}),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Equal([]uint8{0x1, 0x2}),
			Expect().Body().Bytes().Equal([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Equal()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Equal([]uint8{0x1, 0x2}),
			Expect().Body().Bytes().Equal([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Equal([]uint8{0x1, 0x2}),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().Between(2, 2),
			Expect().Body().Bytes().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Len()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().Between(2, 2),
			Expect().Body().Bytes().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Len().Between()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().Between(2, 2),
			Expect().Body().Bytes().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().Equal(2),
			Expect().Body().Bytes().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Len().Equal()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().Equal(2),
			Expect().Body().Bytes().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().GreaterOrEqualThan(2),
			Expect().Body().Bytes().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().GreaterOrEqualThan(2),
			Expect().Body().Bytes().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().GreaterThan(2),
			Expect().Body().Bytes().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().GreaterThan(2),
			Expect().Body().Bytes().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().LessOrEqualThan(2),
			Expect().Body().Bytes().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().LessOrEqualThan(2),
			Expect().Body().Bytes().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().LessThan(2),
			Expect().Body().Bytes().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().LessThan(2),
			Expect().Body().Bytes().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().NotBetween(2, 2),
			Expect().Body().Bytes().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().NotBetween(2, 2),
			Expect().Body().Bytes().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().NotEqual(1, 2),
			Expect().Body().Bytes().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().NotEqual(1, 2),
			Expect().Body().Bytes().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().NotOneOf(1, 2),
			Expect().Body().Bytes().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().NotOneOf(1, 2),
			Expect().Body().Bytes().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().OneOf(1, 2),
			Expect().Body().Bytes().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Bytes().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().Len().OneOf(1, 2),
			Expect().Body().Bytes().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().NotContains([]uint8{0x1, 0x2}),
			Expect().Body().Bytes().NotContains([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().NotContains()),
		PtrStr("unable to find a step with Expect().Body().Bytes().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().NotContains([]uint8{0x1, 0x2}),
			Expect().Body().Bytes().NotContains([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().NotContains([]uint8{0x1, 0x2}),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyBytesNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().NotEqual([]uint8{0x1, 0x2}),
			Expect().Body().Bytes().NotEqual([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Bytes().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Bytes().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyBytesNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Bytes().NotEqual([]uint8{0x1, 0x2}),
			Expect().Body().Bytes().NotEqual([]uint8{0x3, 0x4}),
			storeSteps(&steps),
			Clear().Expect().Body().Bytes().NotEqual([]uint8{0x1, 0x2}),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat32(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().Between(1.000000, 1.000000),
			Expect().Body().Float32().Between(3.000000, 3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float32()),
		PtrStr("unable to find a step with Expect().Body().Float32()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat32Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().Between(1.000000, 1.000000),
			Expect().Body().Float32().Between(3.000000, 3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float32().Between()),
		PtrStr("unable to find a step with Expect().Body().Float32().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat32Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().Between(1.000000, 1.000000),
			Expect().Body().Float32().Between(3.000000, 3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().Between(1.000000, 1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat32Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().Equal(1.000000),
			Expect().Body().Float32().Equal(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float32().Equal()),
		PtrStr("unable to find a step with Expect().Body().Float32().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat32Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().Equal(1.000000),
			Expect().Body().Float32().Equal(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().Equal(1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat32GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().GreaterOrEqualThan(1.000000),
			Expect().Body().Float32().GreaterOrEqualThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float32().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Float32().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat32GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().GreaterOrEqualThan(1.000000),
			Expect().Body().Float32().GreaterOrEqualThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().GreaterOrEqualThan(1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat32GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().GreaterThan(1.000000),
			Expect().Body().Float32().GreaterThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float32().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Float32().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat32GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().GreaterThan(1.000000),
			Expect().Body().Float32().GreaterThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().GreaterThan(1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat32LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().LessOrEqualThan(1.000000),
			Expect().Body().Float32().LessOrEqualThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float32().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Float32().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat32LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().LessOrEqualThan(1.000000),
			Expect().Body().Float32().LessOrEqualThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().LessOrEqualThan(1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat32LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().LessThan(1.000000),
			Expect().Body().Float32().LessThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float32().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Float32().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat32LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().LessThan(1.000000),
			Expect().Body().Float32().LessThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().LessThan(1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat32NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().NotBetween(1.000000, 1.000000),
			Expect().Body().Float32().NotBetween(3.000000, 3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float32().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Float32().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat32NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().NotBetween(1.000000, 1.000000),
			Expect().Body().Float32().NotBetween(3.000000, 3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().NotBetween(1.000000, 1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat32NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().NotEqual(1.000000, 2.000000),
			Expect().Body().Float32().NotEqual(3.000000, 4.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float32().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Float32().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat32NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().NotEqual(1.000000, 2.000000),
			Expect().Body().Float32().NotEqual(3.000000, 4.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().NotEqual(1.000000, 2.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat32NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().NotOneOf(1.000000, 2.000000),
			Expect().Body().Float32().NotOneOf(3.000000, 4.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float32().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Float32().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat32NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().NotOneOf(1.000000, 2.000000),
			Expect().Body().Float32().NotOneOf(3.000000, 4.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().NotOneOf(1.000000, 2.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat32OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().OneOf(1.000000, 2.000000),
			Expect().Body().Float32().OneOf(3.000000, 4.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float32().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Float32().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat32OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float32().OneOf(1.000000, 2.000000),
			Expect().Body().Float32().OneOf(3.000000, 4.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float32().OneOf(1.000000, 2.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat64(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().Between(1.000000, 1.000000),
			Expect().Body().Float64().Between(3.000000, 3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float64()),
		PtrStr("unable to find a step with Expect().Body().Float64()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat64Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().Between(1.000000, 1.000000),
			Expect().Body().Float64().Between(3.000000, 3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float64().Between()),
		PtrStr("unable to find a step with Expect().Body().Float64().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat64Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().Between(1.000000, 1.000000),
			Expect().Body().Float64().Between(3.000000, 3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().Between(1.000000, 1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat64Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().Equal(1.000000),
			Expect().Body().Float64().Equal(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float64().Equal()),
		PtrStr("unable to find a step with Expect().Body().Float64().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat64Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().Equal(1.000000),
			Expect().Body().Float64().Equal(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().Equal(1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat64GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().GreaterOrEqualThan(1.000000),
			Expect().Body().Float64().GreaterOrEqualThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float64().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Float64().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat64GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().GreaterOrEqualThan(1.000000),
			Expect().Body().Float64().GreaterOrEqualThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().GreaterOrEqualThan(1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat64GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().GreaterThan(1.000000),
			Expect().Body().Float64().GreaterThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float64().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Float64().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat64GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().GreaterThan(1.000000),
			Expect().Body().Float64().GreaterThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().GreaterThan(1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat64LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().LessOrEqualThan(1.000000),
			Expect().Body().Float64().LessOrEqualThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float64().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Float64().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat64LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().LessOrEqualThan(1.000000),
			Expect().Body().Float64().LessOrEqualThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().LessOrEqualThan(1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat64LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().LessThan(1.000000),
			Expect().Body().Float64().LessThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float64().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Float64().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat64LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().LessThan(1.000000),
			Expect().Body().Float64().LessThan(3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().LessThan(1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat64NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().NotBetween(1.000000, 1.000000),
			Expect().Body().Float64().NotBetween(3.000000, 3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float64().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Float64().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat64NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().NotBetween(1.000000, 1.000000),
			Expect().Body().Float64().NotBetween(3.000000, 3.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().NotBetween(1.000000, 1.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat64NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().NotEqual(1.000000, 2.000000),
			Expect().Body().Float64().NotEqual(3.000000, 4.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float64().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Float64().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat64NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().NotEqual(1.000000, 2.000000),
			Expect().Body().Float64().NotEqual(3.000000, 4.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().NotEqual(1.000000, 2.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat64NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().NotOneOf(1.000000, 2.000000),
			Expect().Body().Float64().NotOneOf(3.000000, 4.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float64().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Float64().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat64NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().NotOneOf(1.000000, 2.000000),
			Expect().Body().Float64().NotOneOf(3.000000, 4.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().NotOneOf(1.000000, 2.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFloat64OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().OneOf(1.000000, 2.000000),
			Expect().Body().Float64().OneOf(3.000000, 4.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Float64().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Float64().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFloat64OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Float64().OneOf(1.000000, 2.000000),
			Expect().Body().Float64().OneOf(3.000000, 4.000000),
			storeSteps(&steps),
			Clear().Expect().Body().Float64().OneOf(1.000000, 2.000000),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValues(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Contains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues()),
		PtrStr("unable to find a step with Expect().Body().FormValues()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Contains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Contains()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Contains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Empty(),
			Expect().Body().FormValues("Hello-World").Empty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Empty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Empty()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Empty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Empty(),
			Expect().Body().FormValues("Hello-World").Empty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Empty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Equal("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Equal("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Equal()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Equal("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Equal("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Equal("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirst(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Contains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").First().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Contains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").First().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Contains()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Contains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").First().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Empty(),
			Expect().Body().FormValues("Hello-World").First().Empty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Empty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Empty()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Empty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Empty(),
			Expect().Body().FormValues("Hello-World").First().Empty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Empty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Equal("Foo-Taz"),
			Expect().Body().FormValues("Hello-World").First().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Equal()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Equal("Foo-Taz"),
			Expect().Body().FormValues("Hello-World").First().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Equal("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().Between(2, 2),
			Expect().Body().FormValues("Hello-World").First().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Len()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().Between(2, 2),
			Expect().Body().FormValues("Hello-World").First().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Len().Between()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().Between(2, 2),
			Expect().Body().FormValues("Hello-World").First().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().Equal(2),
			Expect().Body().FormValues("Hello-World").First().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Len().Equal()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().Equal(2),
			Expect().Body().FormValues("Hello-World").First().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().GreaterOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").First().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().GreaterOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").First().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().GreaterThan(2),
			Expect().Body().FormValues("Hello-World").First().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().GreaterThan(2),
			Expect().Body().FormValues("Hello-World").First().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().LessOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").First().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().LessOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").First().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().LessThan(2),
			Expect().Body().FormValues("Hello-World").First().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().LessThan(2),
			Expect().Body().FormValues("Hello-World").First().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().NotBetween(2, 2),
			Expect().Body().FormValues("Hello-World").First().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().NotBetween(2, 2),
			Expect().Body().FormValues("Hello-World").First().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().NotEqual(1, 2),
			Expect().Body().FormValues("Hello-World").First().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().NotEqual(1, 2),
			Expect().Body().FormValues("Hello-World").First().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().NotOneOf(1, 2),
			Expect().Body().FormValues("Hello-World").First().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().NotOneOf(1, 2),
			Expect().Body().FormValues("Hello-World").First().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().OneOf(1, 2),
			Expect().Body().FormValues("Hello-World").First().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().Len().OneOf(1, 2),
			Expect().Body().FormValues("Hello-World").First().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().NotContains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").First().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().NotContains()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().NotContains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").First().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().NotEmpty(),
			Expect().Body().FormValues("Hello-World").First().NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().NotEmpty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().NotEmpty()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().NotEmpty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().NotEmpty(),
			Expect().Body().FormValues("Hello-World").First().NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().NotEmpty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().NotEqual("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").First().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().NotEqual("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").First().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().NotOneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").First().NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().NotOneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").First().NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().NotOneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesFirstOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().OneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").First().OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().First().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().First().OneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().First().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesFirstOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").First().OneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").First().OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").First().OneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLast(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Contains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Last().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Contains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Last().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Contains()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Contains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Last().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Empty(),
			Expect().Body().FormValues("Hello-World").Last().Empty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Empty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Empty()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Empty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Empty(),
			Expect().Body().FormValues("Hello-World").Last().Empty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Empty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Equal("Foo-Taz"),
			Expect().Body().FormValues("Hello-World").Last().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Equal()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Equal("Foo-Taz"),
			Expect().Body().FormValues("Hello-World").Last().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Equal("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().Between(2, 2),
			Expect().Body().FormValues("Hello-World").Last().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Len()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().Between(2, 2),
			Expect().Body().FormValues("Hello-World").Last().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Len().Between()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().Between(2, 2),
			Expect().Body().FormValues("Hello-World").Last().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().Equal(2),
			Expect().Body().FormValues("Hello-World").Last().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Len().Equal()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().Equal(2),
			Expect().Body().FormValues("Hello-World").Last().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().GreaterOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").Last().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().GreaterOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").Last().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().GreaterThan(2),
			Expect().Body().FormValues("Hello-World").Last().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().GreaterThan(2),
			Expect().Body().FormValues("Hello-World").Last().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().LessOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").Last().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().LessOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").Last().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().LessThan(2),
			Expect().Body().FormValues("Hello-World").Last().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().LessThan(2),
			Expect().Body().FormValues("Hello-World").Last().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().NotBetween(2, 2),
			Expect().Body().FormValues("Hello-World").Last().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().NotBetween(2, 2),
			Expect().Body().FormValues("Hello-World").Last().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().NotEqual(1, 2),
			Expect().Body().FormValues("Hello-World").Last().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().NotEqual(1, 2),
			Expect().Body().FormValues("Hello-World").Last().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().NotOneOf(1, 2),
			Expect().Body().FormValues("Hello-World").Last().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().NotOneOf(1, 2),
			Expect().Body().FormValues("Hello-World").Last().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().OneOf(1, 2),
			Expect().Body().FormValues("Hello-World").Last().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().Len().OneOf(1, 2),
			Expect().Body().FormValues("Hello-World").Last().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().NotContains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Last().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().NotContains()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().NotContains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Last().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().NotEmpty(),
			Expect().Body().FormValues("Hello-World").Last().NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().NotEmpty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().NotEmpty()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().NotEmpty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().NotEmpty(),
			Expect().Body().FormValues("Hello-World").Last().NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().NotEmpty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().NotEqual("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Last().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().NotEqual("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Last().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().NotOneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Last().NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().NotOneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Last().NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().NotOneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLastOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().OneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Last().OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Last().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Last().OneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Last().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLastOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Last().OneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Last().OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Last().OneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().Between(2, 2),
			Expect().Body().FormValues("Hello-World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Len()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().Between(2, 2),
			Expect().Body().FormValues("Hello-World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Len().Between()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().Between(2, 2),
			Expect().Body().FormValues("Hello-World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().Equal(2),
			Expect().Body().FormValues("Hello-World").Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Len().Equal()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().Equal(2),
			Expect().Body().FormValues("Hello-World").Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().GreaterOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().GreaterOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().GreaterThan(2),
			Expect().Body().FormValues("Hello-World").Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().GreaterThan(2),
			Expect().Body().FormValues("Hello-World").Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().LessOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().LessOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().LessThan(2),
			Expect().Body().FormValues("Hello-World").Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().LessThan(2),
			Expect().Body().FormValues("Hello-World").Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().NotBetween(2, 2),
			Expect().Body().FormValues("Hello-World").Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().NotBetween(2, 2),
			Expect().Body().FormValues("Hello-World").Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().NotEqual(1, 2),
			Expect().Body().FormValues("Hello-World").Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().NotEqual(1, 2),
			Expect().Body().FormValues("Hello-World").Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().NotOneOf(1, 2),
			Expect().Body().FormValues("Hello-World").Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().NotOneOf(1, 2),
			Expect().Body().FormValues("Hello-World").Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().OneOf(1, 2),
			Expect().Body().FormValues("Hello-World").Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Len().OneOf(1, 2),
			Expect().Body().FormValues("Hello-World").Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").NotContains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().NotContains()),
		PtrStr("unable to find a step with Expect().Body().FormValues().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").NotContains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").NotEmpty(),
			Expect().Body().FormValues("Hello-World").NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().NotEmpty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().NotEmpty()),
		PtrStr("unable to find a step with Expect().Body().FormValues().NotEmpty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").NotEmpty(),
			Expect().Body().FormValues("Hello-World").NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").NotEmpty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").NotEqual("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().FormValues().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").NotEqual("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").NotOneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").NotOneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").NotOneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNth(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Contains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Nth(3).Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Contains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Nth(3).Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Contains()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Contains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Nth(3).Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Empty(),
			Expect().Body().FormValues("Hello-World").Nth(3).Empty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Empty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Empty()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Empty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Empty(),
			Expect().Body().FormValues("Hello-World").Nth(3).Empty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Empty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Equal("Foo-Taz"),
			Expect().Body().FormValues("Hello-World").Nth(3).Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Equal()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Equal("Foo-Taz"),
			Expect().Body().FormValues("Hello-World").Nth(3).Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Equal("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().Between(2, 2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Len()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().Between(2, 2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Len().Between()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().Between(2, 2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().Equal(2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Len().Equal()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().Equal(2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().GreaterOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().GreaterOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().GreaterThan(2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().GreaterThan(2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().LessOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().LessOrEqualThan(2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().LessThan(2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().LessThan(2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().NotBetween(2, 2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().NotBetween(2, 2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().NotEqual(1, 2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().NotEqual(1, 2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().NotOneOf(1, 2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().NotOneOf(1, 2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().OneOf(1, 2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).Len().OneOf(1, 2),
			Expect().Body().FormValues("Hello-World").Nth(3).Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).NotContains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Nth(3).NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().NotContains()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).NotContains("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Nth(3).NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).NotEmpty(),
			Expect().Body().FormValues("Hello-World").Nth(3).NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().NotEmpty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().NotEmpty()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().NotEmpty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).NotEmpty(),
			Expect().Body().FormValues("Hello-World").Nth(3).NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).NotEmpty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).NotEqual("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Nth(3).NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).NotEqual("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Nth(3).NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).NotOneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Nth(3).NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).NotOneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Nth(3).NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).NotOneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesNthOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).OneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Nth(3).OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().Nth().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().Nth().OneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().Nth().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesNthOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").Nth(2).OneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").Nth(3).OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").Nth(2).OneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyFormValuesOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").OneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().FormValues().OneOf()),
		PtrStr("unable to find a step with Expect().Body().FormValues().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyFormValuesOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().FormValues("Foo-Bar").OneOf("Foo", "Baz"),
			Expect().Body().FormValues("Hello-World").OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().FormValues("Foo-Bar").OneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().Between(2, 2),
			Expect().Body().Int().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int()),
		PtrStr("unable to find a step with Expect().Body().Int()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyIntBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().Between(2, 2),
			Expect().Body().Int().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int().Between()),
		PtrStr("unable to find a step with Expect().Body().Int().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyIntBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().Between(2, 2),
			Expect().Body().Int().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyIntEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().Equal(2),
			Expect().Body().Int().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int().Equal()),
		PtrStr("unable to find a step with Expect().Body().Int().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyIntEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().Equal(2),
			Expect().Body().Int().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyIntGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().GreaterOrEqualThan(2),
			Expect().Body().Int().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Int().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyIntGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().GreaterOrEqualThan(2),
			Expect().Body().Int().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyIntGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().GreaterThan(2),
			Expect().Body().Int().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Int().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyIntGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().GreaterThan(2),
			Expect().Body().Int().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyIntLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().LessOrEqualThan(2),
			Expect().Body().Int().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Int().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyIntLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().LessOrEqualThan(2),
			Expect().Body().Int().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyIntLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().LessThan(2),
			Expect().Body().Int().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Int().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyIntLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().LessThan(2),
			Expect().Body().Int().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyIntNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().NotBetween(2, 2),
			Expect().Body().Int().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Int().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyIntNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().NotBetween(2, 2),
			Expect().Body().Int().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyIntNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().NotEqual(1, 2),
			Expect().Body().Int().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Int().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyIntNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().NotEqual(1, 2),
			Expect().Body().Int().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyIntNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().NotOneOf(1, 2),
			Expect().Body().Int().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Int().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyIntNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().NotOneOf(1, 2),
			Expect().Body().Int().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyIntOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().OneOf(1, 2),
			Expect().Body().Int().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Int().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyIntOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int().OneOf(1, 2),
			Expect().Body().Int().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt16(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().Between(2, 2),
			Expect().Body().Int16().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int16()),
		PtrStr("unable to find a step with Expect().Body().Int16()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyInt16Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().Between(2, 2),
			Expect().Body().Int16().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int16().Between()),
		PtrStr("unable to find a step with Expect().Body().Int16().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt16Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().Between(2, 2),
			Expect().Body().Int16().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt16Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().Equal(2),
			Expect().Body().Int16().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int16().Equal()),
		PtrStr("unable to find a step with Expect().Body().Int16().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt16Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().Equal(2),
			Expect().Body().Int16().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt16GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().GreaterOrEqualThan(2),
			Expect().Body().Int16().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int16().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Int16().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt16GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().GreaterOrEqualThan(2),
			Expect().Body().Int16().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt16GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().GreaterThan(2),
			Expect().Body().Int16().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int16().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Int16().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt16GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().GreaterThan(2),
			Expect().Body().Int16().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt16LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().LessOrEqualThan(2),
			Expect().Body().Int16().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int16().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Int16().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt16LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().LessOrEqualThan(2),
			Expect().Body().Int16().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt16LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().LessThan(2),
			Expect().Body().Int16().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int16().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Int16().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt16LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().LessThan(2),
			Expect().Body().Int16().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt16NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().NotBetween(2, 2),
			Expect().Body().Int16().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int16().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Int16().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt16NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().NotBetween(2, 2),
			Expect().Body().Int16().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt16NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().NotEqual(1, 2),
			Expect().Body().Int16().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int16().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Int16().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt16NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().NotEqual(1, 2),
			Expect().Body().Int16().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt16NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().NotOneOf(1, 2),
			Expect().Body().Int16().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int16().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Int16().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt16NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().NotOneOf(1, 2),
			Expect().Body().Int16().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt16OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().OneOf(1, 2),
			Expect().Body().Int16().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int16().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Int16().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt16OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int16().OneOf(1, 2),
			Expect().Body().Int16().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int16().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt32(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().Between(2, 2),
			Expect().Body().Int32().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int32()),
		PtrStr("unable to find a step with Expect().Body().Int32()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyInt32Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().Between(2, 2),
			Expect().Body().Int32().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int32().Between()),
		PtrStr("unable to find a step with Expect().Body().Int32().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt32Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().Between(2, 2),
			Expect().Body().Int32().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt32Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().Equal(2),
			Expect().Body().Int32().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int32().Equal()),
		PtrStr("unable to find a step with Expect().Body().Int32().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt32Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().Equal(2),
			Expect().Body().Int32().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt32GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().GreaterOrEqualThan(2),
			Expect().Body().Int32().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int32().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Int32().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt32GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().GreaterOrEqualThan(2),
			Expect().Body().Int32().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt32GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().GreaterThan(2),
			Expect().Body().Int32().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int32().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Int32().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt32GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().GreaterThan(2),
			Expect().Body().Int32().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt32LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().LessOrEqualThan(2),
			Expect().Body().Int32().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int32().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Int32().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt32LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().LessOrEqualThan(2),
			Expect().Body().Int32().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt32LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().LessThan(2),
			Expect().Body().Int32().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int32().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Int32().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt32LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().LessThan(2),
			Expect().Body().Int32().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt32NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().NotBetween(2, 2),
			Expect().Body().Int32().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int32().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Int32().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt32NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().NotBetween(2, 2),
			Expect().Body().Int32().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt32NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().NotEqual(1, 2),
			Expect().Body().Int32().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int32().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Int32().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt32NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().NotEqual(1, 2),
			Expect().Body().Int32().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt32NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().NotOneOf(1, 2),
			Expect().Body().Int32().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int32().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Int32().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt32NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().NotOneOf(1, 2),
			Expect().Body().Int32().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt32OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().OneOf(1, 2),
			Expect().Body().Int32().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int32().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Int32().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt32OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int32().OneOf(1, 2),
			Expect().Body().Int32().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int32().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt64(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().Between(2, 2),
			Expect().Body().Int64().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int64()),
		PtrStr("unable to find a step with Expect().Body().Int64()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyInt64Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().Between(2, 2),
			Expect().Body().Int64().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int64().Between()),
		PtrStr("unable to find a step with Expect().Body().Int64().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt64Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().Between(2, 2),
			Expect().Body().Int64().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt64Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().Equal(2),
			Expect().Body().Int64().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int64().Equal()),
		PtrStr("unable to find a step with Expect().Body().Int64().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt64Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().Equal(2),
			Expect().Body().Int64().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt64GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().GreaterOrEqualThan(2),
			Expect().Body().Int64().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int64().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Int64().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt64GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().GreaterOrEqualThan(2),
			Expect().Body().Int64().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt64GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().GreaterThan(2),
			Expect().Body().Int64().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int64().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Int64().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt64GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().GreaterThan(2),
			Expect().Body().Int64().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt64LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().LessOrEqualThan(2),
			Expect().Body().Int64().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int64().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Int64().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt64LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().LessOrEqualThan(2),
			Expect().Body().Int64().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt64LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().LessThan(2),
			Expect().Body().Int64().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int64().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Int64().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt64LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().LessThan(2),
			Expect().Body().Int64().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt64NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().NotBetween(2, 2),
			Expect().Body().Int64().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int64().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Int64().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt64NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().NotBetween(2, 2),
			Expect().Body().Int64().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt64NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().NotEqual(1, 2),
			Expect().Body().Int64().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int64().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Int64().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt64NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().NotEqual(1, 2),
			Expect().Body().Int64().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt64NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().NotOneOf(1, 2),
			Expect().Body().Int64().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int64().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Int64().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt64NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().NotOneOf(1, 2),
			Expect().Body().Int64().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt64OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().OneOf(1, 2),
			Expect().Body().Int64().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int64().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Int64().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt64OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int64().OneOf(1, 2),
			Expect().Body().Int64().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int64().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt8(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().Between(2, 2),
			Expect().Body().Int8().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int8()),
		PtrStr("unable to find a step with Expect().Body().Int8()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyInt8Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().Between(2, 2),
			Expect().Body().Int8().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int8().Between()),
		PtrStr("unable to find a step with Expect().Body().Int8().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt8Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().Between(2, 2),
			Expect().Body().Int8().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt8Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().Equal(2),
			Expect().Body().Int8().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int8().Equal()),
		PtrStr("unable to find a step with Expect().Body().Int8().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt8Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().Equal(2),
			Expect().Body().Int8().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt8GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().GreaterOrEqualThan(2),
			Expect().Body().Int8().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int8().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Int8().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt8GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().GreaterOrEqualThan(2),
			Expect().Body().Int8().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt8GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().GreaterThan(2),
			Expect().Body().Int8().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int8().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Int8().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt8GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().GreaterThan(2),
			Expect().Body().Int8().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt8LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().LessOrEqualThan(2),
			Expect().Body().Int8().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int8().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Int8().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt8LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().LessOrEqualThan(2),
			Expect().Body().Int8().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt8LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().LessThan(2),
			Expect().Body().Int8().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int8().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Int8().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt8LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().LessThan(2),
			Expect().Body().Int8().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt8NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().NotBetween(2, 2),
			Expect().Body().Int8().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int8().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Int8().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt8NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().NotBetween(2, 2),
			Expect().Body().Int8().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt8NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().NotEqual(1, 2),
			Expect().Body().Int8().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int8().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Int8().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt8NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().NotEqual(1, 2),
			Expect().Body().Int8().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt8NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().NotOneOf(1, 2),
			Expect().Body().Int8().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int8().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Int8().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt8NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().NotOneOf(1, 2),
			Expect().Body().Int8().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyInt8OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().OneOf(1, 2),
			Expect().Body().Int8().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Int8().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Int8().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyInt8OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Int8().OneOf(1, 2),
			Expect().Body().Int8().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().Int8().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSON(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Contains("Foo", "Baz"),
			Expect().Body().JSON().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON()),
		PtrStr("unable to find a step with Expect().Body().JSON()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Contains("Foo", "Baz"),
			Expect().Body().JSON().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Contains()),
		PtrStr("unable to find a step with Expect().Body().JSON().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Contains("Foo", "Baz"),
			Expect().Body().JSON().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Equal("Foo-Taz"),
			Expect().Body().JSON().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Equal()),
		PtrStr("unable to find a step with Expect().Body().JSON().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Equal("Foo-Taz"),
			Expect().Body().JSON().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Equal("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQ(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Contains("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Contains("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Contains()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Contains("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Equal("Foo-Taz"),
			Expect().Body().JSON().JQ("Hello", "World").Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Equal()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Equal("Foo-Taz"),
			Expect().Body().JSON().JQ("Hello", "World").Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").Equal("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQJQ(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").Contains("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").JQ("Hello", "World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().JQ(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().JQ()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().JQ()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQJQContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").Contains("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").JQ("Hello", "World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().JQ().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().JQ().Contains()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().JQ().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQJQContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").Contains("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").JQ("Hello", "World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQJQEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").Equal("Foo-Taz"),
			Expect().Body().JSON().JQ("Hello", "World").JQ("Hello", "World").Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().JQ().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().JQ().Equal()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().JQ().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQJQEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").Equal("Foo-Taz"),
			Expect().Body().JSON().JQ("Hello", "World").JQ("Hello", "World").Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").Equal("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQJQJQ(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").JQ("Foo", "Bar").Contains("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").JQ("Hello", "World").JQ("Hello", "World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().JQ().JQ(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().JQ().JQ()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().JQ().JQ()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQJQLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").Len().Between(2, 2),
			Expect().Body().JSON().JQ("Hello", "World").JQ("Hello", "World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().JQ().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().JQ().Len()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().JQ().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQJQNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").NotContains("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").JQ("Hello", "World").NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().JQ().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().JQ().NotContains()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().JQ().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQJQNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").NotContains("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").JQ("Hello", "World").NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQJQNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").NotEqual("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").JQ("Hello", "World").NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().JQ().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().JQ().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().JQ().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQJQNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").NotEqual("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").JQ("Hello", "World").NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").JQ("Foo", "Bar").NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().Between(2, 2),
			Expect().Body().JSON().JQ("Hello", "World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Len()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().Between(2, 2),
			Expect().Body().JSON().JQ("Hello", "World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Len().Between()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().Between(2, 2),
			Expect().Body().JSON().JQ("Hello", "World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().Equal(2),
			Expect().Body().JSON().JQ("Hello", "World").Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Len().Equal()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().Equal(2),
			Expect().Body().JSON().JQ("Hello", "World").Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().GreaterOrEqualThan(2),
			Expect().Body().JSON().JQ("Hello", "World").Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().GreaterOrEqualThan(2),
			Expect().Body().JSON().JQ("Hello", "World").Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().GreaterThan(2),
			Expect().Body().JSON().JQ("Hello", "World").Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().GreaterThan(2),
			Expect().Body().JSON().JQ("Hello", "World").Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().LessOrEqualThan(2),
			Expect().Body().JSON().JQ("Hello", "World").Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().LessOrEqualThan(2),
			Expect().Body().JSON().JQ("Hello", "World").Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().LessThan(2),
			Expect().Body().JSON().JQ("Hello", "World").Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().LessThan(2),
			Expect().Body().JSON().JQ("Hello", "World").Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().NotBetween(2, 2),
			Expect().Body().JSON().JQ("Hello", "World").Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().NotBetween(2, 2),
			Expect().Body().JSON().JQ("Hello", "World").Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().NotEqual(1, 2),
			Expect().Body().JSON().JQ("Hello", "World").Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().NotEqual(1, 2),
			Expect().Body().JSON().JQ("Hello", "World").Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().NotOneOf(1, 2),
			Expect().Body().JSON().JQ("Hello", "World").Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().NotOneOf(1, 2),
			Expect().Body().JSON().JQ("Hello", "World").Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().OneOf(1, 2),
			Expect().Body().JSON().JQ("Hello", "World").Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").Len().OneOf(1, 2),
			Expect().Body().JSON().JQ("Hello", "World").Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").NotContains("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().NotContains()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").NotContains("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONJQNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").NotEqual("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().JQ().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().JSON().JQ().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONJQNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().JQ("Foo", "Bar").NotEqual("Foo", "Baz"),
			Expect().Body().JSON().JQ("Hello", "World").NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().JQ("Foo", "Bar").NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().Between(2, 2),
			Expect().Body().JSON().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Len()),
		PtrStr("unable to find a step with Expect().Body().JSON().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().Between(2, 2),
			Expect().Body().JSON().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Len().Between()),
		PtrStr("unable to find a step with Expect().Body().JSON().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().Between(2, 2),
			Expect().Body().JSON().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().Equal(2),
			Expect().Body().JSON().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Len().Equal()),
		PtrStr("unable to find a step with Expect().Body().JSON().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().Equal(2),
			Expect().Body().JSON().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().GreaterOrEqualThan(2),
			Expect().Body().JSON().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().JSON().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().GreaterOrEqualThan(2),
			Expect().Body().JSON().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().GreaterThan(2),
			Expect().Body().JSON().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().JSON().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().GreaterThan(2),
			Expect().Body().JSON().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().LessOrEqualThan(2),
			Expect().Body().JSON().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().JSON().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().LessOrEqualThan(2),
			Expect().Body().JSON().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().LessThan(2),
			Expect().Body().JSON().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Body().JSON().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().LessThan(2),
			Expect().Body().JSON().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().NotBetween(2, 2),
			Expect().Body().JSON().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().JSON().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().NotBetween(2, 2),
			Expect().Body().JSON().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().NotEqual(1, 2),
			Expect().Body().JSON().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().JSON().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().NotEqual(1, 2),
			Expect().Body().JSON().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().NotOneOf(1, 2),
			Expect().Body().JSON().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().JSON().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().NotOneOf(1, 2),
			Expect().Body().JSON().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().OneOf(1, 2),
			Expect().Body().JSON().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Body().JSON().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().Len().OneOf(1, 2),
			Expect().Body().JSON().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().NotContains("Foo", "Baz"),
			Expect().Body().JSON().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().NotContains()),
		PtrStr("unable to find a step with Expect().Body().JSON().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().NotContains("Foo", "Baz"),
			Expect().Body().JSON().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyJSONNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().NotEqual("Foo", "Baz"),
			Expect().Body().JSON().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().JSON().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().JSON().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyJSONNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().JSON().NotEqual("Foo", "Baz"),
			Expect().Body().JSON().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Body().JSON().NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyString(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Contains("Foo-Bar"),
			Expect().Body().String().Contains("Hello-World"),
			storeSteps(&steps),
			Clear().Expect().Body().String(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String()),
		PtrStr("unable to find a step with Expect().Body().String()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyStringContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Contains("Foo-Bar"),
			Expect().Body().String().Contains("Hello-World"),
			storeSteps(&steps),
			Clear().Expect().Body().String().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Contains()),
		PtrStr("unable to find a step with Expect().Body().String().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Contains("Foo-Bar"),
			Expect().Body().String().Contains("Hello-World"),
			storeSteps(&steps),
			Clear().Expect().Body().String().Contains("Foo-Bar"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Equal("Foo-Bar"),
			Expect().Body().String().Equal("Hello-World"),
			storeSteps(&steps),
			Clear().Expect().Body().String().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Equal()),
		PtrStr("unable to find a step with Expect().Body().String().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Equal("Foo-Bar"),
			Expect().Body().String().Equal("Hello-World"),
			storeSteps(&steps),
			Clear().Expect().Body().String().Equal("Foo-Bar"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().Between(2, 2),
			Expect().Body().String().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Len()),
		PtrStr("unable to find a step with Expect().Body().String().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyStringLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().Between(2, 2),
			Expect().Body().String().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Len().Between()),
		PtrStr("unable to find a step with Expect().Body().String().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().Between(2, 2),
			Expect().Body().String().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().Equal(2),
			Expect().Body().String().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Len().Equal()),
		PtrStr("unable to find a step with Expect().Body().String().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().Equal(2),
			Expect().Body().String().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().GreaterOrEqualThan(2),
			Expect().Body().String().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().String().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().GreaterOrEqualThan(2),
			Expect().Body().String().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().GreaterThan(2),
			Expect().Body().String().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().String().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().GreaterThan(2),
			Expect().Body().String().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().LessOrEqualThan(2),
			Expect().Body().String().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().String().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().LessOrEqualThan(2),
			Expect().Body().String().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().LessThan(2),
			Expect().Body().String().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Body().String().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().LessThan(2),
			Expect().Body().String().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().NotBetween(2, 2),
			Expect().Body().String().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().String().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().NotBetween(2, 2),
			Expect().Body().String().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().NotEqual(1, 2),
			Expect().Body().String().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().String().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().NotEqual(1, 2),
			Expect().Body().String().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().NotOneOf(1, 2),
			Expect().Body().String().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().String().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().NotOneOf(1, 2),
			Expect().Body().String().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().OneOf(1, 2),
			Expect().Body().String().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Body().String().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().Len().OneOf(1, 2),
			Expect().Body().String().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Body().String().Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().NotContains("Foo-Bar"),
			Expect().Body().String().NotContains("Hello-World"),
			storeSteps(&steps),
			Clear().Expect().Body().String().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().NotContains()),
		PtrStr("unable to find a step with Expect().Body().String().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().NotContains("Foo-Bar"),
			Expect().Body().String().NotContains("Hello-World"),
			storeSteps(&steps),
			Clear().Expect().Body().String().NotContains("Foo-Bar"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().NotEqual("Foo-Bar"),
			Expect().Body().String().NotEqual("Hello-World"),
			storeSteps(&steps),
			Clear().Expect().Body().String().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().String().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().NotEqual("Foo-Bar"),
			Expect().Body().String().NotEqual("Hello-World"),
			storeSteps(&steps),
			Clear().Expect().Body().String().NotEqual("Foo-Bar"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().NotOneOf("Foo", "Bar"),
			Expect().Body().String().NotOneOf("Hello", "World"),
			storeSteps(&steps),
			Clear().Expect().Body().String().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().String().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().NotOneOf("Foo", "Bar"),
			Expect().Body().String().NotOneOf("Hello", "World"),
			storeSteps(&steps),
			Clear().Expect().Body().String().NotOneOf("Foo", "Bar"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyStringOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().OneOf("Foo", "Bar"),
			Expect().Body().String().OneOf("Hello", "World"),
			storeSteps(&steps),
			Clear().Expect().Body().String().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().String().OneOf()),
		PtrStr("unable to find a step with Expect().Body().String().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyStringOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().String().OneOf("Foo", "Bar"),
			Expect().Body().String().OneOf("Hello", "World"),
			storeSteps(&steps),
			Clear().Expect().Body().String().OneOf("Foo", "Bar"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().Between(0x2, 0x2),
			Expect().Body().Uint().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint()),
		PtrStr("unable to find a step with Expect().Body().Uint()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyUintBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().Between(0x2, 0x2),
			Expect().Body().Uint().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint().Between()),
		PtrStr("unable to find a step with Expect().Body().Uint().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUintBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().Between(0x2, 0x2),
			Expect().Body().Uint().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().Between(0x2, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUintEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().Equal(0x2),
			Expect().Body().Uint().Equal(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint().Equal()),
		PtrStr("unable to find a step with Expect().Body().Uint().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUintEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().Equal(0x2),
			Expect().Body().Uint().Equal(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().Equal(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUintGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().GreaterOrEqualThan(0x2),
			Expect().Body().Uint().GreaterOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Uint().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUintGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().GreaterOrEqualThan(0x2),
			Expect().Body().Uint().GreaterOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().GreaterOrEqualThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUintGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().GreaterThan(0x2),
			Expect().Body().Uint().GreaterThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Uint().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUintGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().GreaterThan(0x2),
			Expect().Body().Uint().GreaterThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().GreaterThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUintLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().LessOrEqualThan(0x2),
			Expect().Body().Uint().LessOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Uint().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUintLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().LessOrEqualThan(0x2),
			Expect().Body().Uint().LessOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().LessOrEqualThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUintLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().LessThan(0x2),
			Expect().Body().Uint().LessThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Uint().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUintLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().LessThan(0x2),
			Expect().Body().Uint().LessThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().LessThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUintNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().NotBetween(0x2, 0x2),
			Expect().Body().Uint().NotBetween(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Uint().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUintNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().NotBetween(0x2, 0x2),
			Expect().Body().Uint().NotBetween(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().NotBetween(0x2, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUintNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().NotEqual(0x1, 0x2),
			Expect().Body().Uint().NotEqual(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Uint().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUintNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().NotEqual(0x1, 0x2),
			Expect().Body().Uint().NotEqual(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().NotEqual(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUintNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().NotOneOf(0x1, 0x2),
			Expect().Body().Uint().NotOneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Uint().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUintNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().NotOneOf(0x1, 0x2),
			Expect().Body().Uint().NotOneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().NotOneOf(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUintOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().OneOf(0x1, 0x2),
			Expect().Body().Uint().OneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Uint().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUintOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint().OneOf(0x1, 0x2),
			Expect().Body().Uint().OneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint().OneOf(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint16(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().Between(0x2, 0x2),
			Expect().Body().Uint16().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint16()),
		PtrStr("unable to find a step with Expect().Body().Uint16()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyUint16Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().Between(0x2, 0x2),
			Expect().Body().Uint16().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint16().Between()),
		PtrStr("unable to find a step with Expect().Body().Uint16().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint16Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().Between(0x2, 0x2),
			Expect().Body().Uint16().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().Between(0x2, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint16Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().Equal(0x2),
			Expect().Body().Uint16().Equal(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint16().Equal()),
		PtrStr("unable to find a step with Expect().Body().Uint16().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint16Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().Equal(0x2),
			Expect().Body().Uint16().Equal(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().Equal(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint16GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().GreaterOrEqualThan(0x2),
			Expect().Body().Uint16().GreaterOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint16().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Uint16().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint16GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().GreaterOrEqualThan(0x2),
			Expect().Body().Uint16().GreaterOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().GreaterOrEqualThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint16GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().GreaterThan(0x2),
			Expect().Body().Uint16().GreaterThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint16().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Uint16().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint16GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().GreaterThan(0x2),
			Expect().Body().Uint16().GreaterThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().GreaterThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint16LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().LessOrEqualThan(0x2),
			Expect().Body().Uint16().LessOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint16().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Uint16().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint16LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().LessOrEqualThan(0x2),
			Expect().Body().Uint16().LessOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().LessOrEqualThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint16LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().LessThan(0x2),
			Expect().Body().Uint16().LessThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint16().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Uint16().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint16LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().LessThan(0x2),
			Expect().Body().Uint16().LessThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().LessThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint16NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().NotBetween(0x2, 0x2),
			Expect().Body().Uint16().NotBetween(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint16().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Uint16().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint16NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().NotBetween(0x2, 0x2),
			Expect().Body().Uint16().NotBetween(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().NotBetween(0x2, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint16NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().NotEqual(0x1, 0x2),
			Expect().Body().Uint16().NotEqual(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint16().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Uint16().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint16NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().NotEqual(0x1, 0x2),
			Expect().Body().Uint16().NotEqual(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().NotEqual(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint16NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().NotOneOf(0x1, 0x2),
			Expect().Body().Uint16().NotOneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint16().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Uint16().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint16NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().NotOneOf(0x1, 0x2),
			Expect().Body().Uint16().NotOneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().NotOneOf(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint16OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().OneOf(0x1, 0x2),
			Expect().Body().Uint16().OneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint16().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Uint16().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint16OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint16().OneOf(0x1, 0x2),
			Expect().Body().Uint16().OneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint16().OneOf(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint32(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().Between(0x2, 0x2),
			Expect().Body().Uint32().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint32()),
		PtrStr("unable to find a step with Expect().Body().Uint32()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyUint32Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().Between(0x2, 0x2),
			Expect().Body().Uint32().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint32().Between()),
		PtrStr("unable to find a step with Expect().Body().Uint32().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint32Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().Between(0x2, 0x2),
			Expect().Body().Uint32().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().Between(0x2, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint32Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().Equal(0x2),
			Expect().Body().Uint32().Equal(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint32().Equal()),
		PtrStr("unable to find a step with Expect().Body().Uint32().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint32Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().Equal(0x2),
			Expect().Body().Uint32().Equal(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().Equal(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint32GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().GreaterOrEqualThan(0x2),
			Expect().Body().Uint32().GreaterOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint32().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Uint32().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint32GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().GreaterOrEqualThan(0x2),
			Expect().Body().Uint32().GreaterOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().GreaterOrEqualThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint32GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().GreaterThan(0x2),
			Expect().Body().Uint32().GreaterThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint32().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Uint32().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint32GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().GreaterThan(0x2),
			Expect().Body().Uint32().GreaterThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().GreaterThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint32LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().LessOrEqualThan(0x2),
			Expect().Body().Uint32().LessOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint32().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Uint32().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint32LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().LessOrEqualThan(0x2),
			Expect().Body().Uint32().LessOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().LessOrEqualThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint32LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().LessThan(0x2),
			Expect().Body().Uint32().LessThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint32().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Uint32().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint32LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().LessThan(0x2),
			Expect().Body().Uint32().LessThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().LessThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint32NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().NotBetween(0x2, 0x2),
			Expect().Body().Uint32().NotBetween(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint32().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Uint32().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint32NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().NotBetween(0x2, 0x2),
			Expect().Body().Uint32().NotBetween(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().NotBetween(0x2, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint32NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().NotEqual(0x1, 0x2),
			Expect().Body().Uint32().NotEqual(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint32().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Uint32().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint32NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().NotEqual(0x1, 0x2),
			Expect().Body().Uint32().NotEqual(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().NotEqual(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint32NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().NotOneOf(0x1, 0x2),
			Expect().Body().Uint32().NotOneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint32().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Uint32().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint32NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().NotOneOf(0x1, 0x2),
			Expect().Body().Uint32().NotOneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().NotOneOf(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint32OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().OneOf(0x1, 0x2),
			Expect().Body().Uint32().OneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint32().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Uint32().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint32OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint32().OneOf(0x1, 0x2),
			Expect().Body().Uint32().OneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint32().OneOf(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint64(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().Between(0x2, 0x2),
			Expect().Body().Uint64().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint64()),
		PtrStr("unable to find a step with Expect().Body().Uint64()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyUint64Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().Between(0x2, 0x2),
			Expect().Body().Uint64().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint64().Between()),
		PtrStr("unable to find a step with Expect().Body().Uint64().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint64Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().Between(0x2, 0x2),
			Expect().Body().Uint64().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().Between(0x2, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint64Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().Equal(0x2),
			Expect().Body().Uint64().Equal(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint64().Equal()),
		PtrStr("unable to find a step with Expect().Body().Uint64().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint64Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().Equal(0x2),
			Expect().Body().Uint64().Equal(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().Equal(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint64GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().GreaterOrEqualThan(0x2),
			Expect().Body().Uint64().GreaterOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint64().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Uint64().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint64GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().GreaterOrEqualThan(0x2),
			Expect().Body().Uint64().GreaterOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().GreaterOrEqualThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint64GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().GreaterThan(0x2),
			Expect().Body().Uint64().GreaterThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint64().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Uint64().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint64GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().GreaterThan(0x2),
			Expect().Body().Uint64().GreaterThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().GreaterThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint64LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().LessOrEqualThan(0x2),
			Expect().Body().Uint64().LessOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint64().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Uint64().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint64LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().LessOrEqualThan(0x2),
			Expect().Body().Uint64().LessOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().LessOrEqualThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint64LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().LessThan(0x2),
			Expect().Body().Uint64().LessThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint64().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Uint64().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint64LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().LessThan(0x2),
			Expect().Body().Uint64().LessThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().LessThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint64NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().NotBetween(0x2, 0x2),
			Expect().Body().Uint64().NotBetween(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint64().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Uint64().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint64NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().NotBetween(0x2, 0x2),
			Expect().Body().Uint64().NotBetween(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().NotBetween(0x2, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint64NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().NotEqual(0x1, 0x2),
			Expect().Body().Uint64().NotEqual(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint64().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Uint64().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint64NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().NotEqual(0x1, 0x2),
			Expect().Body().Uint64().NotEqual(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().NotEqual(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint64NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().NotOneOf(0x1, 0x2),
			Expect().Body().Uint64().NotOneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint64().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Uint64().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint64NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().NotOneOf(0x1, 0x2),
			Expect().Body().Uint64().NotOneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().NotOneOf(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint64OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().OneOf(0x1, 0x2),
			Expect().Body().Uint64().OneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint64().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Uint64().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint64OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint64().OneOf(0x1, 0x2),
			Expect().Body().Uint64().OneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint64().OneOf(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint8(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().Between(0x2, 0x2),
			Expect().Body().Uint8().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint8()),
		PtrStr("unable to find a step with Expect().Body().Uint8()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectBodyUint8Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().Between(0x2, 0x2),
			Expect().Body().Uint8().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint8().Between()),
		PtrStr("unable to find a step with Expect().Body().Uint8().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint8Between(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().Between(0x2, 0x2),
			Expect().Body().Uint8().Between(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().Between(0x2, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint8Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().Equal(0x2),
			Expect().Body().Uint8().Equal(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint8().Equal()),
		PtrStr("unable to find a step with Expect().Body().Uint8().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint8Equal(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().Equal(0x2),
			Expect().Body().Uint8().Equal(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().Equal(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint8GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().GreaterOrEqualThan(0x2),
			Expect().Body().Uint8().GreaterOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint8().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Uint8().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint8GreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().GreaterOrEqualThan(0x2),
			Expect().Body().Uint8().GreaterOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().GreaterOrEqualThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint8GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().GreaterThan(0x2),
			Expect().Body().Uint8().GreaterThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint8().GreaterThan()),
		PtrStr("unable to find a step with Expect().Body().Uint8().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint8GreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().GreaterThan(0x2),
			Expect().Body().Uint8().GreaterThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().GreaterThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint8LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().LessOrEqualThan(0x2),
			Expect().Body().Uint8().LessOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint8().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Body().Uint8().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint8LessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().LessOrEqualThan(0x2),
			Expect().Body().Uint8().LessOrEqualThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().LessOrEqualThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint8LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().LessThan(0x2),
			Expect().Body().Uint8().LessThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint8().LessThan()),
		PtrStr("unable to find a step with Expect().Body().Uint8().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint8LessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().LessThan(0x2),
			Expect().Body().Uint8().LessThan(0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().LessThan(0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint8NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().NotBetween(0x2, 0x2),
			Expect().Body().Uint8().NotBetween(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint8().NotBetween()),
		PtrStr("unable to find a step with Expect().Body().Uint8().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint8NotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().NotBetween(0x2, 0x2),
			Expect().Body().Uint8().NotBetween(0x3, 0x3),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().NotBetween(0x2, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint8NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().NotEqual(0x1, 0x2),
			Expect().Body().Uint8().NotEqual(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint8().NotEqual()),
		PtrStr("unable to find a step with Expect().Body().Uint8().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint8NotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().NotEqual(0x1, 0x2),
			Expect().Body().Uint8().NotEqual(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().NotEqual(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint8NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().NotOneOf(0x1, 0x2),
			Expect().Body().Uint8().NotOneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint8().NotOneOf()),
		PtrStr("unable to find a step with Expect().Body().Uint8().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint8NotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().NotOneOf(0x1, 0x2),
			Expect().Body().Uint8().NotOneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().NotOneOf(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectBodyUint8OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().OneOf(0x1, 0x2),
			Expect().Body().Uint8().OneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Body().Uint8().OneOf()),
		PtrStr("unable to find a step with Expect().Body().Uint8().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectBodyUint8OneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Body().Uint8().OneOf(0x1, 0x2),
			Expect().Body().Uint8().OneOf(0x3, 0x4),
			storeSteps(&steps),
			Clear().Expect().Body().Uint8().OneOf(0x1, 0x2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeaders(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Contains("Foo", "Baz"),
			Expect().Headers("Hello-World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers()),
		PtrStr("unable to find a step with Expect().Headers()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectHeadersContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Contains("Foo", "Baz"),
			Expect().Headers("Hello-World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Contains()),
		PtrStr("unable to find a step with Expect().Headers().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Contains("Foo", "Baz"),
			Expect().Headers("Hello-World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Empty(),
			Expect().Headers("Hello-World").Empty(),
			storeSteps(&steps),
			Clear().Expect().Headers().Empty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Empty()),
		PtrStr("unable to find a step with Expect().Headers().Empty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Empty(),
			Expect().Headers("Hello-World").Empty(),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Empty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Equal("Foo", "Baz"),
			Expect().Headers("Hello-World").Equal("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Equal()),
		PtrStr("unable to find a step with Expect().Headers().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Equal("Foo", "Baz"),
			Expect().Headers("Hello-World").Equal("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Equal("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirst(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Contains("Foo", "Baz"),
			Expect().Headers("Hello-World").First().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().First(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First()),
		PtrStr("unable to find a step with Expect().Headers().First()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Contains("Foo", "Baz"),
			Expect().Headers("Hello-World").First().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Contains()),
		PtrStr("unable to find a step with Expect().Headers().First().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Contains("Foo", "Baz"),
			Expect().Headers("Hello-World").First().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Empty(),
			Expect().Headers("Hello-World").First().Empty(),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Empty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Empty()),
		PtrStr("unable to find a step with Expect().Headers().First().Empty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Empty(),
			Expect().Headers("Hello-World").First().Empty(),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Empty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Equal("Foo-Taz"),
			Expect().Headers("Hello-World").First().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Equal()),
		PtrStr("unable to find a step with Expect().Headers().First().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Equal("Foo-Taz"),
			Expect().Headers("Hello-World").First().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Equal("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().Between(2, 2),
			Expect().Headers("Hello-World").First().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Len()),
		PtrStr("unable to find a step with Expect().Headers().First().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().Between(2, 2),
			Expect().Headers("Hello-World").First().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Len().Between()),
		PtrStr("unable to find a step with Expect().Headers().First().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().Between(2, 2),
			Expect().Headers("Hello-World").First().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().Equal(2),
			Expect().Headers("Hello-World").First().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Len().Equal()),
		PtrStr("unable to find a step with Expect().Headers().First().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().Equal(2),
			Expect().Headers("Hello-World").First().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().GreaterOrEqualThan(2),
			Expect().Headers("Hello-World").First().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Headers().First().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().GreaterOrEqualThan(2),
			Expect().Headers("Hello-World").First().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().GreaterThan(2),
			Expect().Headers("Hello-World").First().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Headers().First().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().GreaterThan(2),
			Expect().Headers("Hello-World").First().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().LessOrEqualThan(2),
			Expect().Headers("Hello-World").First().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Headers().First().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().LessOrEqualThan(2),
			Expect().Headers("Hello-World").First().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().LessThan(2),
			Expect().Headers("Hello-World").First().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Headers().First().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().LessThan(2),
			Expect().Headers("Hello-World").First().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().NotBetween(2, 2),
			Expect().Headers("Hello-World").First().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Headers().First().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().NotBetween(2, 2),
			Expect().Headers("Hello-World").First().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().NotEqual(1, 2),
			Expect().Headers("Hello-World").First().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Headers().First().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().NotEqual(1, 2),
			Expect().Headers("Hello-World").First().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().NotOneOf(1, 2),
			Expect().Headers("Hello-World").First().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Headers().First().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().NotOneOf(1, 2),
			Expect().Headers("Hello-World").First().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().OneOf(1, 2),
			Expect().Headers("Hello-World").First().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers().First().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Headers().First().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().Len().OneOf(1, 2),
			Expect().Headers("Hello-World").First().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().NotContains("Foo", "Baz"),
			Expect().Headers("Hello-World").First().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().First().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().NotContains()),
		PtrStr("unable to find a step with Expect().Headers().First().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().NotContains("Foo", "Baz"),
			Expect().Headers("Hello-World").First().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().NotEmpty(),
			Expect().Headers("Hello-World").First().NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Headers().First().NotEmpty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().NotEmpty()),
		PtrStr("unable to find a step with Expect().Headers().First().NotEmpty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().NotEmpty(),
			Expect().Headers("Hello-World").First().NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().NotEmpty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().NotEqual("Foo", "Baz"),
			Expect().Headers("Hello-World").First().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().First().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().NotEqual()),
		PtrStr("unable to find a step with Expect().Headers().First().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().NotEqual("Foo", "Baz"),
			Expect().Headers("Hello-World").First().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().NotOneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").First().NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().First().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().NotOneOf()),
		PtrStr("unable to find a step with Expect().Headers().First().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().NotOneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").First().NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().NotOneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersFirstOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().OneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").First().OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().First().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().First().OneOf()),
		PtrStr("unable to find a step with Expect().Headers().First().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersFirstOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").First().OneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").First().OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").First().OneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLast(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Contains("Foo", "Baz"),
			Expect().Headers("Hello-World").Last().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Last(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last()),
		PtrStr("unable to find a step with Expect().Headers().Last()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Contains("Foo", "Baz"),
			Expect().Headers("Hello-World").Last().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Contains()),
		PtrStr("unable to find a step with Expect().Headers().Last().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Contains("Foo", "Baz"),
			Expect().Headers("Hello-World").Last().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Empty(),
			Expect().Headers("Hello-World").Last().Empty(),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Empty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Empty()),
		PtrStr("unable to find a step with Expect().Headers().Last().Empty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Empty(),
			Expect().Headers("Hello-World").Last().Empty(),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Empty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Equal("Foo-Taz"),
			Expect().Headers("Hello-World").Last().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Equal()),
		PtrStr("unable to find a step with Expect().Headers().Last().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Equal("Foo-Taz"),
			Expect().Headers("Hello-World").Last().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Equal("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().Between(2, 2),
			Expect().Headers("Hello-World").Last().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Len()),
		PtrStr("unable to find a step with Expect().Headers().Last().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().Between(2, 2),
			Expect().Headers("Hello-World").Last().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Len().Between()),
		PtrStr("unable to find a step with Expect().Headers().Last().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().Between(2, 2),
			Expect().Headers("Hello-World").Last().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().Equal(2),
			Expect().Headers("Hello-World").Last().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Len().Equal()),
		PtrStr("unable to find a step with Expect().Headers().Last().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().Equal(2),
			Expect().Headers("Hello-World").Last().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().GreaterOrEqualThan(2),
			Expect().Headers("Hello-World").Last().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Headers().Last().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().GreaterOrEqualThan(2),
			Expect().Headers("Hello-World").Last().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().GreaterThan(2),
			Expect().Headers("Hello-World").Last().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Headers().Last().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().GreaterThan(2),
			Expect().Headers("Hello-World").Last().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().LessOrEqualThan(2),
			Expect().Headers("Hello-World").Last().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Headers().Last().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().LessOrEqualThan(2),
			Expect().Headers("Hello-World").Last().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().LessThan(2),
			Expect().Headers("Hello-World").Last().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Headers().Last().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().LessThan(2),
			Expect().Headers("Hello-World").Last().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().NotBetween(2, 2),
			Expect().Headers("Hello-World").Last().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Headers().Last().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().NotBetween(2, 2),
			Expect().Headers("Hello-World").Last().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().NotEqual(1, 2),
			Expect().Headers("Hello-World").Last().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Headers().Last().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().NotEqual(1, 2),
			Expect().Headers("Hello-World").Last().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().NotOneOf(1, 2),
			Expect().Headers("Hello-World").Last().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Headers().Last().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().NotOneOf(1, 2),
			Expect().Headers("Hello-World").Last().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().OneOf(1, 2),
			Expect().Headers("Hello-World").Last().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Headers().Last().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().Len().OneOf(1, 2),
			Expect().Headers("Hello-World").Last().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().NotContains("Foo", "Baz"),
			Expect().Headers("Hello-World").Last().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().NotContains()),
		PtrStr("unable to find a step with Expect().Headers().Last().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().NotContains("Foo", "Baz"),
			Expect().Headers("Hello-World").Last().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().NotEmpty(),
			Expect().Headers("Hello-World").Last().NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().NotEmpty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().NotEmpty()),
		PtrStr("unable to find a step with Expect().Headers().Last().NotEmpty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().NotEmpty(),
			Expect().Headers("Hello-World").Last().NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().NotEmpty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().NotEqual("Foo", "Baz"),
			Expect().Headers("Hello-World").Last().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().NotEqual()),
		PtrStr("unable to find a step with Expect().Headers().Last().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().NotEqual("Foo", "Baz"),
			Expect().Headers("Hello-World").Last().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().NotOneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").Last().NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().NotOneOf()),
		PtrStr("unable to find a step with Expect().Headers().Last().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().NotOneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").Last().NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().NotOneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLastOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().OneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").Last().OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Last().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Last().OneOf()),
		PtrStr("unable to find a step with Expect().Headers().Last().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLastOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Last().OneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").Last().OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Last().OneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().Between(2, 2),
			Expect().Headers("Hello-World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Len()),
		PtrStr("unable to find a step with Expect().Headers().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectHeadersLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().Between(2, 2),
			Expect().Headers("Hello-World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Len().Between()),
		PtrStr("unable to find a step with Expect().Headers().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().Between(2, 2),
			Expect().Headers("Hello-World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().Equal(2),
			Expect().Headers("Hello-World").Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Len().Equal()),
		PtrStr("unable to find a step with Expect().Headers().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().Equal(2),
			Expect().Headers("Hello-World").Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().GreaterOrEqualThan(2),
			Expect().Headers("Hello-World").Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Headers().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().GreaterOrEqualThan(2),
			Expect().Headers("Hello-World").Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().GreaterThan(2),
			Expect().Headers("Hello-World").Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Headers().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().GreaterThan(2),
			Expect().Headers("Hello-World").Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().LessOrEqualThan(2),
			Expect().Headers("Hello-World").Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Headers().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().LessOrEqualThan(2),
			Expect().Headers("Hello-World").Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().LessThan(2),
			Expect().Headers("Hello-World").Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Headers().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().LessThan(2),
			Expect().Headers("Hello-World").Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().NotBetween(2, 2),
			Expect().Headers("Hello-World").Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Headers().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().NotBetween(2, 2),
			Expect().Headers("Hello-World").Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().NotEqual(1, 2),
			Expect().Headers("Hello-World").Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Headers().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().NotEqual(1, 2),
			Expect().Headers("Hello-World").Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().NotOneOf(1, 2),
			Expect().Headers("Hello-World").Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Headers().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().NotOneOf(1, 2),
			Expect().Headers("Hello-World").Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().OneOf(1, 2),
			Expect().Headers("Hello-World").Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Headers().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Len().OneOf(1, 2),
			Expect().Headers("Hello-World").Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").NotContains("Foo", "Baz"),
			Expect().Headers("Hello-World").NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().NotContains()),
		PtrStr("unable to find a step with Expect().Headers().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").NotContains("Foo", "Baz"),
			Expect().Headers("Hello-World").NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").NotEmpty(),
			Expect().Headers("Hello-World").NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Headers().NotEmpty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().NotEmpty()),
		PtrStr("unable to find a step with Expect().Headers().NotEmpty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").NotEmpty(),
			Expect().Headers("Hello-World").NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").NotEmpty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").NotEqual("Foo", "Baz"),
			Expect().Headers("Hello-World").NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().NotEqual()),
		PtrStr("unable to find a step with Expect().Headers().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").NotEqual("Foo", "Baz"),
			Expect().Headers("Hello-World").NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").NotOneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().NotOneOf()),
		PtrStr("unable to find a step with Expect().Headers().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").NotOneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").NotOneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNth(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Contains("Foo", "Baz"),
			Expect().Headers("Hello-World").Nth(3).Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth()),
		PtrStr("unable to find a step with Expect().Headers().Nth()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Contains("Foo", "Baz"),
			Expect().Headers("Hello-World").Nth(3).Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Contains()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Contains("Foo", "Baz"),
			Expect().Headers("Hello-World").Nth(3).Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Empty(),
			Expect().Headers("Hello-World").Nth(3).Empty(),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Empty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Empty()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Empty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Empty(),
			Expect().Headers("Hello-World").Nth(3).Empty(),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Empty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Equal("Foo-Taz"),
			Expect().Headers("Hello-World").Nth(3).Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Equal()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Equal("Foo-Taz"),
			Expect().Headers("Hello-World").Nth(3).Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Equal("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().Between(2, 2),
			Expect().Headers("Hello-World").Nth(3).Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Len()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().Between(2, 2),
			Expect().Headers("Hello-World").Nth(3).Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Len().Between()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().Between(2, 2),
			Expect().Headers("Hello-World").Nth(3).Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().Equal(2),
			Expect().Headers("Hello-World").Nth(3).Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Len().Equal()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().Equal(2),
			Expect().Headers("Hello-World").Nth(3).Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().GreaterOrEqualThan(2),
			Expect().Headers("Hello-World").Nth(3).Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().GreaterOrEqualThan(2),
			Expect().Headers("Hello-World").Nth(3).Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().GreaterThan(2),
			Expect().Headers("Hello-World").Nth(3).Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().GreaterThan(2),
			Expect().Headers("Hello-World").Nth(3).Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().LessOrEqualThan(2),
			Expect().Headers("Hello-World").Nth(3).Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().LessOrEqualThan(2),
			Expect().Headers("Hello-World").Nth(3).Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().LessThan(2),
			Expect().Headers("Hello-World").Nth(3).Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().LessThan(2),
			Expect().Headers("Hello-World").Nth(3).Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().NotBetween(2, 2),
			Expect().Headers("Hello-World").Nth(3).Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().NotBetween(2, 2),
			Expect().Headers("Hello-World").Nth(3).Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().NotEqual(1, 2),
			Expect().Headers("Hello-World").Nth(3).Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().NotEqual(1, 2),
			Expect().Headers("Hello-World").Nth(3).Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().NotOneOf(1, 2),
			Expect().Headers("Hello-World").Nth(3).Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().NotOneOf(1, 2),
			Expect().Headers("Hello-World").Nth(3).Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().OneOf(1, 2),
			Expect().Headers("Hello-World").Nth(3).Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Headers().Nth().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).Len().OneOf(1, 2),
			Expect().Headers("Hello-World").Nth(3).Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).NotContains("Foo", "Baz"),
			Expect().Headers("Hello-World").Nth(3).NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().NotContains()),
		PtrStr("unable to find a step with Expect().Headers().Nth().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).NotContains("Foo", "Baz"),
			Expect().Headers("Hello-World").Nth(3).NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).NotEmpty(),
			Expect().Headers("Hello-World").Nth(3).NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().NotEmpty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().NotEmpty()),
		PtrStr("unable to find a step with Expect().Headers().Nth().NotEmpty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).NotEmpty(),
			Expect().Headers("Hello-World").Nth(3).NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).NotEmpty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).NotEqual("Foo", "Baz"),
			Expect().Headers("Hello-World").Nth(3).NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().NotEqual()),
		PtrStr("unable to find a step with Expect().Headers().Nth().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).NotEqual("Foo", "Baz"),
			Expect().Headers("Hello-World").Nth(3).NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).NotOneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").Nth(3).NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().NotOneOf()),
		PtrStr("unable to find a step with Expect().Headers().Nth().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).NotOneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").Nth(3).NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).NotOneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersNthOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).OneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").Nth(3).OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().Nth().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().Nth().OneOf()),
		PtrStr("unable to find a step with Expect().Headers().Nth().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersNthOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").Nth(2).OneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").Nth(3).OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").Nth(2).OneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectHeadersOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").OneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Headers().OneOf()),
		PtrStr("unable to find a step with Expect().Headers().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectHeadersOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Headers("Foo-Bar").OneOf("Foo", "Baz"),
			Expect().Headers("Hello-World").OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Headers("Foo-Bar").OneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectStatus(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().Between(2, 2),
			Expect().Status().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Status(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Status()),
		PtrStr("unable to find a step with Expect().Status()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectStatusBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().Between(2, 2),
			Expect().Status().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Status().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Status().Between()),
		PtrStr("unable to find a step with Expect().Status().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectStatusBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().Between(2, 2),
			Expect().Status().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Status().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectStatusEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().Equal(2),
			Expect().Status().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Status().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Status().Equal()),
		PtrStr("unable to find a step with Expect().Status().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectStatusEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().Equal(2),
			Expect().Status().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Status().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectStatusGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().GreaterOrEqualThan(2),
			Expect().Status().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Status().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Status().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Status().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectStatusGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().GreaterOrEqualThan(2),
			Expect().Status().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Status().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectStatusGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().GreaterThan(2),
			Expect().Status().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Status().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Status().GreaterThan()),
		PtrStr("unable to find a step with Expect().Status().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectStatusGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().GreaterThan(2),
			Expect().Status().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Status().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectStatusLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().LessOrEqualThan(2),
			Expect().Status().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Status().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Status().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Status().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectStatusLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().LessOrEqualThan(2),
			Expect().Status().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Status().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectStatusLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().LessThan(2),
			Expect().Status().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Status().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Status().LessThan()),
		PtrStr("unable to find a step with Expect().Status().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectStatusLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().LessThan(2),
			Expect().Status().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Status().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectStatusNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().NotBetween(2, 2),
			Expect().Status().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Status().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Status().NotBetween()),
		PtrStr("unable to find a step with Expect().Status().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectStatusNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().NotBetween(2, 2),
			Expect().Status().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Status().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectStatusNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().NotEqual(1, 2),
			Expect().Status().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Status().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Status().NotEqual()),
		PtrStr("unable to find a step with Expect().Status().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectStatusNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().NotEqual(1, 2),
			Expect().Status().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Status().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectStatusNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().NotOneOf(1, 2),
			Expect().Status().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Status().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Status().NotOneOf()),
		PtrStr("unable to find a step with Expect().Status().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectStatusNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().NotOneOf(1, 2),
			Expect().Status().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Status().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectStatusOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().OneOf(1, 2),
			Expect().Status().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Status().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Status().OneOf()),
		PtrStr("unable to find a step with Expect().Status().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectStatusOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Status().OneOf(1, 2),
			Expect().Status().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Status().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailers(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Contains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers()),
		PtrStr("unable to find a step with Expect().Trailers()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectTrailersContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Contains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Contains()),
		PtrStr("unable to find a step with Expect().Trailers().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Contains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Empty(),
			Expect().Trailers("Hello-World").Empty(),
			storeSteps(&steps),
			Clear().Expect().Trailers().Empty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Empty()),
		PtrStr("unable to find a step with Expect().Trailers().Empty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Empty(),
			Expect().Trailers("Hello-World").Empty(),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Empty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Equal("Foo", "Baz"),
			Expect().Trailers("Hello-World").Equal("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Equal()),
		PtrStr("unable to find a step with Expect().Trailers().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Equal("Foo", "Baz"),
			Expect().Trailers("Hello-World").Equal("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Equal("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirst(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Contains("Foo", "Baz"),
			Expect().Trailers("Hello-World").First().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().First(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First()),
		PtrStr("unable to find a step with Expect().Trailers().First()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Contains("Foo", "Baz"),
			Expect().Trailers("Hello-World").First().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Contains()),
		PtrStr("unable to find a step with Expect().Trailers().First().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Contains("Foo", "Baz"),
			Expect().Trailers("Hello-World").First().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Empty(),
			Expect().Trailers("Hello-World").First().Empty(),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Empty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Empty()),
		PtrStr("unable to find a step with Expect().Trailers().First().Empty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Empty(),
			Expect().Trailers("Hello-World").First().Empty(),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Empty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Equal("Foo-Taz"),
			Expect().Trailers("Hello-World").First().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Equal()),
		PtrStr("unable to find a step with Expect().Trailers().First().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Equal("Foo-Taz"),
			Expect().Trailers("Hello-World").First().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Equal("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().Between(2, 2),
			Expect().Trailers("Hello-World").First().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Len()),
		PtrStr("unable to find a step with Expect().Trailers().First().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().Between(2, 2),
			Expect().Trailers("Hello-World").First().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Len().Between()),
		PtrStr("unable to find a step with Expect().Trailers().First().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().Between(2, 2),
			Expect().Trailers("Hello-World").First().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().Equal(2),
			Expect().Trailers("Hello-World").First().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Len().Equal()),
		PtrStr("unable to find a step with Expect().Trailers().First().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().Equal(2),
			Expect().Trailers("Hello-World").First().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().GreaterOrEqualThan(2),
			Expect().Trailers("Hello-World").First().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Trailers().First().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().GreaterOrEqualThan(2),
			Expect().Trailers("Hello-World").First().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().GreaterThan(2),
			Expect().Trailers("Hello-World").First().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Trailers().First().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().GreaterThan(2),
			Expect().Trailers("Hello-World").First().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().LessOrEqualThan(2),
			Expect().Trailers("Hello-World").First().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Trailers().First().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().LessOrEqualThan(2),
			Expect().Trailers("Hello-World").First().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().LessThan(2),
			Expect().Trailers("Hello-World").First().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Trailers().First().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().LessThan(2),
			Expect().Trailers("Hello-World").First().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().NotBetween(2, 2),
			Expect().Trailers("Hello-World").First().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Trailers().First().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().NotBetween(2, 2),
			Expect().Trailers("Hello-World").First().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().NotEqual(1, 2),
			Expect().Trailers("Hello-World").First().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Trailers().First().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().NotEqual(1, 2),
			Expect().Trailers("Hello-World").First().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().NotOneOf(1, 2),
			Expect().Trailers("Hello-World").First().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Trailers().First().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().NotOneOf(1, 2),
			Expect().Trailers("Hello-World").First().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().OneOf(1, 2),
			Expect().Trailers("Hello-World").First().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Trailers().First().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().Len().OneOf(1, 2),
			Expect().Trailers("Hello-World").First().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().NotContains("Foo", "Baz"),
			Expect().Trailers("Hello-World").First().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().NotContains()),
		PtrStr("unable to find a step with Expect().Trailers().First().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().NotContains("Foo", "Baz"),
			Expect().Trailers("Hello-World").First().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().NotEmpty(),
			Expect().Trailers("Hello-World").First().NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().NotEmpty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().NotEmpty()),
		PtrStr("unable to find a step with Expect().Trailers().First().NotEmpty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().NotEmpty(),
			Expect().Trailers("Hello-World").First().NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().NotEmpty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().NotEqual("Foo", "Baz"),
			Expect().Trailers("Hello-World").First().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().NotEqual()),
		PtrStr("unable to find a step with Expect().Trailers().First().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().NotEqual("Foo", "Baz"),
			Expect().Trailers("Hello-World").First().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().NotOneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").First().NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().NotOneOf()),
		PtrStr("unable to find a step with Expect().Trailers().First().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().NotOneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").First().NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().NotOneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersFirstOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().OneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").First().OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().First().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().First().OneOf()),
		PtrStr("unable to find a step with Expect().Trailers().First().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersFirstOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").First().OneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").First().OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").First().OneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLast(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Contains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Last().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last()),
		PtrStr("unable to find a step with Expect().Trailers().Last()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Contains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Last().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Contains()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Contains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Last().Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Empty(),
			Expect().Trailers("Hello-World").Last().Empty(),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Empty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Empty()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Empty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Empty(),
			Expect().Trailers("Hello-World").Last().Empty(),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Empty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Equal("Foo-Taz"),
			Expect().Trailers("Hello-World").Last().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Equal()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Equal("Foo-Taz"),
			Expect().Trailers("Hello-World").Last().Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Equal("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().Between(2, 2),
			Expect().Trailers("Hello-World").Last().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Len()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().Between(2, 2),
			Expect().Trailers("Hello-World").Last().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Len().Between()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().Between(2, 2),
			Expect().Trailers("Hello-World").Last().Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().Equal(2),
			Expect().Trailers("Hello-World").Last().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Len().Equal()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().Equal(2),
			Expect().Trailers("Hello-World").Last().Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().GreaterOrEqualThan(2),
			Expect().Trailers("Hello-World").Last().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().GreaterOrEqualThan(2),
			Expect().Trailers("Hello-World").Last().Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().GreaterThan(2),
			Expect().Trailers("Hello-World").Last().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().GreaterThan(2),
			Expect().Trailers("Hello-World").Last().Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().LessOrEqualThan(2),
			Expect().Trailers("Hello-World").Last().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().LessOrEqualThan(2),
			Expect().Trailers("Hello-World").Last().Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().LessThan(2),
			Expect().Trailers("Hello-World").Last().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().LessThan(2),
			Expect().Trailers("Hello-World").Last().Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().NotBetween(2, 2),
			Expect().Trailers("Hello-World").Last().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().NotBetween(2, 2),
			Expect().Trailers("Hello-World").Last().Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().NotEqual(1, 2),
			Expect().Trailers("Hello-World").Last().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().NotEqual(1, 2),
			Expect().Trailers("Hello-World").Last().Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().NotOneOf(1, 2),
			Expect().Trailers("Hello-World").Last().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().NotOneOf(1, 2),
			Expect().Trailers("Hello-World").Last().Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().OneOf(1, 2),
			Expect().Trailers("Hello-World").Last().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Trailers().Last().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().Len().OneOf(1, 2),
			Expect().Trailers("Hello-World").Last().Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().NotContains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Last().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().NotContains()),
		PtrStr("unable to find a step with Expect().Trailers().Last().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().NotContains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Last().NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().NotEmpty(),
			Expect().Trailers("Hello-World").Last().NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().NotEmpty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().NotEmpty()),
		PtrStr("unable to find a step with Expect().Trailers().Last().NotEmpty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().NotEmpty(),
			Expect().Trailers("Hello-World").Last().NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().NotEmpty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().NotEqual("Foo", "Baz"),
			Expect().Trailers("Hello-World").Last().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().NotEqual()),
		PtrStr("unable to find a step with Expect().Trailers().Last().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().NotEqual("Foo", "Baz"),
			Expect().Trailers("Hello-World").Last().NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().NotOneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").Last().NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().NotOneOf()),
		PtrStr("unable to find a step with Expect().Trailers().Last().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().NotOneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").Last().NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().NotOneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLastOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().OneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").Last().OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Last().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Last().OneOf()),
		PtrStr("unable to find a step with Expect().Trailers().Last().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLastOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Last().OneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").Last().OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Last().OneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().Between(2, 2),
			Expect().Trailers("Hello-World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Len()),
		PtrStr("unable to find a step with Expect().Trailers().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectTrailersLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().Between(2, 2),
			Expect().Trailers("Hello-World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Len().Between()),
		PtrStr("unable to find a step with Expect().Trailers().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().Between(2, 2),
			Expect().Trailers("Hello-World").Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().Equal(2),
			Expect().Trailers("Hello-World").Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Len().Equal()),
		PtrStr("unable to find a step with Expect().Trailers().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().Equal(2),
			Expect().Trailers("Hello-World").Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().GreaterOrEqualThan(2),
			Expect().Trailers("Hello-World").Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Trailers().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().GreaterOrEqualThan(2),
			Expect().Trailers("Hello-World").Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().GreaterThan(2),
			Expect().Trailers("Hello-World").Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Trailers().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().GreaterThan(2),
			Expect().Trailers("Hello-World").Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().LessOrEqualThan(2),
			Expect().Trailers("Hello-World").Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Trailers().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().LessOrEqualThan(2),
			Expect().Trailers("Hello-World").Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().LessThan(2),
			Expect().Trailers("Hello-World").Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Trailers().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().LessThan(2),
			Expect().Trailers("Hello-World").Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().NotBetween(2, 2),
			Expect().Trailers("Hello-World").Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Trailers().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().NotBetween(2, 2),
			Expect().Trailers("Hello-World").Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().NotEqual(1, 2),
			Expect().Trailers("Hello-World").Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Trailers().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().NotEqual(1, 2),
			Expect().Trailers("Hello-World").Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().NotOneOf(1, 2),
			Expect().Trailers("Hello-World").Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Trailers().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().NotOneOf(1, 2),
			Expect().Trailers("Hello-World").Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().OneOf(1, 2),
			Expect().Trailers("Hello-World").Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Trailers().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Len().OneOf(1, 2),
			Expect().Trailers("Hello-World").Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").NotContains("Foo", "Baz"),
			Expect().Trailers("Hello-World").NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().NotContains()),
		PtrStr("unable to find a step with Expect().Trailers().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").NotContains("Foo", "Baz"),
			Expect().Trailers("Hello-World").NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").NotEmpty(),
			Expect().Trailers("Hello-World").NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Trailers().NotEmpty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().NotEmpty()),
		PtrStr("unable to find a step with Expect().Trailers().NotEmpty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").NotEmpty(),
			Expect().Trailers("Hello-World").NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").NotEmpty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").NotEqual("Foo", "Baz"),
			Expect().Trailers("Hello-World").NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().NotEqual()),
		PtrStr("unable to find a step with Expect().Trailers().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").NotEqual("Foo", "Baz"),
			Expect().Trailers("Hello-World").NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").NotOneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().NotOneOf()),
		PtrStr("unable to find a step with Expect().Trailers().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").NotOneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").NotOneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNth(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Contains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Nth(3).Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth()),
		PtrStr("unable to find a step with Expect().Trailers().Nth()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Contains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Nth(3).Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Contains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Contains()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Contains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Contains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Nth(3).Contains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Contains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Empty(),
			Expect().Trailers("Hello-World").Nth(3).Empty(),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Empty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Empty()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Empty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Empty(),
			Expect().Trailers("Hello-World").Nth(3).Empty(),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Empty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Equal("Foo-Taz"),
			Expect().Trailers("Hello-World").Nth(3).Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Equal()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Equal("Foo-Taz"),
			Expect().Trailers("Hello-World").Nth(3).Equal("Hello-Universe"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Equal("Foo-Taz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthLen(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().Between(2, 2),
			Expect().Trailers("Hello-World").Nth(3).Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Len(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Len()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Len()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().Between(2, 2),
			Expect().Trailers("Hello-World").Nth(3).Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Len().Between(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Len().Between()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Len().Between()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthLenBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().Between(2, 2),
			Expect().Trailers("Hello-World").Nth(3).Len().Between(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Len().Between(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().Equal(2),
			Expect().Trailers("Hello-World").Nth(3).Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Len().Equal(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Len().Equal()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Len().Equal()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthLenEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().Equal(2),
			Expect().Trailers("Hello-World").Nth(3).Len().Equal(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Len().Equal(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().GreaterOrEqualThan(2),
			Expect().Trailers("Hello-World").Nth(3).Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Len().GreaterOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Len().GreaterOrEqualThan()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Len().GreaterOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthLenGreaterOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().GreaterOrEqualThan(2),
			Expect().Trailers("Hello-World").Nth(3).Len().GreaterOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Len().GreaterOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().GreaterThan(2),
			Expect().Trailers("Hello-World").Nth(3).Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Len().GreaterThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Len().GreaterThan()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Len().GreaterThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthLenGreaterThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().GreaterThan(2),
			Expect().Trailers("Hello-World").Nth(3).Len().GreaterThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Len().GreaterThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().LessOrEqualThan(2),
			Expect().Trailers("Hello-World").Nth(3).Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Len().LessOrEqualThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Len().LessOrEqualThan()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Len().LessOrEqualThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthLenLessOrEqualThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().LessOrEqualThan(2),
			Expect().Trailers("Hello-World").Nth(3).Len().LessOrEqualThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Len().LessOrEqualThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().LessThan(2),
			Expect().Trailers("Hello-World").Nth(3).Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Len().LessThan(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Len().LessThan()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Len().LessThan()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthLenLessThan(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().LessThan(2),
			Expect().Trailers("Hello-World").Nth(3).Len().LessThan(3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Len().LessThan(2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().NotBetween(2, 2),
			Expect().Trailers("Hello-World").Nth(3).Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Len().NotBetween(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Len().NotBetween()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Len().NotBetween()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthLenNotBetween(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().NotBetween(2, 2),
			Expect().Trailers("Hello-World").Nth(3).Len().NotBetween(3, 3),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Len().NotBetween(2, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().NotEqual(1, 2),
			Expect().Trailers("Hello-World").Nth(3).Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Len().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Len().NotEqual()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Len().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthLenNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().NotEqual(1, 2),
			Expect().Trailers("Hello-World").Nth(3).Len().NotEqual(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Len().NotEqual(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().NotOneOf(1, 2),
			Expect().Trailers("Hello-World").Nth(3).Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Len().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Len().NotOneOf()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Len().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthLenNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().NotOneOf(1, 2),
			Expect().Trailers("Hello-World").Nth(3).Len().NotOneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Len().NotOneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().OneOf(1, 2),
			Expect().Trailers("Hello-World").Nth(3).Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().Len().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().Len().OneOf()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().Len().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthLenOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).Len().OneOf(1, 2),
			Expect().Trailers("Hello-World").Nth(3).Len().OneOf(3, 4),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).Len().OneOf(1, 2),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).NotContains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Nth(3).NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().NotContains(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().NotContains()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().NotContains()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthNotContains(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).NotContains("Foo", "Baz"),
			Expect().Trailers("Hello-World").Nth(3).NotContains("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).NotContains("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).NotEmpty(),
			Expect().Trailers("Hello-World").Nth(3).NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().NotEmpty(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().NotEmpty()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().NotEmpty()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthNotEmpty(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).NotEmpty(),
			Expect().Trailers("Hello-World").Nth(3).NotEmpty(),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).NotEmpty(),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).NotEqual("Foo", "Baz"),
			Expect().Trailers("Hello-World").Nth(3).NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().NotEqual(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().NotEqual()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().NotEqual()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthNotEqual(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).NotEqual("Foo", "Baz"),
			Expect().Trailers("Hello-World").Nth(3).NotEqual("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).NotEqual("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).NotOneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").Nth(3).NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().NotOneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().NotOneOf()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().NotOneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthNotOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).NotOneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").Nth(3).NotOneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).NotOneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersNthOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).OneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").Nth(3).OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().Nth().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().Nth().OneOf()),
		PtrStr("unable to find a step with Expect().Trailers().Nth().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersNthOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").Nth(2).OneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").Nth(3).OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").Nth(2).OneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}
func TestGenClear_Generic_ExpectTrailersOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").OneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers().OneOf(),
			expectSteps(t, &steps, 2)),
		PtrStr("TestOK"),
	)
	// test unable to find a step
	ExpectError(t,
		Do(
			Post(s.URL),
			Clear().Expect().Trailers().OneOf()),
		PtrStr("unable to find a step with Expect().Trailers().OneOf()"),
		PtrStr("got these steps:"),
		PtrStr("Post()"),
	)
}
func TestGenClear_Specific_ExpectTrailersOneOf(t *testing.T) {
	s := EchoServer()
	defer s.Close()
	var steps []IStep
	ExpectError(t,
		Do(
			Post(s.URL),
			Expect().Trailers("Foo-Bar").OneOf("Foo", "Baz"),
			Expect().Trailers("Hello-World").OneOf("Hello", "Earth"),
			storeSteps(&steps),
			Clear().Expect().Trailers("Foo-Bar").OneOf("Foo", "Baz"),
			expectSteps(t, &steps, 1)),
		PtrStr("TestOK"),
	)
}