massive refactoring against unit test lib

testing/assert/boolsubject.go

@@ -0,0 +1,45 @@
+package assert
+
+import (
+	"strconv"
+)
+
+func Bool(value bool) *BoolSubject {
+	return &BoolSubject{value: value}
+}
+
+type BoolSubject struct {
+	Subject
+	value bool
+}
+
+func (subject *BoolSubject) Named(name string) *BoolSubject {
+	subject.Subject.Named(name)
+	return subject
+}
+
+func (subject *BoolSubject) Fail(verb string, other bool) {
+	subject.FailWithMessage("Not true that " + subject.DisplayString() + " " + verb + " <" + strconv.FormatBool(other) + ">.")
+}
+
+func (subject *BoolSubject) DisplayString() string {
+	return subject.Subject.DisplayString(strconv.FormatBool(subject.value))
+}
+
+func (subject *BoolSubject) Equals(expectation bool) {
+	if subject.value != expectation {
+		subject.Fail("is equal to", expectation)
+	}
+}
+
+func (subject *BoolSubject) IsTrue() {
+	if subject.value != true {
+		subject.Fail("is", true)
+	}
+}
+
+func (subject *BoolSubject) IsFalse() {
+	if subject.value != false {
+		subject.Fail("is", false)
+	}
+}

testing/assert/bytessubject.go

@@ -0,0 +1,35 @@
+package assert
+
+import (
+	"bytes"
+	"fmt"
+)
+
+func Bytes(value []byte) *BytesSubject {
+	return &BytesSubject{value: value}
+}
+
+type BytesSubject struct {
+	Subject
+	value []byte
+}
+
+func (subject *BytesSubject) Named(name string) *BytesSubject {
+	subject.Subject.Named(name)
+	return subject
+}
+
+func (subject *BytesSubject) Fail(verb string, other []byte) {
+	otherString := fmt.Sprintf("%v", other)
+	subject.FailWithMessage("Not true that " + subject.DisplayString() + " " + verb + " <" + otherString + ">.")
+}
+
+func (subject *BytesSubject) DisplayString() string {
+	return subject.Subject.DisplayString(fmt.Sprintf("%v", subject.value))
+}
+
+func (subject *BytesSubject) Equals(expectation []byte) {
+	if !bytes.Equal(subject.value, expectation) {
+		subject.Fail("is equal to", expectation)
+	}
+}

testing/assert/bytesubject.go

@@ -0,0 +1,45 @@
+package assert
+
+import (
+	"strconv"
+)
+
+func Byte(value byte) *ByteSubject {
+	return &ByteSubject{value: value}
+}
+
+type ByteSubject struct {
+	Subject
+	value byte
+}
+
+func (subject *ByteSubject) Named(name string) *ByteSubject {
+	subject.Subject.Named(name)
+	return subject
+}
+
+func (subject *ByteSubject) Fail(verb string, other byte) {
+	subject.FailWithMessage("Not true that " + subject.DisplayString() + " " + verb + " <" + strconv.Itoa(int(other)) + ">.")
+}
+
+func (subject *ByteSubject) DisplayString() string {
+	return subject.Subject.DisplayString(strconv.Itoa(int(subject.value)))
+}
+
+func (subject *ByteSubject) Equals(expectation byte) {
+	if subject.value != expectation {
+		subject.Fail("is equal to", expectation)
+	}
+}
+
+func (subject *ByteSubject) GreaterThan(expectation byte) {
+	if subject.value <= expectation {
+		subject.Fail("is greater than", expectation)
+	}
+}
+
+func (subject *ByteSubject) LessThan(expectation byte) {
+	if subject.value >= expectation {
+		subject.Fail("is less than", expectation)
+	}
+}

testing/assert/errorsubject.go

