How to use isZero method of internal Package

1package keeper2import (3	"bytes"4	"fmt"5	"sort"6	sdk "github.com/cosmos/cosmos-sdk/types"7	sdkErrors "github.com/cosmos/cosmos-sdk/types/errors"8	"github.com/olekukonko/tablewriter"9	"github.com/dfinance/dnode/x/orderbook/internal/types"10)11// Supply-demand curves point holding aggregated supply and demand quantities for price.12type SDItem struct {13	Price  sdk.Uint14	Supply sdk.Uint15	Demand sdk.Uint16}17// SupplyDemandBalance compares point supply and demand.18func (i SDItem) SupplyDemandBalance() int {19	if i.Supply.GT(i.Demand) {20		return 121	}22	if i.Supply.Equal(i.Demand) {23		return 024	}25	return -126}27// SDCurves object stores all Supply-demand curves points.28type SDCurves []SDItem29// Strings returns multi-line text object representation.30func (c *SDCurves) String() string {31	var buf bytes.Buffer32	t := tablewriter.NewWriter(&buf)33	t.SetHeader([]string{34		"PQ.Price",35		"PQ.Supply",36		"PQ.Demand",37	})38	for _, i := range *c {39		t.Append([]string{40			i.Price.String(),41			i.Supply.String(),42			i.Demand.String(),43		})44	}45	t.Render()46	return buf.String()47}48// NewSDCurves creates a new SDCurves object mergind ask/bid aggregates.49func NewSDCurves(askAggs, bidAggs OrderAggregates) (SDCurves, error) {50	// check if curves can be obtained51	if len(askAggs) == 0 || len(bidAggs) == 0 {52		return SDCurves{}, fmt.Errorf("ask / bid orders are empty: %d / %d", len(askAggs), len(bidAggs))53	}54	// check inputs (aggregates must be properly sorted)55	// TODO: remove that time wasting checks once we are sure aggregates build is correct56	askAggsSorted := sort.SliceIsSorted(askAggs, func(i, j int) bool {57		return askAggs[i].Price.LT(askAggs[j].Price) && askAggs[i].Quantity.LTE(askAggs[j].Quantity)58	})59	if !askAggsSorted {60		return SDCurves{}, sdkErrors.Wrap(types.ErrInternal, "askAggs not sorted")61	}62	bidAggsSorted := sort.SliceIsSorted(bidAggs, func(i, j int) bool {63		return bidAggs[i].Price.LT(bidAggs[j].Price) && bidAggs[i].Quantity.GTE(bidAggs[j].Quantity)64	})65	if !bidAggsSorted {66		return SDCurves{}, sdkErrors.Wrap(types.ErrInternal, "bidAggs not sorted")67	}68	// check if clearance price can be found69	if bidAggs[len(bidAggs)-1].Price.LT(askAggs[0].Price) {70		return SDCurves{}, fmt.Errorf("highest bid price is lower than lowest ask price")71	}72	// merge bid/ask aggregates inputs73	c := SDCurves{}74	c.addAskOrders(askAggs)75	c.addBidOrders(bidAggs)76	c.fixZeroSupplyDemand()77	return c, nil78}79// GetClearanceState processes the SDCurves searching for the best crossing point.80// Result is the clearance price and adjusted (by ProRate coefficient) max supply/demand amounts that are81// used to fill orders.82func (c *SDCurves) GetClearanceState() (retState types.ClearanceState, retErr error) {83	// check input84	if len(*c) == 0 {85		retErr = fmt.Errorf("SDCurves is empty")86		return87	}88	crossPoint := c.getCrossPoint()89	// check is the crossing point is valid90	if crossPoint.Price.IsZero() {91		retErr = sdkErrors.Wrap(types.ErrInternal, "crossPoint.Price: empty")92		return93	}94	if crossPoint.Supply.IsZero() {95		retErr = sdkErrors.Wrap(types.ErrInternal, "crossPoint.Supply: empty")96		return97	}98	if crossPoint.Demand.IsZero() {99		retErr = sdkErrors.Wrap(types.ErrInternal, "crossPoint.Demand: empty")100		return101	}102	// convert demand/supply to sdk.Dec for better accuracy103	demandDec, supplyDec := sdk.NewDecFromBigInt(crossPoint.Demand.BigInt()), sdk.NewDecFromBigInt(crossPoint.Supply.BigInt())104	// build the result105	retState.Price = crossPoint.Price106	retState.ProRata = supplyDec.Quo(demandDec)107	retState.ProRataInvert = sdk.OneDec().Quo(retState.ProRata)108	retState.MaxBidVolume = sdk.NewDecFromInt(demandDec.Mul(retState.ProRata).RoundInt())109	retState.MaxAskVolume = sdk.NewDecFromInt(supplyDec.Mul(retState.ProRataInvert).RoundInt())110	return111}112// getCrossPoint searches for the crossing point.113// Crossing point might not be found: other point is picked in that case (edge cases).114func (c *SDCurves) getCrossPoint() SDItem {115	// crossPointIdx is an index of the last found crossing point116	// clearancePrice is the last calculated clearance price117	crossPointIdx, clearancePrice := -1, sdk.ZeroUint()118	cLen := len(*c)119	// edge-case 0: first point has non-zero equal Supply and Demand120	// it's a crossing point, but left SupplyDemandBalance can't be calculated (idx == -1)121	if firstItem := &(*c)[0]; firstItem.Supply.Equal(firstItem.Demand) {122		if !firstItem.Supply.IsZero() && !firstItem.Demand.IsZero() {123			return SDItem{124				Price:  firstItem.Price,125				Supply: firstItem.Supply,126				Demand: firstItem.Demand,127			}128		}129	}130	for i := 1; i < cLen; i++ {131		curItem, prevItem := &(*c)[i], &(*c)[i-1]132		// cross point is defined by previous and current point having different supply/demand relations133		if prevItem.SupplyDemandBalance() != curItem.SupplyDemandBalance() {134			crossPointIdx, clearancePrice = i, curItem.Price135			// check if next points are equal to the found one ("corridor")136			leftCrossPoint, rightCrossPoint := curItem, (*SDItem)(nil)137			for j := i + 1; j < cLen; j++ {138				rightItem := &(*c)[j]139				if !leftCrossPoint.Supply.Equal(rightItem.Supply) || !leftCrossPoint.Demand.Equal(rightItem.Demand) {140					break141				}142				rightCrossPoint = rightItem143			}144			// if the "corridor" was found average the clearance price145			if rightCrossPoint != nil {146				clearancePrice = leftCrossPoint.Price.Add(rightCrossPoint.Price).QuoUint64(2)147			}148			break149		}150	}151	if crossPointIdx != -1 {152		// the crossing point was found153		curItem, prevItem := &(*c)[crossPointIdx], &(*c)[crossPointIdx-1]154		if !curItem.Supply.IsZero() && !curItem.Demand.IsZero() {155			// edge-case 1a: crossing point has volumes156			return SDItem{157				Price:  clearancePrice,158				Supply: curItem.Supply,159				Demand: curItem.Demand,160			}161		}162		if !prevItem.Supply.IsZero() && !prevItem.Demand.IsZero() {163			// edge-case 1b: prev to the crossing point has volumes164			return SDItem{165				Price:  prevItem.Price,166				Supply: prevItem.Supply,167				Demand: prevItem.Demand,168			}169		}170	}171	// the crossing point wasn't found172	// edge-case 2 (option a): find point with the minimal |Supply - Demand| diff and non-zero Supply and Demand173	// Supply / Demand can't be zero as it would cause "div 0" error174	cSorted := make(SDCurves, cLen)175	copy(cSorted, *c)176	sort.Slice(cSorted, func(i, j int) bool {177		leftItem, rightItem := &cSorted[i], &cSorted[j]178		var leftDiff, rightDiff sdk.Uint179		if leftItem.Supply.GT(leftItem.Demand) {180			leftDiff = leftItem.Supply.Sub(leftItem.Demand)181		} else {182			leftDiff = leftItem.Demand.Sub(leftItem.Supply)183		}184		if rightItem.Supply.GT(rightItem.Demand) {185			rightDiff = rightItem.Supply.Sub(rightItem.Demand)186		} else {187			rightDiff = rightItem.Demand.Sub(rightItem.Supply)188		}189		return leftDiff.LT(rightDiff)190	})191	for i := 0; i < len(cSorted); i++ {192		item := &cSorted[i]193		if !item.Supply.IsZero() && !item.Demand.IsZero() {194			return SDItem{195				Price:  item.Price,196				Supply: item.Supply,197				Demand: item.Demand,198			}199		}200	}201	// edge-case 2 (option b): find first point with non-zero Supply and Demand (search from the middle)202	// Supply / Demand can't be zero as it would cause "div 0" error203	//middleIdx := cLen / 2204	//for rightIdx := middleIdx; rightIdx < cLen; rightIdx++ {205	//	rightItem := &(*c)[rightIdx]206	//207	//	var leftItem *SDItem208	//	leftIdx := middleIdx - (rightIdx - middleIdx)209	//	if leftIdx >= 0 {210	//		leftItem = &(*c)[leftIdx]211	//	}212	//213	//	if !rightItem.Supply.IsZero() && !rightItem.Demand.IsZero() {214	//		return SDItem{215	//			Price:  rightItem.Price,216	//			Supply: rightItem.Supply,217	//			Demand: rightItem.Demand,218	//		}219	//	}220	//221	//	if leftItem != nil && !leftItem.Supply.IsZero() && !leftItem.Demand.IsZero() {222	//		return SDItem{223	//			Price:  leftItem.Price,224	//			Supply: leftItem.Supply,225	//			Demand: leftItem.Demand,226	//		}227	//	}228	//}229	// edge-case 3: can't happen if the lowest ask price is higher then the highest bid price230	return SDItem{231		Price:  sdk.ZeroUint(),232		Supply: sdk.ZeroUint(),233		Demand: sdk.ZeroUint(),234	}235}236// addAskOrders merges ask aggregates into SDCurve.237func (c *SDCurves) addAskOrders(aggs OrderAggregates) {238	for i := 0; i < len(aggs); i++ {239		agg := &aggs[i]240		*c = append(*c, SDItem{241			Price:  agg.Price,242			Supply: agg.Quantity,243			Demand: sdk.ZeroUint(),244		})245	}246}247// addAskOrders merges bid aggregates into SDCurve.248// Contract: ask aggregates must be merged first.249func (c *SDCurves) addBidOrders(aggs OrderAggregates) {250	for i := 0; i < len(aggs); i++ {251		agg := &aggs[i]252		gtePriceIdx := sort.Search(len(*c), func(i int) bool {253			return (*c)[i].Price.GTE(agg.Price)254		})255		if gtePriceIdx != len(*c) && (*c)[gtePriceIdx].Price.Equal(agg.Price) {256			(*c)[gtePriceIdx].Demand = agg.Quantity257			continue258		}259		*c = append(*c, SDItem{})260		copy((*c)[gtePriceIdx+1:], (*c)[gtePriceIdx:])261		(*c)[gtePriceIdx] = SDItem{262			Price:  agg.Price,263			Supply: sdk.ZeroUint(),264			Demand: agg.Quantity,265		}266	}267}268// fixZeroSupplyDemand sets empty supply/demand for inserted rows.269// Iterates over SDCurves in both directions copying quantity from the previous point.270func (c *SDCurves) fixZeroSupplyDemand() {271	askIdx, askFillItem := 1, &(*c)[0]272	bidIdx, bidFillItem := len(*c)-2, &(*c)[len(*c)-1]273	for i := 1; i < len(*c); i++ {274		if (*c)[askIdx].Supply.IsZero() {275			(*c)[askIdx].Supply = (*askFillItem).Supply276		} else {277			askFillItem = &(*c)[askIdx]278		}279		askIdx++280		if (*c)[bidIdx].Demand.IsZero() {281			(*c)[bidIdx].Demand = (*bidFillItem).Demand282		} else {283			bidFillItem = &(*c)[bidIdx]284		}285		bidIdx--286	}287}...

