Documentation

Overview

    Package gtest provides convenient test utilities for unit testing.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func Assert

    func Assert(value, expect interface{})

      Assert checks `value` and `expect` EQUAL.

      func AssertEQ

      func AssertEQ(value, expect interface{})

        AssertEQ checks `value` and `expect` EQUAL, including their TYPES.

        func AssertGE

        func AssertGE(value, expect interface{})

          AssertGE checks `value` is GREATER OR EQUAL THAN `expect`. Notice that, only string, integer and float types can be compared by AssertGTE, others are invalid.

          func AssertGT

          func AssertGT(value, expect interface{})

            AssertGT checks `value` is GREATER THAN `expect`. Notice that, only string, integer and float types can be compared by AssertGT, others are invalid.

            func AssertIN

            func AssertIN(value, expect interface{})

              AssertIN checks `value` is IN `expect`. The `expect` should be a slice, but the `value` can be a slice or a basic type variable. TODO map support.

              func AssertLE

              func AssertLE(value, expect interface{})

                AssertLE checks `value` is LESS OR EQUAL THAN `expect`. Notice that, only string, integer and float types can be compared by AssertLTE, others are invalid.

                func AssertLT

                func AssertLT(value, expect interface{})

                  AssertLT checks `value` is LESS EQUAL THAN `expect`. Notice that, only string, integer and float types can be compared by AssertLT, others are invalid.

                  func AssertNE

                  func AssertNE(value, expect interface{})

                    AssertNE checks `value` and `expect` NOT EQUAL.

                    func AssertNI

                    func AssertNI(value, expect interface{})

                      AssertNI checks `value` is NOT IN `expect`. The `expect` should be a slice, but the `value` can be a slice or a basic type variable. TODO map support.

                      func AssertNQ

                      func AssertNQ(value, expect interface{})

                        AssertNQ checks `value` and `expect` NOT EQUAL, including their TYPES.

                        func AssertNil

                        func AssertNil(value interface{})

                          AssertNil asserts `value` is nil.

                          func C

                          func C(t *testing.T, f func(t *T))

                            C creates an unit testing case. The parameter `t` is the pointer to testing.T of stdlib (*testing.T). The parameter `f` is the closure function for unit testing case.

                            func Case

                            func Case(t *testing.T, f func())

                              Case creates an unit testing case. The parameter `t` is the pointer to testing.T of stdlib (*testing.T). The parameter `f` is the closure function for unit testing case. Deprecated.

                              func Error

                              func Error(message ...interface{})

                                Error panics with given `message`.

                                func Fatal

                                func Fatal(message ...interface{})

                                  Fatal prints `message` to stderr and exit the process.

                                  Types

                                  type T

                                  type T struct {
                                  	*testing.T
                                  }

                                    T is the testing unit case management object.

                                    func (*T) Assert

                                    func (t *T) Assert(value, expect interface{})

                                      Assert checks `value` and `expect` EQUAL.

                                      func (*T) AssertEQ

                                      func (t *T) AssertEQ(value, expect interface{})

                                        AssertEQ checks `value` and `expect` EQUAL, including their TYPES.

                                        func (*T) AssertGE

                                        func (t *T) AssertGE(value, expect interface{})

                                          AssertGE checks `value` is GREATER OR EQUAL THAN `expect`. Notice that, only string, integer and float types can be compared by AssertGTE, others are invalid.

                                          func (*T) AssertGT

                                          func (t *T) AssertGT(value, expect interface{})

                                            AssertGT checks `value` is GREATER THAN `expect`. Notice that, only string, integer and float types can be compared by AssertGT, others are invalid.

                                            func (*T) AssertIN

                                            func (t *T) AssertIN(value, expect interface{})

                                              AssertIN checks `value` is IN `expect`. The `expect` should be a slice, but the `value` can be a slice or a basic type variable.

                                              func (*T) AssertLE

                                              func (t *T) AssertLE(value, expect interface{})

                                                AssertLE checks `value` is LESS OR EQUAL THAN `expect`. Notice that, only string, integer and float types can be compared by AssertLTE, others are invalid.

                                                func (*T) AssertLT

                                                func (t *T) AssertLT(value, expect interface{})

                                                  AssertLT checks `value` is LESS EQUAL THAN `expect`. Notice that, only string, integer and float types can be compared by AssertLT, others are invalid.

                                                  func (*T) AssertNE

                                                  func (t *T) AssertNE(value, expect interface{})

                                                    AssertNE checks `value` and `expect` NOT EQUAL.

                                                    func (*T) AssertNI

                                                    func (t *T) AssertNI(value, expect interface{})

                                                      AssertNI checks `value` is NOT IN `expect`. The `expect` should be a slice, but the `value` can be a slice or a basic type variable.

                                                      func (*T) AssertNQ

                                                      func (t *T) AssertNQ(value, expect interface{})

                                                        AssertNQ checks `value` and `expect` NOT EQUAL, including their TYPES.

                                                        func (*T) AssertNil

                                                        func (t *T) AssertNil(value interface{})

                                                          AssertNil asserts `value` is nil.

                                                          func (*T) Error

                                                          func (t *T) Error(message ...interface{})

                                                            Error panics with given `message`.

                                                            func (*T) Fatal

                                                            func (t *T) Fatal(message ...interface{})

                                                              Fatal prints `message` to stderr and exit the process.