@@ -0,0 +1,41 @@
+package assert
+
+func Error(value error) *ErrorSubject {
+	return &ErrorSubject{value: value}
+}
+
+type ErrorSubject struct {
+	Subject
+	value error
+}
+
+func (subject *ErrorSubject) Named(name string) *ErrorSubject {
+	subject.Subject.Named(name)
+	return subject
+}
+
+func (subject *ErrorSubject) Fail(verb string, other error) {
+	subject.FailWithMessage("Not true that " + subject.DisplayString() + " " + verb + " <" + other.Error() + ">.")
+}
+
+func (subject *ErrorSubject) DisplayString() string {
+	return subject.Subject.DisplayString(subject.value.Error())
+}
+
+func (subject *ErrorSubject) Equals(expectation error) {
+	if subject.value != expectation {
+		subject.Fail("is equal to", expectation)
+	}
+}
+
+func (subject *ErrorSubject) IsNil() {
+	if subject.value != nil {
+		subject.FailWithMessage("Not true that " + subject.DisplayString() + " is nil.")
+	}
+}
+
+func (subject *ErrorSubject) IsNotNil() {
+	if subject.value == nil {
+		subject.FailWithMessage("Not true that the error is not nil.")
+	}
+}

testing/assert/int64subject.go

@@ -0,0 +1,51 @@
+package assert
+
+import (
+	"strconv"
+)
+
+func Int64(value int64) *Int64Subject {
+	return &Int64Subject{value: value}
+}
+
+type Int64Subject struct {
+	Subject
+	value int64
+}
+
+func (subject *Int64Subject) Named(name string) *Int64Subject {
+	subject.Subject.Named(name)
+	return subject
+}
+
+func (subject *Int64Subject) Fail(verb string, other int64) {
+	subject.FailWithMessage("Not true that " + subject.DisplayString() + " " + verb + " <" + strconv.FormatInt(other, 10) + ">.")
+}
+
+func (subject *Int64Subject) DisplayString() string {
+	return subject.Subject.DisplayString(strconv.FormatInt(subject.value, 10))
+}
+
+func (subject *Int64Subject) Equals(expectation int64) {
+	if subject.value != expectation {
+		subject.Fail("is equal to", expectation)
+	}
+}
+
+func (subject *Int64Subject) GreaterThan(expectation int64) {
+	if subject.value <= expectation {
+		subject.Fail("is greater than", expectation)
+	}
+}
+
+func (subject *Int64Subject) AtMost(expectation int64) {
+	if subject.value > expectation {
+		subject.Fail("is at most", expectation)
+	}
+}
+
+func (subject *Int64Subject) AtLeast(expectation int64) {
+	if subject.value < expectation {
+		subject.Fail("is at least", expectation)
+	}
+}

testing/assert/intsubject.go

@@ -0,0 +1,45 @@
+package assert
+
+import (
+	"strconv"
+)
+
+func Int(value int) *IntSubject {
+	return &IntSubject{value: value}
+}
+
+type IntSubject struct {
+	*Subject
+	value int
+}
+
+func (subject *IntSubject) Named(name string) *IntSubject {
+	subject.Subject.Named(name)
+	return subject
+}
+
+func (subject *IntSubject) Fail(verb string, other int) {
+	subject.FailWithMessage("Not true that " + subject.DisplayString() + " " + verb + " <" + strconv.Itoa(other) + ">.")
+}
+
+func (subject *IntSubject) DisplayString() string {
+	return subject.Subject.DisplayString(strconv.Itoa(subject.value))
+}
+
+func (subject *IntSubject) Equals(expectation int) {
+	if subject.value != expectation {
+		subject.Fail("is equal to", expectation)
+	}
+}
+
+func (subject *IntSubject) GreaterThan(expectation int) {
+	if subject.value <= expectation {
+		subject.Fail("is greater than", expectation)
+	}
+}
+
+func (subject *IntSubject) LessThan(expectation int) {
+	if subject.value >= expectation {
+		subject.Fail("is less than", expectation)
+	}
+}

testing/assert/pointersubject.go