1package server2import (3	"errors"4	"net/http"5	"reflect"6	"strings"7	"time"8	"github.com/gin-gonic/gin"9	"github.com/izzudinhafiz/go-mycovidapi/models"10	log "github.com/sirupsen/logrus"11)12var statesAbrvMap = map[string]string {13	"JHR": "Johor",14	"KDH": "Kedah",15	"KTN": "Kelantan",16	"MLK": "Melaka",17	"NSN": "Negeri Sembilan",18	"PLS": "Perlis",19	"SBH": "Sabah",20	"SWK": "Sarawak",21	"TRG": "Terengganu",22	"SGR": "Selangor",23	"PRK": "Perak",24	"PHG": "Pahang",25	"KUL": "W.P. Kuala Lumpur",26	"LBN": "W.P. Labuan",27	"PJY": "W.P. Putrajaya",28	"PNG": "Pulau Pinang",29}30var (31	ErrorNoState = errors.New("requires at least one state")32	ErrorUnknownState = errors.New("unknown state(s) passed as param")33)34func parseStates(states_str string) ([]string, error) {35	if states_str == "" {36		return []string{}, ErrorNoState37	}38	states_raw := strings.Split(states_str, ",")39	for i, state_raw := range states_raw {40		_, key_exists := statesAbrvMap[strings.ToUpper(state_raw)]41		if !key_exists {42			return []string{}, ErrorUnknownState43		}44		states_raw[i] = strings.ToUpper(state_raw)45	}46	return states_raw, nil47}48type CountryRequests struct {49	StartDate time.Time `form:"start_date" time_format:"2006-01-02"`50	EndDate time.Time `form:"end_date" time_format:"2006-01-02"`51}52type StateRequests struct {53	StartDate time.Time `form:"start_date" time_format:"2006-01-02"`54	EndDate time.Time `form:"end_date" time_format:"2006-01-02"`55	State string `form:"state_id"`56}57type ValidationError struct {58	ErrorMessage string `json:"msg"`59	Location string `json:"loc"`60	Type string `json:"type"`61}62func (s *Server) getCountry(c *gin.Context, out interface{}) error {63	var query CountryRequests64	err := c.ShouldBindQuery(&query)65	if err != nil {66		c.AbortWithStatusJSON(422, ValidationError{67			err.Error(),68			"start_date | end_date",69			"string",70		})71		log.Errorf("%v?%v: %v",c.Request.URL.Path, c.Request.URL.Query(), err)72		return err73	}74	val := reflect.ValueOf(out).Interface()75	tx := s.DB76	if query.StartDate.IsZero() && query.EndDate.IsZero() {77	} else if !query.StartDate.IsZero() && query.EndDate.IsZero() {78		tx = s.DB.Where("date >= ?", query.StartDate)79	} else if query.StartDate.IsZero() && !query.EndDate.IsZero() {80		tx = s.DB.Where("date <= ?", query.EndDate)81	} else {82		tx = s.DB.Where("date BETWEEN ? AND ?", query.StartDate, query.EndDate)83	}84	tx = tx.Order("date").Find(&val, "state ='MY'")85	if tx.Error != nil {86		log.Errorf("%v?%v: %v",c.Request.URL.Path, c.Request.URL.Query(), tx.Error)87		c.AbortWithStatus(http.StatusInternalServerError)88		return tx.Error89	}90	c.JSON(http.StatusOK, val)91	return nil92}93func (s *Server) getState(c *gin.Context, out interface{}) error {94	var query StateRequests95	c.BindQuery(&query)96	states, err := parseStates(query.State)97	if err != nil {98		log.Errorf("%v?%v: %v", c.Request.URL.Path, c.Request.URL.Query(), err)99		errorMsg := ValidationError{ErrorMessage: "Validation Error",}100		if err == ErrorNoState {101			errorMsg = ValidationError{102				ErrorMessage: "requires at least one state",103				Location: "state_id",104				Type: "string (comma separated)",105			}106		} else if err == ErrorUnknownState{107			errorMsg = ValidationError{108				ErrorMessage: "invalid states in query parameter",109				Location: "state_id",110				Type: "string (comma separated)",111			}112		}113		c.AbortWithStatusJSON(422, errorMsg)114		return err115	}116	val := reflect.ValueOf(out).Interface()117	tx := s.DB118	if query.StartDate.IsZero() && query.EndDate.IsZero() {119	} else if !query.StartDate.IsZero() && query.EndDate.IsZero() {120		tx = s.DB.Where("date >= ?", query.StartDate)121	} else if query.StartDate.IsZero() && !query.EndDate.IsZero() {122		tx = s.DB.Where("date <= ?", query.EndDate)123	} else {124		tx = s.DB.Where("date BETWEEN ? AND ?", query.StartDate, query.EndDate)125	}126	tx = tx.Where("state IN ?", states).Order("date, state").Find(&val)127	if tx.Error != nil {128		log.Errorf("%v?%v: %v",c.Request.URL.Path, c.Request.URL.Query(), tx.Error)129		c.AbortWithStatus(http.StatusInternalServerError)130		return tx.Error131	}132	c.JSON(http.StatusOK, val)133	return nil134}135func (s *Server) getClusterList(c *gin.Context, out interface{}) error {136	val := reflect.ValueOf(out).Interface()137	tx := s.DB.Model(models.Clusters{}).Find(&val)138	if tx.Error != nil {139		log.Errorf("%v?%v: %v",c.Request.URL.Path, c.Request.URL.Query(), tx.Error)140		c.AbortWithStatus(http.StatusInternalServerError)141		return tx.Error142	}143	c.JSON(http.StatusOK, val)144	return nil145}146func (s *Server) getActiveClusters(c *gin.Context, out interface{}) error {147	val := reflect.ValueOf(out).Interface()148	tx := s.DB.Model(models.Clusters{}).Where("status = ?", "active").Find(&val)149	if tx.Error != nil {150		log.Errorf("%v?%v: %v",c.Request.URL.Path, c.Request.URL.Query(), tx.Error)151		c.AbortWithStatus(http.StatusInternalServerError)152		return tx.Error153	}154	c.JSON(http.StatusOK, val)155	return nil156}...

