diff --git a/g/database/gredis/gredis_unit_test.go b/g/database/gredis/gredis_unit_test.go
index e0dcf7e94..99e9427cf 100644
--- a/g/database/gredis/gredis_unit_test.go
+++ b/g/database/gredis/gredis_unit_test.go
@@ -147,7 +147,7 @@ func Test_Basic(t *testing.T) {
 		}
 		redis := gredis.New(config1)
 		_, err := redis.Do("info")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 
 		config1 = gredis.Config{
 			Host: "127.0.0.1",
@@ -157,7 +157,7 @@ func Test_Basic(t *testing.T) {
 		}
 		redis = gredis.New(config1)
 		_, err = redis.Do("info")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 
 		config1 = gredis.Config{
 			Host: "127.0.0.1",
@@ -166,7 +166,7 @@ func Test_Basic(t *testing.T) {
 		}
 		redis = gredis.New(config1)
 		_, err = redis.Do("info")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 
 		redis = gredis.Instance("gf")
 		gtest.Assert(redis == nil, true)
diff --git a/g/encoding/gcompress/gcompress.go b/g/encoding/gcompress/gcompress.go
index 060c193e6..38bdc76be 100644
--- a/g/encoding/gcompress/gcompress.go
+++ b/g/encoding/gcompress/gcompress.go
@@ -5,8 +5,6 @@
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package gcompress provides kinds of compression algorithms for binary/bytes data.
-//
-// 数据压缩/解压.
 package gcompress
 
 import (
@@ -16,19 +14,19 @@ import (
     "io"
 )
 
-// 进行zlib压缩
+// Zlib compresses <data> with zlib algorithm.
 func Zlib(data []byte) []byte {
     if data == nil || len(data) < 13 {
         return data
     }
     var in bytes.Buffer
-    w := zlib.NewWriter(&in)
-    w.Write(data)
-    w.Close()
+    w   := zlib.NewWriter(&in)
+    _, _ = w.Write(data)
+    _    = w.Close()
     return in.Bytes()
 }
 
-// 进行zlib解压缩
+// UnZlib decompresses <data> with zlib algorithm.
 func UnZlib(data []byte) []byte {
     if data == nil || len(data) < 13 {
         return data
@@ -39,32 +37,32 @@ func UnZlib(data []byte) []byte {
     if err != nil {
         return nil
     }
-    io.Copy(&out, r)
+    _, _ = io.Copy(&out, r)
     return out.Bytes()
 }
 
-//做gzip解压缩
-func UnGzip(data []byte) []byte {
-    var buf bytes.Buffer
-	content := bytes.NewReader(data)
-	zipdata, err := gzip.NewReader(content)
-	if err != nil {
-		return nil
-	}
-	io.Copy(&buf, zipdata)
-	zipdata.Close()
-	return buf.Bytes()
-}
-
-//做gzip压缩
+// Gzip compresses <data> with gzip algorithm.
 func Gzip(data []byte) []byte {
-    var buf bytes.Buffer
-	zip := gzip.NewWriter(&buf)
+	var buf bytes.Buffer
+	zip    := gzip.NewWriter(&buf)
 	_, err := zip.Write(data)
 	if err != nil {
 		return nil
 	}
-	zip.Close()
-
+	_ = zip.Close()
 	return buf.Bytes()
-}
\ No newline at end of file
+}
+
+// UnGzip decompresses <data> with gzip algorithm.
+func UnGzip(data []byte) []byte {
+    var buf bytes.Buffer
+	content      := bytes.NewReader(data)
+	zipData, err := gzip.NewReader(content)
+	if err != nil {
+		return nil
+	}
+	_, _ = io.Copy(&buf, zipData)
+	_    = zipData.Close()
+	return buf.Bytes()
+}
+
diff --git a/g/encoding/gcompress/gcompress_test.go b/g/encoding/gcompress/gcompress_test.go
index dcd8f5c06..ac34a2027 100644
--- a/g/encoding/gcompress/gcompress_test.go
+++ b/g/encoding/gcompress/gcompress_test.go
@@ -3,6 +3,7 @@
 // This Source Code Form is subject to the terms of the MIT License.
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
+
 package gcompress_test
 
 import (
diff --git a/g/encoding/gjson/gjson_z_unit_basic_test.go b/g/encoding/gjson/gjson_z_unit_basic_test.go
index 20bc1b5fd..1afde1cc5 100644
--- a/g/encoding/gjson/gjson_z_unit_basic_test.go
+++ b/g/encoding/gjson/gjson_z_unit_basic_test.go
@@ -304,37 +304,37 @@ func Test_Convert(t *testing.T) {
 	gtest.Case(t, func() {
 		j := gjson.New(`{"name":"gf"}`)
 		arr, err := j.ToXml()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(string(arr), "<name>gf</name>")
 		arr, err = j.ToXmlIndent()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(string(arr), "<name>gf</name>")
 		str, err := j.ToXmlString()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(str, "<name>gf</name>")
 		str, err = j.ToXmlIndentString()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(str, "<name>gf</name>")
 
 		arr, err = j.ToJsonIndent()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(string(arr), "{\n\t\"name\": \"gf\"\n}")
 		str, err = j.ToJsonIndentString()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(string(arr), "{\n\t\"name\": \"gf\"\n}")
 
 		arr, err = j.ToYaml()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(string(arr), "name: gf\n")
 		str, err = j.ToYamlString()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(string(arr), "name: gf\n")
 
 		arr, err = j.ToToml()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(string(arr), "name = \"gf\"\n")
 		str, err = j.ToTomlString()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(string(arr), "name = \"gf\"\n")
 	})
 }
@@ -359,19 +359,19 @@ func Test_Convert2(t *testing.T) {
 		gtest.Assert(j.GetDuration("time").String(), "0s")
 
 		err := j.ToStruct(&name)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(name.Name, "gf")
 		err = j.Dump()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 
 		j = gjson.New(`{"person":{"name":"gf"}}`)
 		err = j.GetToStruct("person", &name)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(name.Name, "gf")
 
 		j = gjson.New(`{"name":"gf""}`)
 		err = j.Dump()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 
 		j = gjson.New(`[1,2,3]`)
 		gtest.Assert(len(j.ToArray()), 3)
@@ -388,37 +388,36 @@ func Test_Basic(t *testing.T) {
 		gtest.Assert(j.Get("").(g.Map)["name"], "gf")
 
 		err := j.Set("name", "gf1")
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(j.Get("name"), "gf1")
 
 		j = gjson.New(`[1,2,3]`)
 		err = j.Set("\"0\".1", 11)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(j.Get("1"), 11)
 
 		j = gjson.New(`[1,2,3]`)
 		err = j.Set("11111111111111111111111", 11)
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 
-		//此测试用例测出bug，数组下表越界，暂且注释起来，
-		/*j = gjson.New(`[1,2,3]`)
+		j   = gjson.New(`[1,2,3]`)
 		err = j.Remove("1")
-		gtest.Assert(err == nil, false)
-		gtest.Assert(j.Get("0"), nil)*/
+		gtest.Assert(err, nil)
+		gtest.Assert(j.Get("0"), 1)
 
 		j = gjson.New(`[1,2,3]`)
 		err = j.Remove("3")
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(j.Get("0"), 1)
 
 		j = gjson.New(`[1,2,3]`)
 		err = j.Remove("0.3")
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(len(j.Get("0").([]interface{})), 3)
 
 		j = gjson.New(`[1,2,3]`)
 		err = j.Remove("0.a")
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(len(j.Get("0").(g.Map)), 0)
 
 		name := struct {
@@ -427,35 +426,35 @@ func Test_Basic(t *testing.T) {
 		j = gjson.New(name)
 		gtest.Assert(j.Get("Name"), "gf")
 		err = j.Remove("Name")
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(j.Get("Name"), nil)
 
 		err = j.Set("Name", "gf1")
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(j.Get("Name"), "gf1")
 
 		j = gjson.New(nil)
 		err = j.Remove("Name")
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(j.Get("Name"), nil)
 
 		j = gjson.New(name)
 		gtest.Assert(j.Get("Name"), "gf")
 		err = j.Set("Name1", g.Map{"Name": "gf1"})
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(j.Get("Name1").(g.Map)["Name"], "gf1")
 		err = j.Set("Name2", g.Slice{1, 2, 3})
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(j.Get("Name2").(g.Slice)[0], 1)
 		err = j.Set("Name3", name)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(j.Get("Name3").(g.Map)["Name"], "gf")
 		err = j.Set("Name4", &name)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(j.Get("Name4").(g.Map)["Name"], "gf")
 		arr := [3]int{1, 2, 3}
 		err = j.Set("Name5", arr)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(j.Get("Name5").(g.Array)[0], 1)
 
 	})
diff --git a/g/encoding/gjson/gjson_z_unit_load_test.go b/g/encoding/gjson/gjson_z_unit_load_test.go
index 7698f71e3..aa8b9b803 100644
--- a/g/encoding/gjson/gjson_z_unit_load_test.go
+++ b/g/encoding/gjson/gjson_z_unit_load_test.go
@@ -177,18 +177,18 @@ func Test_Load_Basic(t *testing.T) {
 		j := gjson.NewUnsafe()
 		gtest.Assert(j.Value(), nil)
 		_, err := gjson.Decode(nil)
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 		_, err = gjson.DecodeToJson(nil)
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 		j, err = gjson.LoadContent(nil)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(j.Value(), nil)
 
 		j, err = gjson.LoadContent(`{"name": "gf"}`)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 
 		j, err = gjson.LoadContent(`{"name": "gf"""}`)
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 
 		j = gjson.New(&g.Map{"name": "gf"})
 		gtest.Assert(j.GetString("name"), "gf")
diff --git a/g/encoding/gparser/gparser_unit_basic_test.go b/g/encoding/gparser/gparser_unit_basic_test.go
index cdd24599b..484c8e5f7 100644
--- a/g/encoding/gparser/gparser_unit_basic_test.go
+++ b/g/encoding/gparser/gparser_unit_basic_test.go
@@ -233,11 +233,11 @@ func Test_Convert(t *testing.T) {
 			Name string
 		}{}
 		err := p.GetToStruct("person", &name)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(name.Name, "gf")
 		gtest.Assert(p.ToMap()["name"], "gf")
 		err = p.ToStruct(&name)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(name.Name, "gf")
 		p.Dump()
 
@@ -245,7 +245,7 @@ func Test_Convert(t *testing.T) {
 		gtest.Assert(p.ToArray()[0], 0)
 
 		err = gparser.VarToStruct(`{"name":"gf"}`, &name)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(name.Name, "gf")
 	})
 }
@@ -255,40 +255,40 @@ func Test_Convert2(t *testing.T) {
 		xmlArr := []byte{60, 114, 111, 111, 116, 47, 62}
 		p := gparser.New(`<root></root>`)
 		arr, err := p.ToXml("root")
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(arr, xmlArr)
 		arr, err = gparser.VarToXml(`<root></root>`, "root")
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(arr, xmlArr)
 
 		arr, err = p.ToXmlIndent("root")
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(arr, xmlArr)
 		arr, err = gparser.VarToXmlIndent(`<root></root>`, "root")
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(arr, xmlArr)
 
 		p = gparser.New(`{"name":"gf"}`)
 		str, err := p.ToJsonString()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(str, `{"name":"gf"}`)
 		str, err = gparser.VarToJsonString(`{"name":"gf"}`)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(str, `{"name":"gf"}`)
 
 		jsonIndentArr := []byte{123, 10, 9, 34, 110, 97, 109, 101, 34, 58, 32, 34, 103, 102, 34, 10, 125}
 		arr, err = p.ToJsonIndent()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(arr, jsonIndentArr)
 		arr, err = gparser.VarToJsonIndent(`{"name":"gf"}`)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(arr, jsonIndentArr)
 
 		str, err = p.ToJsonIndentString()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(str, "{\n\t\"name\": \"gf\"\n}")
 		str, err = gparser.VarToJsonIndentString(`{"name":"gf"}`)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(str, "{\n\t\"name\": \"gf\"\n}")
 
 		yamlArr := []byte{124, 50, 10, 10, 32, 32, 110, 97, 109, 101, 58, 103, 102, 10}
@@ -296,12 +296,12 @@ func Test_Convert2(t *testing.T) {
 name:gf
 `)
 		arr, err = p.ToYaml()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(arr, yamlArr)
 		arr, err = gparser.VarToYaml(`
 name:gf
 `)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(arr, yamlArr)
 
 		tomlArr := []byte{110, 97, 109, 101, 32, 61, 32, 34, 103, 102, 34, 10}
@@ -309,12 +309,12 @@ name:gf
 name= "gf"
 `)
 		arr, err = p.ToToml()
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(arr, tomlArr)
 		arr, err = gparser.VarToToml(`
 name= "gf"
 `)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(arr, tomlArr)
 	})
 }
diff --git a/g/encoding/gparser/gparser_unit_load_test.go b/g/encoding/gparser/gparser_unit_load_test.go
index 993d7cfdf..919d12de1 100644
--- a/g/encoding/gparser/gparser_unit_load_test.go
+++ b/g/encoding/gparser/gparser_unit_load_test.go
@@ -182,9 +182,8 @@ func Test_Load_Nil(t *testing.T) {
 		ioutil.WriteFile(filePath, []byte("{"), 0644)
 		defer gfile.Remove(filePath)
 		_, err := gparser.Load("test.json")
-		//gtest.Assert(err == nil, false)
-		t.Log(err)
+		gtest.AssertNE(err, nil)
 		_, err = gparser.LoadContent("{")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 	})
 }
diff --git a/g/os/gcfg/gcfg_z_unit_test.go b/g/os/gcfg/gcfg_z_unit_test.go
index d5a88c96f..d4dc8a9b5 100644
--- a/g/os/gcfg/gcfg_z_unit_test.go
+++ b/g/os/gcfg/gcfg_z_unit_test.go
@@ -297,9 +297,9 @@ func TestCfg_SetPath(t *testing.T) {
 	gtest.Case(t, func() {
 		c := gcfg.New("config.yml")
 		err := c.SetPath("tmp")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 		err = c.SetPath("gcfg.go")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 		gtest.Assert(c.Get("name"), nil)
 	})
 }
@@ -316,9 +316,9 @@ func TestCfg_AddPath(t *testing.T) {
 	gtest.Case(t, func() {
 		c := gcfg.New("config.yml")
 		err := c.AddPath("tmp")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 		err = c.AddPath("gcfg.go")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 		gtest.Assert(c.Get("name"), nil)
 	})
 }
@@ -381,7 +381,7 @@ func TestCfg_Get(t *testing.T) {
 		gtest.Assert(c.GetDuration("time").String(), "0s")
 		t.Log(c.GetString("person"))
 		err := c.GetToStruct("person", &name)
-		gtest.Assert(err == nil, true)
+		gtest.Assert(err, nil)
 		gtest.Assert(name.Name, "gf")
 		gtest.Assert(c.GetFloats("floats") == nil, false)
 	})
diff --git a/g/os/gview/gview_unit_test.go b/g/os/gview/gview_unit_test.go
index b1c7f01a7..a6795e16c 100644
--- a/g/os/gview/gview_unit_test.go
+++ b/g/os/gview/gview_unit_test.go
@@ -199,25 +199,25 @@ func TestView_SetPath(t *testing.T) {
 	gtest.Case(t, func() {
 		view := gview.Instance("addpath")
 		err := view.AddPath("tmp")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 
 		err = view.AddPath("gview.go")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 
 		os.Setenv("GF_GVIEW_PATH", "tmp")
 		view = gview.Instance("setpath")
 		err = view.SetPath("tmp")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 
 		err = view.SetPath("gview.go")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 
 		view = gview.New(gfile.Pwd())
 		err = view.SetPath("tmp")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 
 		err = view.SetPath("gview.go")
-		gtest.Assert(err == nil, false)
+		gtest.AssertNE(err, nil)
 
 		os.Setenv("GF_GVIEW_PATH", "template")
 		gfile.Mkdir(gfile.Pwd() + gfile.Separator + "template")