@@ -0,0 +1,45 @@
+package assert
+
+import (
+	"fmt"
+)
+
+func Pointer(value interface{}) *PointerSubject {
+	return &PointerSubject{value: value}
+}
+
+type PointerSubject struct {
+	Subject
+	value interface{}
+}
+
+func (subject *PointerSubject) Named(name string) *PointerSubject {
+	subject.Subject.Named(name)
+	return subject
+}
+
+func (subject *PointerSubject) Fail(verb string, other interface{}) {
+	subject.FailWithMessage(fmt.Sprintf("Not true that %s %s <%v>.", subject.DisplayString(), verb, other))
+}
+
+func (subject *PointerSubject) DisplayString() string {
+	return subject.Subject.DisplayString(fmt.Sprintf("%v", subject.value))
+}
+
+func (subject *PointerSubject) Equals(expectation interface{}) {
+	if subject.value != expectation {
+		subject.Fail("is equal to", expectation)
+	}
+}
+
+func (subject *PointerSubject) IsNil() {
+	if subject.value != nil {
+		subject.FailWithMessage("Not true that " + subject.DisplayString() + " is nil.")
+	}
+}
+
+func (subject *PointerSubject) IsNotNil() {
+	if subject.value == nil {
+		subject.FailWithMessage("Not true that " + subject.DisplayString() + " is not nil.")
+	}
+}

testing/assert/stringsubject.go

@@ -0,0 +1,29 @@
+package assert
+
+func String(value string) *StringSubject {
+	return &StringSubject{value: value}
+}
+
+type StringSubject struct {
+	Subject
+	value string
+}
+
+func (subject *StringSubject) Named(name string) *StringSubject {
+	subject.Subject.Named(name)
+	return subject
+}
+
+func (subject *StringSubject) Fail(verb string, other string) {
+	subject.FailWithMessage("Not true that " + subject.DisplayString() + " " + verb + " <" + other + ">.")
+}
+
+func (subject *StringSubject) DisplayString() string {
+	return subject.Subject.DisplayString(subject.value)
+}
+
+func (subject *StringSubject) Equals(expectation string) {
+	if subject.value != expectation {
+		subject.Fail("is equal to", expectation)
+	}
+}

testing/assert/subject.go

@@ -0,0 +1,33 @@
+package assert
+
+import (
+	v2testing "github.com/v2ray/v2ray-core/testing"
+)
+
+type Subject struct {
+	name string
+}
+
+func NewSubject() *Subject {
+	return &Subject{
+		name: "",
+	}
+}
+
+func (subject *Subject) FailWithMessage(message string) {
+	v2testing.Fail(message)
+}
+
+func (subject *Subject) Named(name string) {
+	subject.name = name
+}
+
+func (subject *Subject) DisplayString(value string) string {
+	if len(value) == 0 {
+		value = "unknown"
+	}
+	if len(subject.name) == 0 {
+		return "<" + value + ">"
+	}
+	return subject.name + "(<" + value + ">)"
+}

testing/assert/uint16subject.go

@@ -0,0 +1,51 @@
+package assert
+
+import (
+	"strconv"
+)
+
+func Uint16(value uint16) *Uint16Subject {
+	return &Uint16Subject{value: value}
+}
+
+type Uint16Subject struct {
+	Subject
+	value uint16
+}
+
+func (subject *Uint16Subject) Named(name string) *Uint16Subject {
+	subject.Subject.Named(name)
+	return subject
+}
+
+func (subject *Uint16Subject) Fail(verb string, other uint16) {
+	subject.FailWithMessage("Not true that " + subject.DisplayString() + " " + verb + " <" + strconv.Itoa(int(other)) + ">.")
+}
+
+func (subject *Uint16Subject) DisplayString() string {
+	return subject.Subject.DisplayString(strconv.Itoa(int(subject.value)))
+}
+
+func (subject *Uint16Subject) Equals(expectation uint16) {
+	if subject.value != expectation {
+		subject.Fail("is equal to", expectation)
+	}
+}
+
+func (subject *Uint16Subject) GreaterThan(expectation uint16) {
+	if subject.value <= expectation {
+		subject.Fail("is greater than", expectation)
+	}
+}
+
+func (subject *Uint16Subject) LessThan(expectation uint16) {
+	if subject.value >= expectation {
+		subject.Fail("is less than", expectation)
+	}
+}
+
+func (subject *Uint16Subject) Positive() {
+	if subject.value <= 0 {
+		subject.FailWithMessage("Not true that " + subject.DisplayString() + " is positive.")
+	}
+}