doc: update docs.

Author: ghosind

README.md

@@ -31,6 +31,9 @@ func TestExample(t *testing.T) {
   // assert inequality
   assert.NotEqual(t, actual, expect)
 
+  // you can also use DeepEqual to assert the equality that also checks the type between the values
+  assert.DeepEqual(t, actual, expect)
+
   // var object
 
   // assert for nil
@@ -41,6 +44,30 @@ func TestExample(t *testing.T) {
 }
 ```
 
+You can use `True` method to check whether a value is truthy or falsy (is the zero value of the type or not).
+
+```go
+func TestExample(t *testing.T) {
+  assert.True(t, 1) // success
+  assert.True(t, 0) // fail
+  assert.True(t, "test") // success
+  assert.True(t, "") // fail
+}
+```
+
+If you want to test the value of a string, you can use `Match` method to test it with a regular expression pattern.
+
+```go
+func TestExample(t *testing.T) {
+  pattern := regexp.MustCompile(`^https?:\/\/`)
+  assert.Match(t, "https://example.com", pattern) // success
+  assert.Match(t, "example.com", pattern) // fail
+
+  // you can also use `MatchString` to test it without compiling the regexp pattern
+  assert.MatchString(t, "https://example.com", `^https?:\/\/`) // success
+}
+```
+
 It also provided assertion functions to verify a function will panic or not:
 
 ```go
@@ -71,7 +98,7 @@ func TestExample(t *testing.T) {
   // The following line will set the test result to fail and stop the execution
   assert.EqualNow(t, actual, expect)
 
-  // The following lines will never execute if they are not deep equal.
+  // The following lines will never execute if they are not equal.
   // ...
 }
 ```

assertion.go

@@ -4,11 +4,16 @@ import (
 	"testing"
 )
 
+// Assertion is the extension of the Go builtin `testing.T`.
 type Assertion struct {
 	*testing.T
 }
 
 // New returns an assertion instance for verifying invariants.
+//
+//	assertion := assert.New(t)
+//	assertion.Equal(actual, expect)
+//	// ...
 func New(t *testing.T) *Assertion {
 	a := new(Assertion)
 
@@ -26,6 +31,11 @@ func New(t *testing.T) *Assertion {
 //
 // Run may be called simultaneously from multiple goroutines, but all such calls
 // must return before the outer test function for a returns.
+//
+//	assertion := assert.New(t)
+//	assertion.Run("SubTest", func (a *assert.Assertion) bool {
+//	  // TODO...
+//	})
 func (assertion *Assertion) Run(name string, f func(a *Assertion)) bool {
 	return assertion.T.Run(name, func(t *testing.T) {
 		subAssertion := New(t)