1package api_test2import (3	"errors"4	"testing"5	"github.com/stretchr/testify/require"6	api "github.com/trisacrypto/trisa/pkg/trisa/api/v1beta1"7	codes "google.golang.org/grpc/codes"8	status "google.golang.org/grpc/status"9	"google.golang.org/protobuf/proto"10	"google.golang.org/protobuf/types/known/anypb"11)12func TestErrors(t *testing.T) {13	err := api.Errorf(api.UnknownIdentity, "could not parse %q", "foo")14	require.Error(t, err)15	require.Equal(t, err.Error(), `trisa rejection [UNKNOWN_IDENTITY]: could not parse "foo"`)16	require.False(t, err.IsZero())17	oerr, ok := api.Errorp(err)18	require.True(t, ok)19	require.Equal(t, err, oerr)20	require.False(t, oerr.IsZero())21	oerr, ok = api.Errorp(errors.New("unhandled error"))22	require.False(t, ok)23	require.Equal(t, oerr.Error(), "trisa rejection [UNHANDLED]: unhandled error")24	require.False(t, oerr.IsZero())25	sterr := err.Err()26	require.Equal(t, sterr.Error(), `rpc error: code = Aborted desc = [UNKNOWN_IDENTITY] could not parse "foo"`)27	oerr, ok = api.Errorp(sterr)28	require.True(t, ok)29	require.True(t, proto.Equal(err, oerr), "unexpected return value from Errorp")30	require.False(t, oerr.IsZero())31	// WithRetry should return a new error with retry set to true32	errWithRetry := err.WithRetry()33	require.Equal(t, err.Code, errWithRetry.Code)34	require.Equal(t, err.Message, errWithRetry.Message)35	require.True(t, errWithRetry.Retry)36	require.Nil(t, errWithRetry.Details)37	require.False(t, errWithRetry.IsZero())38	_, parseErr := err.WithDetails(nil)39	require.Error(t, parseErr)40	// WithDetails should add an arbitrary proto.Message to the error details41	details := &api.Error{42		Code: api.UnknownIdentity,43	}44	errWithDetails, parseErr := err.WithDetails(details)45	require.NoError(t, parseErr)46	require.Equal(t, err.Code, errWithDetails.Code)47	require.Equal(t, err.Message, errWithDetails.Message)48	require.Equal(t, err.Retry, errWithDetails.Retry)49	actualDetails := &api.Error{}50	require.NoError(t, anypb.UnmarshalTo(errWithDetails.Details, actualDetails, proto.UnmarshalOptions{}))51	require.True(t, proto.Equal(details, actualDetails), "unexpected details created by WithDetails")52	require.False(t, errWithDetails.IsZero())53}54func TestIsZero(t *testing.T) {55	err := &api.Error{}56	require.True(t, err.IsZero(), "no code and no message should be zero valued")57	err = &api.Error{Retry: true}58	require.True(t, err.IsZero(), "non-zero retry is not sufficient")59	details, _ := anypb.New(&api.Error{Code: api.ExceededTradingVolume, Message: "too fast"})60	err = &api.Error{Details: details}61	require.True(t, err.IsZero(), "non-zero details is not sufficient")62	err = &api.Error{Code: api.OutOfNetwork}63	require.False(t, err.IsZero(), "a code greater than zero should be sufficient")64	err = &api.Error{Message: "unexpected content"}65	require.False(t, err.IsZero(), "a message without a code should be sufficient")66	err = &api.Error{Code: api.OutOfNetwork, Message: "unexpected content"}67	require.False(t, err.IsZero(), "both a message and a code should be non-zero")68	// After marshaling an empty protocol buffer message, it should still be zero69	data, merr := proto.Marshal(&api.Error{})70	require.NoError(t, merr, "could not marshal protocol buffer")71	umerr := &api.Error{}72	require.NoError(t, proto.Unmarshal(data, umerr), "could not unmarshal error pb")73	require.True(t, umerr.IsZero(), "should be zero after marshal and unmarshal")74}75// Test that the Err function returns an error that includes the corresponding gRPC76// error code and message from the original error.77func TestErr(t *testing.T) {78	tests := []struct {79		name         string80		code         api.Error_Code81		message      string82		expectedCode codes.Code83	}{84		{"unavailable", api.Unavailable, "endpoint is unavailable", codes.Unavailable},85		{"internal", api.InternalError, "internal error", codes.Internal},86		{"aborted", api.Rejected, "aborted", codes.Aborted},87		{"failedPrecondition", api.Unverified, "failed precondition", codes.FailedPrecondition},88		{"invalidArgument", api.InvalidKey, "invalid argument", codes.InvalidArgument},89	}90	for _, tt := range tests {91		t.Run(tt.name, func(t *testing.T) {92			err := &api.Error{93				Code:    tt.code,94				Message: tt.message,95			}96			stErr := err.Err()97			require.NotNil(t, stErr)98			require.Equal(t, tt.expectedCode, status.Code(stErr))99			require.Contains(t, stErr.Error(), tt.message)100		})101	}102}...

1func main() {2    fmt.Println(isZero(i), isZero(f), isZero(b), isZero(s))3}4func main() {5    fmt.Println(isZero(i), isZero(f), isZero(b), isZero(s))6}7func main() {8    fmt.Println(isZero(i), isZero(f), isZero(b), isZero(s))9}10func main() {11    fmt.Println(isZero(i), isZero(f), isZero(b), isZero(s))12}13func main() {14    fmt.Println(isZero(i), isZero(f), isZero(b), isZero(s))15}16func main() {17    fmt.Println(isZero(i), isZero(f), isZero(b), isZero(s))18}19func main() {20    fmt.Println(isZero(i), isZero(f), isZero(b), isZero(s))21}22func main() {23    fmt.Println(isZero(i), isZero(f), isZero(b), isZero(s))24}

1import "fmt"2type Person struct {3}4}5func main() {6}7import "fmt"8type Person struct {9}10}11func main() {12}13import "fmt"14type Person struct {15}16}17func main() {18}19import "fmt"20type Person struct {21}22}23func main() {24}25import "fmt"26type Person struct {27}28}29func main() {

1import (2func main() {3	fmt.Println(reflect.ValueOf(num).IsZero())4}5import (6func main() {7	fmt.Println(reflect.ValueOf(&num).Elem().IsZero())8}9import (10func main() {11	fmt.Println(reflect.ValueOf(&num).IsZero())12}13reflect.flag.mustBe(0x8, 0x1)14reflect.Value.IsZero(0x4c1a00, 0xc00000e0b8, 0x98, 0x4c1a00)15main.main()16import (17func main() {18	fmt.Println(reflect.ValueOf(&num).Elem().IsZero())19}20import (21func main() {22	fmt.Println(reflect.DeepEqual(num, 0))23}24import (25func main() {26	fmt.Println(reflect.DeepEqual(&num, 0))27}28import (29func main() {30	fmt.Println(reflect.DeepEqual(&num, &num))31}32import (33func main() {34	fmt.Println(reflect.DeepEqual(num, &num))35}

1import (2func main() {3	var f3 func()4	var i3 interface{}5	fmt.Println("isZero(i1):", isZero(unsafe.Pointer(&i1)))6	fmt.Println("isZero(i2):", isZero(unsafe.Pointer(&i2)))7	fmt.Println("isZero(f1):", isZero(unsafe.Pointer(&f1)))8	fmt.Println("isZero(f2):", isZero(unsafe.Pointer(&f2)))9	fmt.Println("isZero(c1):", isZero(unsafe.Pointer(&c1)))10	fmt.Println("isZero(c2):", isZero(unsafe.Pointer(&c2)))11	fmt.Println("isZero(b1):", isZero(unsafe.Pointer(&b1)))12	fmt.Println("isZero(s1):", isZero(unsafe.Pointer(&s1)))13	fmt.Println("isZero(p1):", isZero(unsafe.Pointer(&p1)))14	fmt.Println("isZero(a1):", isZero(unsafe.Pointer(&a1)))15	fmt.Println("isZero(s2):", isZero(unsafe.Pointer(&s2)))16	fmt.Println("isZero(m1):", isZero(unsafe.Pointer(&m1)))17	fmt.Println("isZero(c3):", isZero(unsafe.Pointer(&c3)))18	fmt.Println("isZero(f3):", isZero(unsafe.Pointer(&f3)))19	fmt.Println("isZero(i3):", isZero(unsafe.Pointer(&i3)))20}21func isZero(ptr unsafe.Pointer) bool {22	return *(*byte)(ptr) == 023}24isZero(i1): true25isZero(i2): true26isZero(f1): true27isZero(f2): true28isZero(c1): true29isZero(c2): true30isZero(b1): true31isZero(s1): true32isZero(p1): true33isZero(a1): true34isZero(s2): true35isZero(m1): true36isZero(c3): true37isZero(f3): true38isZero(i

1import (2func main() {3	fmt.Println(i.IsZero())4}5type Internal struct {6}7func (i *Internal) IsZero() bool {8}9var ExportedMethods = [...]string{"IsZero"}

1import (2func main() {3	fmt.Println(1.IsZero(0))4}5import (6func main() {7	fmt.Println(1.IsZero(0))8}9import (10func main() {11	fmt.Println(1.IsZero(0))12}13import (14func main() {15	fmt.Println(1.IsZero(0))16}17import (18func main() {19	fmt.Println(1.IsZero(0))20}21import (22func main() {23	fmt.Println(1.IsZero(0))24}25import (26func main() {27	fmt.Println(1.IsZero(0))28}29import (30func main() {31	fmt.Println(1.IsZero(0))32}33import (34func main() {35	fmt.Println(1.IsZero(0))36}37import (38func main() {39	fmt.Println(1.IsZero(0))40}41import (42func main() {43	fmt.Println(1.IsZero(0))44}

1import (2type test struct {3}4func main() {5	t1 := reflect.TypeOf(t)6	fmt.Println(t1.Field(0).Name)7	fmt.Println(t1.Field(0).Type)8	fmt.Println(t1.Field(1).Name)9	fmt.Println(t1.Field(1).Type)10	fmt.Println(reflect.ValueOf(s).IsZero())11	fmt.Println(reflect.ValueOf(b).IsZero())12	fmt.Println(reflect.ValueOf(f).IsZero())13	fmt.Println(reflect.ValueOf(c).IsZero())14	fmt.Println(reflect.ValueOf(tm).IsZero())15	fmt.Println(reflect.ValueOf(p).IsZero())16	fmt.Println(reflect.ValueOf(m).IsZero())17	fmt.Println(reflect.ValueOf(ch).IsZero())18	fmt.Println(reflect.ValueOf(sl).IsZero())19	var fn func()20	fmt.Println(reflect.ValueOf(fn).IsZero())21	var st struct{}22	fmt.Println(reflect.ValueOf(st).IsZero())23	var itf interface{}24	fmt.Println(reflect.ValueOf(itf).IsZero())25	fmt.Println(reflect.ValueOf(arr).IsZero())26}

1import (2type A struct {3}4func main() {5	a := A{B: 10}6	fmt.Println(isZero(a))7}8func isZero(i interface{}) bool {9	return reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Inte

1import (2func main() {3	fmt.Println(1.IsZero(i))4}5import (6func main() {7	fmt.Println(1.IsZero(i))8}9import (10func main() {11	fmt.Println(1.IsZero(i))12}13import (14func main() {15	fmt.Println(1.IsZero(i))16}17import (18func main() {19	fmt.Println(1.IsZero(i))20}21import (22func main() {23	fmt.Println(1.IsZero(i))24}25import (26func main() {27	fmt.Println(1.IsZero(i))28}29import (30func main() {31	fmt.Println(1.IsZero(i))32}33import (34func main() {35	fmt.Println(

1import (2func main() {3    fmt.Println("Hello world!")4    fmt.Println(i.IsZero())5    fmt.Println(i.IsZero())6}7import (8func ExampleInt_IsZero() {9    fmt.Println(i.IsZero())10    fmt.Println(i.IsZero())11}12import (13func main() {14    fmt.Println("Hello world!")15    fmt.Println(i.IsZero())16    fmt.Println(i.IsZero())17}18import (19func ExampleInt_IsZero() {20    fmt.Println(i.IsZero())21    fmt.Println(i.IsZero())22}23import (24func main() {25    fmt.Println("Hello world!")26    fmt.Println(i.IsZero())27    fmt.Println(i.IsZero())28}29import (30func ExampleInt_IsZero() {31    fmt.Println(i.IsZero())