diff --git a/errors/easy_func_test.go b/errors/easy_func_test.go
new file mode 100644
index 0000000..146f696
--- /dev/null
+++ b/errors/easy_func_test.go
@@ -0,0 +1,1031 @@
+package error
+
+import (
+	"code.30cm.net/digimon/library-go/errors/code"
+	"context"
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+	"github.com/zeromicro/go-zero/core/logx"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func TestFromGRPCError_GivenStatusWithCodeAndMessage_ShouldReturnErr(t *testing.T) {
+	// setup
+	s := status.Error(codes.Code(102399), "FAKE ERROR")
+
+	// act
+	e := FromGRPCError(s)
+
+	// assert
+	assert.Equal(t, uint32(10), e.Scope())
+	assert.Equal(t, uint32(2300), e.Category())
+	assert.Equal(t, uint32(2399), e.Code())
+	assert.Equal(t, "FAKE ERROR", e.Error())
+}
+
+func TestFromGRPCError_GivenNilError_ShouldReturnErr_Scope0_Cat0_Detail0(t *testing.T) {
+	// setup
+	var nilError error = nil
+
+	// act
+	e := FromGRPCError(nilError)
+
+	// assert
+	assert.Equal(t, uint32(0), e.Scope())
+	assert.Equal(t, uint32(0), e.Category())
+	assert.Equal(t, uint32(0), e.Code())
+	assert.Equal(t, "", e.Error())
+}
+
+func TestFromGRPCError_GivenGRPCNativeError_ShouldReturnErr_Scope0_CatGRPC_DetailGRPCUnavailable(t *testing.T) {
+	// setup
+	msg := "GRPC Unavailable ERROR"
+	s := status.Error(codes.Code(codes.Unavailable), msg)
+
+	// act
+	e := FromGRPCError(s)
+
+	// assert
+	assert.Equal(t, code.Unset, e.Scope())
+	assert.Equal(t, code.CatGRPC, e.Category())
+	assert.Equal(t, uint32(codes.Unavailable), e.Code())
+	assert.Equal(t, msg, e.Error())
+}
+
+func TestFromGRPCError_GivenGeneralError_ShouldReturnErr_Scope0_CatGRPC_DetailGRPCUnknown(t *testing.T) {
+	// setup
+	generalErr := errors.New("general error")
+
+	// act
+	e := FromGRPCError(generalErr)
+
+	// assert
+	assert.Equal(t, code.Unset, e.Scope())
+	assert.Equal(t, code.CatGRPC, e.Category())
+	assert.Equal(t, uint32(codes.Unknown), e.Code())
+}
+
+func TestToGRPCError_GivenErr_StatusShouldHave_Code112233(t *testing.T) {
+	// setup
+	e := Err{scope: 11, code: 2233, msg: "FAKE MSG"}
+
+	// act
+	err := ToGRPCError(&e)
+	s, _ := status.FromError(err)
+
+	// assert
+	assert.Equal(t, 112233, int(s.Code()))
+	assert.Equal(t, "FAKE MSG", s.Message())
+}
+
+func TestInvalidFormat_WithStrings_ShouldHasCatInputAndDetailCode(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := InvalidFormat("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatInput, e.Category())
+	assert.Equal(t, code.InvalidFormat, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Equal(t, e.Error(), "invalid format: field A Error description")
+}
+
+func TestInvalidFormatL_WithStrings_ShouldHasCatInputAndDetailCode(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	ctx := context.Background()
+	// act
+	e := InvalidFormatL(logx.WithContext(ctx), "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatInput, e.Category())
+	assert.Equal(t, code.InvalidFormat, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestInvalidRange_WithStrings_ShouldHasCatInputAndDetailCode(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := InvalidRange("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatInput, e.Category())
+	assert.Equal(t, code.InvalidRange, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Equal(t, e.Error(), "invalid range: field A Error description")
+}
+
+func TestInvalidRangeL_WithStrings_ShouldHasCatInputAndDetailCode(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	ctx := context.Background()
+	// act
+	e := InvalidRangeL(logx.WithContext(ctx), "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatInput, e.Category())
+	assert.Equal(t, code.InvalidRange, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestNotValidImplementation_WithStrings_ShouldHasCatInputAndDetailCode(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := NotValidImplementation("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatInput, e.Category())
+	assert.Equal(t, code.NotValidImplementation, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Equal(t, e.Error(), "not valid implementation: field A Error description")
+}
+
+func TestNotValidImplementationL_WithStrings_ShouldHasCatInputAndDetailCode(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+	// act
+	e := NotValidImplementationL(l, "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatInput, e.Category())
+	assert.Equal(t, code.NotValidImplementation, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestDBError_WithStrings_ShouldHasCatDBAndDetailCodeDBError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := DBError("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatDB, e.Category())
+	assert.Equal(t, code.DBError, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestDBDataConvert_WithStrings_ShouldHasCatDBAndDetailCodeDBDataConvert(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := DBDataConvert("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatDB, e.Category())
+	assert.Equal(t, code.DBDataConvert, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestResourceNotFound_WithStrings_ShouldHasCatResource_DetailCodeResourceNotFound(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := ResourceNotFound("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.ResourceNotFound, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestInvalidResourceFormat_WithStrings_ShouldHasCatResource_DetailCodeInvalidResourceFormat(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := InvalidResourceFormat("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.InvalidResourceFormat, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestInvalidResourceState_OK(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := InvalidResourceState("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.InvalidResourceState, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.EqualError(t, e, "invalid resource state: field A Error description")
+}
+
+func TestInvalidResourceStateL_LogError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+
+	// act
+	e := InvalidResourceStateL(l, "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.InvalidResourceState, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.EqualError(t, e, "invalid resource state: field A Error description")
+}
+
+func TestAuthExpired_OK(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := AuthExpired("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatAuth, e.Category())
+	assert.Equal(t, code.AuthExpired, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestUnauthorized_WithStrings_ShouldHasCatAuth_DetailCodeUnauthorized(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := Unauthorized("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatAuth, e.Category())
+	assert.Equal(t, code.Unauthorized, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestInvalidPosixTime_WithStrings_ShouldHasCatAuth_DetailCodeInvalidPosixTime(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := InvalidPosixTime("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatAuth, e.Category())
+	assert.Equal(t, code.InvalidPosixTime, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestSigAndPayloadNotMatched_WithStrings_ShouldHasCatAuth_DetailCodeSigAndPayloadNotMatched(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := SigAndPayloadNotMatched("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatAuth, e.Category())
+	assert.Equal(t, code.SigAndPayloadNotMatched, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestForbidden_WithStrings_ShouldHasCatAuth_DetailCodeForbidden(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := Forbidden("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatAuth, e.Category())
+	assert.Equal(t, code.Forbidden, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestXBCInternal_WithStrings_ShouldHasCatResource_DetailCodeXBCInternal(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := ArkInternal("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatArk, e.Category())
+	assert.Equal(t, code.ArkInternal, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestGeneralInternalError_WithStrings_DetailInternalError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := SystemInternalError("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatSystem, e.Category())
+	assert.Equal(t, code.SystemInternalError, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestGeneralInternalErrorL_WithStrings_DetailInternalError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+
+	// act
+	e := SystemInternalErrorL(l, "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatSystem, e.Category())
+	assert.Equal(t, code.SystemInternalError, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestSystemMaintainError_WithStrings_DetailSystemMaintainError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+
+	// act
+	e := SystemMaintainErrorL(l, "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatSystem, e.Category())
+	assert.Equal(t, code.SystemMaintainError, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestResourceAlreadyExist_WithStrings_DetailInternalError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := ResourceAlreadyExist("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.ResourceAlreadyExist, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestResourceAlreadyExistL_WithStrings_DetailInternalError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+
+	// act
+	e := ResourceAlreadyExistL(l, "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.ResourceAlreadyExist, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestResourceInsufficient_WithStrings_DetailInternalError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := ResourceInsufficient("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.ResourceInsufficient, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestResourceInsufficientL_WithStrings_DetailInternalError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+
+	// act
+	e := ResourceInsufficientL(l, "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.ResourceInsufficient, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestInsufficientPermission_WithStrings_DetailInternalError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := InsufficientPermission("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.InsufficientPermission, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestInsufficientPermissionL_WithStrings_DetailInternalError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+
+	// act
+	e := InsufficientPermissionL(l, "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.InsufficientPermission, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestInvalidMeasurementID_WithErrorStrings_ShouldReturnCorrectCodeAndErrorString(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := InvalidMeasurementID("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.InvalidMeasurementID, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestInvalidMeasurementIDL_WithErrorStrings_ShouldReturnCorrectCodeAndErrorStringAndCallLogger(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+
+	// act
+	e := InvalidMeasurementIDL(l, "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.InvalidMeasurementID, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestResourceExpired_OK(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := ResourceExpired("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.ResourceExpired, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestResourceExpiredL_LogError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+
+	// act
+	e := ResourceExpiredL(l, "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.ResourceExpired, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestResourceMigrated_OK(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := ResourceMigrated("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.ResourceMigrated, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestResourceMigratedL_LogError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+
+	// act
+	e := ResourceMigratedL(l, "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.ResourceMigrated, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestInsufficientQuota_OK(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := InsufficientQuota("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.InsufficientQuota, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestInsufficientQuotaL_LogError(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+
+	// act
+	e := InsufficientQuotaL(l, "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatResource, e.Category())
+	assert.Equal(t, code.InsufficientQuota, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestPublish_WithErrorStrings_ShouldReturnCorrectCodeAndErrorString(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := Publish("field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatPubSub, e.Category())
+	assert.Equal(t, code.Publish, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestPublishL_WithErrorStrings_ShouldReturnCorrectCodeAndErrorStringAndCallLogger(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+
+	// act
+	e := PublishL(l, "field A", "Error description")
+
+	// assert
+	assert.Equal(t, code.CatPubSub, e.Category())
+	assert.Equal(t, code.Publish, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "field A")
+	assert.Contains(t, e.Error(), "Error description")
+}
+
+func TestMsgSizeTooLarge_WithErrorStrings_ShouldReturnCorrectCodeAndErrorString(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() {
+		Scope = code.Unset
+	}()
+
+	// act
+	e := MsgSizeTooLarge("Error description")
+
+	// assert
+	assert.Equal(t, code.CatPubSub, e.Category())
+	assert.Equal(t, code.MsgSizeTooLarge, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "kafka error: Error description")
+}
+
+func TestMsgSizeTooLargeL_WithErrorStrings_ShouldReturnCorrectCodeAndErrorStringAndCallLogger(t *testing.T) {
+	// setup
+	Scope = 99
+	defer func() { Scope = code.Unset }()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	l := logx.WithContext(context.Background())
+
+	// act
+	e := MsgSizeTooLargeL(l, "Error description")
+
+	// assert
+	assert.Equal(t, code.CatPubSub, e.Category())
+	assert.Equal(t, code.MsgSizeTooLarge, e.Code())
+	assert.Equal(t, uint32(99), e.Scope())
+	assert.Contains(t, e.Error(), "kafka error: Error description")
+}
+
+// func TestStructErr_WithInternalErr_ShouldIsFuncReportCorrectly(t *testing.T) {
+// 	// setup
+// 	Scope = 99
+// 	defer func() { Scope = code.Unset }()
+// 	// arrange 2 layers err
+// 	layer1Err := fmt.Errorf("layer 1 error")
+// 	layer2Err := fmt.Errorf("layer 2: %w", layer1Err)
+//
+// 	// act with error chain: InvalidFormat -> layer 2 err -> layer 1 err
+// 	e := InvalidFormat("field A", "Error description")
+// 	err := e.Wrap(layer2Err)
+// 	if err != nil {
+// 		t.Fatalf("Failed to wrap error: %v", err)
+// 	}
+//
+// 	// assert
+// 	assert.Equal(t, code.CatInput, e.Category())
+// 	assert.Equal(t, code.InvalidFormat, e.Code())
+// 	assert.Equal(t, uint32(99), e.Scope())
+// 	assert.Contains(t, e.Error(), "field A")
+// 	assert.Contains(t, e.Error(), "Error description")
+//
+// 	// errors.Is should report correctly
+// 	assert.True(t, errors.Is(e, layer1Err))
+// 	assert.True(t, errors.Is(e, layer2Err))
+// }
+
+// func TestStructErr_WithInternalErr_ShouldErrorOutputChainErrMessage(t *testing.T) {
+// 	// setup
+// 	Scope = 99
+// 	defer func() { Scope = code.Unset }()
+//
+// 	// arrange 2 layers err
+// 	layer1Err := fmt.Errorf("layer 1 error")
+// 	// act with error chain: InvalidFormat -> layer 1 err
+// 	e := InvalidFormat("field A", "Error description")
+// 	err := e.Wrap(layer1Err)
+// 	if err != nil {
+// 		t.Fatalf("Failed to wrap error: %v", err)
+// 	}
+//
+// 	// assert
+// 	assert.Equal(t, "invalid format: field A Error description: layer 1 error", e.Error())
+// }
+
+// arrange a specific err type just for UT
+type testErr struct {
+	code int
+}
+
+func (e *testErr) Error() string {
+	return strconv.Itoa(e.code)
+}
+
+// func TestStructErr_WithInternalErr_ShouldAsFuncReportCorrectly(t *testing.T) {
+// 	// setup
+// 	Scope = 99
+// 	defer func() { Scope = code.Unset }()
+//
+// 	testE := &testErr{code: 123}
+// 	layer2Err := fmt.Errorf("layer 2: %w", testE)
+//
+// 	// act with error chain: InvalidFormat -> layer 2 err -> testErr
+// 	e := InvalidFormat("field A", "Error description")
+// 	err := e.Wrap(layer2Err)
+// 	if err != nil {
+// 		t.Fatalf("Failed to wrap error: %v", err)
+// 	}
+//
+// 	// assert
+// 	assert.Equal(t, code.CatInput, e.Category())
+// 	assert.Equal(t, code.InvalidFormat, e.Code())
+// 	assert.Equal(t, uint32(99), e.Scope())
+// 	assert.Contains(t, e.Error(), "field A")
+// 	assert.Contains(t, e.Error(), "Error description")
+//
+// 	// errors.As should report correctly
+// 	var internalErr *testErr
+// 	assert.True(t, errors.As(e, &internalErr))
+// 	assert.Equal(t, testE, internalErr)
+// }
+
+/*
+benchmark run for 1 second:
+Benchmark_ErrorsIs_OneLayerError-4    	148281332	         8.68 ns/op	       0 B/op	       0 allocs/op
+Benchmark_ErrorsIs_TwoLayerError-4    	35048202	        32.4 ns/op	       0 B/op	       0 allocs/op
+Benchmark_ErrorsIs_FourLayerError-4   	15309349	        81.7 ns/op	       0 B/op	       0 allocs/op
+
+Benchmark_ErrorsAs_OneLayerError-4    	16893205	        70.4 ns/op	       0 B/op	       0 allocs/op
+Benchmark_ErrorsAs_TwoLayerError-4    	10568083	       112 ns/op	       0 B/op	       0 allocs/op
+Benchmark_ErrorsAs_FourLayerError-4   	 6307729	       188 ns/op	       0 B/op	       0 allocs/op
+*/
+func Benchmark_ErrorsIs_OneLayerError(b *testing.B) {
+	layer1Err := &testErr{code: 123}
+	var err error = layer1Err
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		errors.Is(err, layer1Err)
+	}
+}
+
+func Benchmark_ErrorsIs_TwoLayerError(b *testing.B) {
+	layer1Err := &testErr{code: 123}
+
+	// act with error chain: InvalidFormat(layer 2) -> testErr(layer 1)
+	layer2Err := InvalidFormat("field A", "Error description")
+	err := layer2Err.Wrap(layer1Err)
+	if err != nil {
+		b.Fatalf("Failed to wrap error: %v", err)
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		errors.Is(layer2Err, layer1Err)
+	}
+}
+
+func Benchmark_ErrorsIs_FourLayerError(b *testing.B) {
+	layer1Err := &testErr{code: 123}
+	layer2Err := fmt.Errorf("layer 2: %w", layer1Err)
+	layer3Err := fmt.Errorf("layer 3: %w", layer2Err)
+	// act with error chain: InvalidFormat(layer 4) -> Error(layer 3) -> Error(layer 2) -> testErr(layer 1)
+	layer4Err := InvalidFormat("field A", "Error description")
+	err := layer4Err.Wrap(layer3Err)
+	if err != nil {
+		b.Fatalf("Failed to wrap error: %v", err)
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		errors.Is(layer4Err, layer1Err)
+	}
+}
+
+func Benchmark_ErrorsAs_OneLayerError(b *testing.B) {
+	layer1Err := &testErr{code: 123}
+	var err error = layer1Err
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	var internalErr *testErr
+	for i := 0; i < b.N; i++ {
+		errors.As(err, &internalErr)
+	}
+}
+
+func Benchmark_ErrorsAs_TwoLayerError(b *testing.B) {
+	layer1Err := &testErr{code: 123}
+
+	// act with error chain: InvalidFormat(layer 2) -> testErr(layer 1)
+	layer2Err := InvalidFormat("field A", "Error description")
+	err := layer2Err.Wrap(layer1Err)
+	if err != nil {
+		b.Fatalf("Failed to wrap error: %v", err)
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	var internalErr *testErr
+	for i := 0; i < b.N; i++ {
+		errors.As(layer2Err, &internalErr)
+	}
+}
+
+func Benchmark_ErrorsAs_FourLayerError(b *testing.B) {
+	layer1Err := &testErr{code: 123}
+	layer2Err := fmt.Errorf("layer 2: %w", layer1Err)
+	layer3Err := fmt.Errorf("layer 3: %w", layer2Err)
+	// act with error chain: InvalidFormat(layer 4) -> Error(layer 3) -> Error(layer 2) -> testErr(layer 1)
+	layer4Err := InvalidFormat("field A", "Error description")
+	err := layer4Err.Wrap(layer3Err)
+	if err != nil {
+		b.Fatalf("Failed to wrap error: %v", err)
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	var internalErr *testErr
+	for i := 0; i < b.N; i++ {
+		errors.As(layer4Err, &internalErr)
+	}
+}
+
+func TestFromError(t *testing.T) {
+	tests := []struct {
+		name       string
+		givenError error
+		want       *Err
+	}{
+		{
+			"given nil error should return nil",
+			nil,
+			nil,
+		},
+		{
+			"given normal error should return nil",
+			errors.New("normal error"),
+			nil,
+		},
+		{
+			"given Err should return Err",
+			ResourceNotFound("fake error"),
+			ResourceNotFound("fake error"),
+		},
+		{
+			"given error wraps Err should return Err",
+			fmt.Errorf("outter error wraps %w", ResourceNotFound("fake error")),
+			ResourceNotFound("fake error"),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := FromError(tt.givenError); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("FromError() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/errors/errors_test.go b/errors/errors_test.go
new file mode 100644
index 0000000..dc31791
--- /dev/null
+++ b/errors/errors_test.go
@@ -0,0 +1,297 @@
+package error
+
+import (
+	code2 "code.30cm.net/digimon/library-go/errors/code"
+	"errors"
+	"fmt"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func TestCode_GivenNilReceiver_CodeReturnOK_CodeStrReturns00000(t *testing.T) {
+	// setup
+	var e *Err = nil
+
+	// act & assert
+	assert.Equal(t, code2.OK, e.Code())
+	assert.Equal(t, "00000", e.CodeStr())
+	assert.Equal(t, "", e.Error())
+}
+
+func TestCode_GivenScope99DetailCode6687_ShouldReturn996687(t *testing.T) {
+	// setup
+	e := Err{scope: 99, code: 6687}
+
+	// act & assert
+	assert.Equal(t, uint32(6687), e.Code())
+	assert.Equal(t, "996687", e.CodeStr())
+}
+
+func TestCode_GivenScope0DetailCode87_ShouldReturn87(t *testing.T) {
+	// setup
+	e := Err{scope: 0, code: 87}
+
+	// act & assert
+	assert.Equal(t, uint32(87), e.Code())
+	assert.Equal(t, "00087", e.CodeStr())
+}
+
+func TestFromCode_Given870005_ShouldHasScope87_Cat0_Detail5(t *testing.T) {
+	// setup
+	e := FromCode(870005)
+
+	// assert
+	assert.Equal(t, uint32(87), e.Scope())
+	assert.Equal(t, uint32(0), e.Category())
+	assert.Equal(t, uint32(5), e.Code())
+	assert.Equal(t, "", e.Error())
+}
+
+func TestFromCode_Given0_ShouldHasScope0_Cat0_Detail0(t *testing.T) {
+	// setup
+	e := FromCode(0)
+
+	// assert
+	assert.Equal(t, uint32(0), e.Scope())
+	assert.Equal(t, uint32(0), e.Category())
+	assert.Equal(t, uint32(0), e.Code())
+	assert.Equal(t, "", e.Error())
+}
+
+func TestFromCode_Given9105_ShouldHasScope0_Cat9100_Detail9105(t *testing.T) {
+	// setup
+	e := FromCode(9105)
+
+	// assert
+	assert.Equal(t, uint32(0), e.Scope())
+	assert.Equal(t, uint32(9100), e.Category())
+	assert.Equal(t, uint32(9105), e.Code())
+	assert.Equal(t, "", e.Error())
+}
+
+func TestErr_ShouldImplementErrorFunction(t *testing.T) {
+	// setup a func return error
+	f := func() error { return InvalidFormat("fake field") }
+
+	// act
+	err := f()
+
+	// assert
+	assert.NotNil(t, err)
+	assert.Contains(t, fmt.Sprint(err), "fake field") // can be printed
+}
+
+func TestGeneralError_GivenNilErr_ShouldReturnEmptyString(t *testing.T) {
+	// setup
+	var e *Err = nil
+
+	// act & assert
+	assert.Equal(t, "", e.GeneralError())
+}
+
+func TestGeneralError_GivenNotExistCat_ShouldReturnEmptyString(t *testing.T) {
+	// setup
+	e := Err{category: 123456}
+
+	// act & assert
+	assert.Equal(t, "", e.GeneralError())
+}
+
+func TestGeneralError_GivenCatDB_ShouldReturnDBError(t *testing.T) {
+	// setup
+	e := Err{category: code2.CatDB}
+	catErrStr := code2.CatToStr[code2.CatDB]
+
+	// act & assert
+	assert.Equal(t, catErrStr, e.GeneralError())
+}
+
+func TestError_GivenEmptyMsg_ShouldReturnCatGeneralErrorMessage(t *testing.T) {
+	// setup
+	e := Err{category: code2.CatDB, msg: ""}
+
+	// act
+	errMsg := e.Error()
+
+	// assert
+	assert.Equal(t, code2.CatToStr[code2.CatDB], errMsg)
+}
+
+func TestError_GivenMsg_ShouldReturnGiveMsg(t *testing.T) {
+	// setup
+	e := Err{msg: "FAKE"}
+
+	// act
+	errMsg := e.Error()
+
+	// assert
+	assert.Equal(t, "FAKE", errMsg)
+}
+
+func TestIs_GivenNilErr_ShouldReturnFalse(t *testing.T) {
+	var nilErrs *Err
+	// act
+	result := errors.Is(nilErrs, DBError())
+	result2 := errors.Is(DBError(), nilErrs)
+
+	// assert
+	assert.False(t, result)
+	assert.False(t, result2)
+}
+
+func TestIs_GivenNil_ShouldReturnFalse(t *testing.T) {
+	// act
+	result := errors.Is(nil, DBError())
+	result2 := errors.Is(DBError(), nil)
+
+	// assert
+	assert.False(t, result)
+	assert.False(t, result2)
+}
+
+func TestIs_GivenNilReceiver_ShouldReturnCorrectResult(t *testing.T) {
+	var nilErr *Err = nil
+
+	// test 1: nilErr != DBError
+	var dbErr error = DBError("fake db error")
+	assert.False(t, nilErr.Is(dbErr))
+
+	// test 2: nilErr != nil error
+	var nilError error
+	assert.False(t, nilErr.Is(nilError))
+
+	// test 3: nilErr == another nilErr
+	var nilErr2 *Err = nil
+	assert.True(t, nilErr.Is(nilErr2))
+}
+
+func TestIs_GivenDBError_ShouldReturnTrue(t *testing.T) {
+	// setup
+	dbErr := DBError("fake db error")
+
+	// act
+	result := errors.Is(dbErr, DBError("not care"))
+	result2 := errors.Is(DBError(), dbErr)
+
+	// assert
+	assert.True(t, result)
+	assert.True(t, result2)
+}
+
+func TestIs_GivenDBErrorAssignToErrorType_ShouldReturnTrue(t *testing.T) {
+	// setup
+	var dbErr error = DBError("fake db error")
+
+	// act
+	result := errors.Is(dbErr, DBError("not care"))
+	result2 := errors.Is(DBError(), dbErr)
+
+	// assert
+	assert.True(t, result)
+	assert.True(t, result2)
+}
+
+func TestWrap_GivenNilErr_ShouldNoPanic(t *testing.T) {
+	// act & assert
+	assert.NotPanics(t, func() {
+		var e *Err = nil
+		_ = e.Wrap(fmt.Errorf("test"))
+	})
+}
+
+func TestWrap_GivenErrorToWrap_ShouldReturnErrorWithWrappedError(t *testing.T) {
+	// act & assert
+	wrappedErr := fmt.Errorf("test")
+	wrappingErr := SystemInternalError("WrappingError").Wrap(wrappedErr)
+	unWrappedErr := wrappingErr.Unwrap()
+
+	assert.Equal(t, wrappedErr, unWrappedErr)
+}
+
+func TestUnwrap_GivenNilErr_ShouldReturnNil(t *testing.T) {
+	var e *Err = nil
+	internalErr := e.Unwrap()
+	assert.Nil(t, internalErr)
+}
+
+func TestErrorsIs_GivenNilErr_ShouldReturnFalse(t *testing.T) {
+	var e *Err = nil
+	assert.False(t, errors.Is(e, fmt.Errorf("test")))
+}
+
+func TestErrorsAs_GivenNilErr_ShouldReturnFalse(t *testing.T) {
+	var internalErr *testErr
+	var e *Err = nil
+	assert.False(t, errors.As(e, &internalErr))
+}
+
+func TestGRPCStatus(t *testing.T) {
+	// setup table driven tests
+	tests := []struct {
+		name          string
+		given         *Err
+		expect        *status.Status
+		expectConvert error
+	}{
+		{
+			"nil errs.Err",
+			nil,
+			status.New(codes.OK, ""),
+			nil,
+		},
+		{
+			"InvalidFormat Err",
+			InvalidFormat("fake"),
+			status.New(codes.Code(101), "invalid format: fake"),
+			status.New(codes.Code(101), "invalid format: fake").Err(),
+		},
+	}
+
+	// act & assert
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			s := test.given.GRPCStatus()
+			assert.Equal(t, test.expect.Code(), s.Code())
+			assert.Equal(t, test.expect.Message(), s.Message())
+			assert.Equal(t, test.expectConvert, status.Convert(test.given).Err())
+		})
+	}
+}
+
+func TestErr_HTTPStatus(t *testing.T) {
+	tests := []struct {
+		name string
+		err  *Err
+		want int
+	}{
+		{name: "nil error", err: nil, want: http.StatusOK},
+		{name: "invalid measurement id", err: &Err{category: code2.CatResource, code: code2.InvalidMeasurementID}, want: http.StatusInternalServerError},
+		{name: "resource already exists", err: &Err{category: code2.CatResource, code: code2.ResourceAlreadyExist}, want: http.StatusConflict},
+		{name: "invalid resource state", err: &Err{category: code2.CatResource, code: code2.InvalidResourceState}, want: http.StatusConflict},
+		{name: "invalid posix time", err: &Err{category: code2.CatAuth, code: code2.InvalidPosixTime}, want: http.StatusForbidden},
+		{name: "unauthorized", err: &Err{category: code2.CatAuth, code: code2.Unauthorized}, want: http.StatusUnauthorized},
+		{name: "db error", err: &Err{category: code2.CatDB, code: code2.DBError}, want: http.StatusInternalServerError},
+		{name: "insufficient permission", err: &Err{category: code2.CatResource, code: code2.InsufficientPermission}, want: http.StatusUnauthorized},
+		{name: "resource insufficient", err: &Err{category: code2.CatResource, code: code2.ResourceInsufficient}, want: http.StatusBadRequest},
+		{name: "invalid format", err: &Err{category: code2.CatInput, code: code2.InvalidFormat}, want: http.StatusBadRequest},
+		{name: "resource not found", err: &Err{code: code2.ResourceNotFound}, want: http.StatusNotFound},
+		{name: "ok", err: &Err{code: code2.OK}, want: http.StatusOK},
+		{name: "not valid implementation", err: &Err{category: code2.CatInput, code: code2.NotValidImplementation}, want: http.StatusNotImplemented},
+		{name: "forbidden", err: &Err{category: code2.CatAuth, code: code2.Forbidden}, want: http.StatusForbidden},
+		{name: "insufficient quota", err: &Err{category: code2.CatResource, code: code2.InsufficientQuota}, want: http.StatusPaymentRequired},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			// act
+			got := tt.err.HTTPStatus()
+
+			// assert
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}