github.com/sttk/sabi@v0.5.0/benchmark/err/benchmark_err_test.go (about)

     1  package sabi_test
     2  
     3  import (
     4  	"strconv"
     5  	"testing"
     6  
     7  	"github.com/sttk/sabi"
     8  )
     9  
    10  func unused(v any) {}
    11  
    12  func returnNilError() error {
    13  	return nil
    14  }
    15  func BenchmarkError_nil(b *testing.B) {
    16  	var err error
    17  	b.StartTimer()
    18  	for i := 0; i < b.N; i++ {
    19  		e := returnNilError()
    20  		err = e
    21  	}
    22  	b.StopTimer()
    23  	unused(err)
    24  }
    25  
    26  func returnOkErr() sabi.Err {
    27  	return sabi.Ok()
    28  }
    29  func BenchmarkErr_ok(b *testing.B) {
    30  	var err sabi.Err
    31  	b.StartTimer()
    32  	for i := 0; i < b.N; i++ {
    33  		e := returnOkErr()
    34  		err = e
    35  	}
    36  	b.StopTimer()
    37  	unused(err)
    38  }
    39  
    40  func BenchmarkError_nil_isNil(b *testing.B) {
    41  	var err error
    42  	e := returnNilError()
    43  	b.StartTimer()
    44  	for i := 0; i < b.N; i++ {
    45  		if e == nil {
    46  			err = e
    47  		}
    48  	}
    49  	b.StopTimer()
    50  	unused(err)
    51  }
    52  
    53  func BenchmarkErr_ok_isOk(b *testing.B) {
    54  	var err sabi.Err
    55  	e := returnOkErr()
    56  	b.StartTimer()
    57  	for i := 0; i < b.N; i++ {
    58  		if e.IsOk() {
    59  			err = e
    60  		}
    61  	}
    62  	b.StopTimer()
    63  	unused(err)
    64  }
    65  
    66  func BenchmarkError_nil_typeSwitch(b *testing.B) {
    67  	var err error
    68  	e := returnNilError()
    69  	b.StartTimer()
    70  	for i := 0; i < b.N; i++ {
    71  		switch e.(type) {
    72  		case nil:
    73  			err = e
    74  		default:
    75  			b.Fail()
    76  		}
    77  	}
    78  	b.StopTimer()
    79  	unused(err)
    80  }
    81  
    82  func BenchmarkErr_ok_typeSwitch(b *testing.B) {
    83  	var err sabi.Err
    84  	e := returnOkErr()
    85  	b.StartTimer()
    86  	for i := 0; i < b.N; i++ {
    87  		switch e.Reason().(type) {
    88  		case nil:
    89  			err = e
    90  		default:
    91  			b.Fail()
    92  		}
    93  	}
    94  	b.StopTimer()
    95  	unused(err)
    96  }
    97  
    98  func BenchmarkError_nil_ErrorString(b *testing.B) {
    99  	var str string
   100  	b.StartTimer()
   101  	for i := 0; i < b.N; i++ {
   102  		s := "nil"
   103  		str = s
   104  	}
   105  	b.StopTimer()
   106  	unused(str)
   107  }
   108  
   109  func BenchmarkErr_ok_ErrorString(b *testing.B) {
   110  	var str string
   111  	e := returnOkErr()
   112  	b.StartTimer()
   113  	for i := 0; i < b.N; i++ {
   114  		s := e.Error()
   115  		str = s
   116  	}
   117  	b.StopTimer()
   118  	unused(str)
   119  }
   120  
   121  type EmptyError struct {
   122  }
   123  
   124  func returnEmptyError() error {
   125  	return EmptyError{}
   126  }
   127  func (e EmptyError) Error() string {
   128  	return "EmptyError"
   129  }
   130  func BenchmarkError_empty(b *testing.B) {
   131  	var err error
   132  	b.StartTimer()
   133  	for i := 0; i < b.N; i++ {
   134  		e := returnEmptyError()
   135  		err = e
   136  	}
   137  	b.StopTimer()
   138  	unused(err)
   139  }
   140  
   141  type EmptyReason struct {
   142  }
   143  
   144  func returnEmptyReasonedErr() sabi.Err {
   145  	return sabi.NewErr(EmptyReason{})
   146  }
   147  func BenchmarkErr_emptyReason(b *testing.B) {
   148  	var err sabi.Err
   149  	b.StartTimer()
   150  	for i := 0; i < b.N; i++ {
   151  		e := returnEmptyReasonedErr()
   152  		err = e
   153  	}
   154  	b.StopTimer()
   155  	unused(err)
   156  }
   157  
   158  func BenchmarkError_empty_isNotNil(b *testing.B) {
   159  	var err error
   160  	e := returnEmptyError()
   161  	b.StartTimer()
   162  	for i := 0; i < b.N; i++ {
   163  		if e != nil {
   164  			err = e
   165  		}
   166  	}
   167  	b.StopTimer()
   168  	unused(err)
   169  }
   170  
   171  func BenchmarkErr_emptyReason_isNotOk(b *testing.B) {
   172  	var err sabi.Err
   173  	e := returnEmptyReasonedErr()
   174  	b.StartTimer()
   175  	for i := 0; i < b.N; i++ {
   176  		if !e.IsOk() {
   177  			err = e
   178  		}
   179  	}
   180  	b.StopTimer()
   181  	unused(err)
   182  }
   183  
   184  func BenchmarkError_empty_typeSwitch(b *testing.B) {
   185  	var err error
   186  	e := returnEmptyError()
   187  	b.StartTimer()
   188  	for i := 0; i < b.N; i++ {
   189  		switch e.(type) {
   190  		case EmptyError:
   191  			err = e
   192  		default:
   193  			b.Fail()
   194  		}
   195  	}
   196  	b.StopTimer()
   197  	unused(err)
   198  }
   199  
   200  func BenchmarkErr_emptyReason_typeSwitch(b *testing.B) {
   201  	var err sabi.Err
   202  	e := returnEmptyReasonedErr()
   203  	b.StartTimer()
   204  	for i := 0; i < b.N; i++ {
   205  		switch e.Reason().(type) {
   206  		case EmptyReason:
   207  			err = e
   208  		default:
   209  			b.Fail()
   210  		}
   211  	}
   212  	b.StopTimer()
   213  	unused(err)
   214  }
   215  
   216  func BenchmarkError_empty_ErrorString(b *testing.B) {
   217  	var str string
   218  	e := returnEmptyError()
   219  	b.StartTimer()
   220  	for i := 0; i < b.N; i++ {
   221  		s := e.Error()
   222  		str = s
   223  	}
   224  	b.StopTimer()
   225  	unused(str)
   226  }
   227  
   228  func BenchmarkErr_emptyReason_ErrorString(b *testing.B) {
   229  	var str string
   230  	e := returnEmptyReasonedErr()
   231  	b.StartTimer()
   232  	for i := 0; i < b.N; i++ {
   233  		s := e.Error()
   234  		str = s
   235  	}
   236  	b.StopTimer()
   237  	unused(str)
   238  	unused(e)
   239  }
   240  
   241  type OneFieldError struct {
   242  	FieldA string
   243  }
   244  
   245  func (e OneFieldError) Error() string {
   246  	return "OneFieldError{FieldA:" + e.FieldA + "}"
   247  }
   248  func returnOneFieldError() error {
   249  	return OneFieldError{FieldA: "abc"}
   250  }
   251  func BenchmarkError_oneField(b *testing.B) {
   252  	var err error
   253  	b.StartTimer()
   254  	for i := 0; i < b.N; i++ {
   255  		e := returnOneFieldError()
   256  		err = e
   257  	}
   258  	b.StopTimer()
   259  	unused(err)
   260  }
   261  
   262  type OneFieldReason struct {
   263  	FieldA string
   264  }
   265  
   266  func returnOneFieldReasonedErr() sabi.Err {
   267  	return sabi.NewErr(OneFieldReason{FieldA: "abc"})
   268  }
   269  func BenchmarkErr_oneFieldReason(b *testing.B) {
   270  	var err sabi.Err
   271  	b.StartTimer()
   272  	for i := 0; i < b.N; i++ {
   273  		e := returnOneFieldReasonedErr()
   274  		err = e
   275  	}
   276  	b.StopTimer()
   277  	unused(err)
   278  }
   279  
   280  func returnOneFieldErrorPtr() error {
   281  	return &OneFieldError{FieldA: "abc"}
   282  }
   283  func BenchmarkError_oneFieldPtr(b *testing.B) {
   284  	var err error
   285  	b.StartTimer()
   286  	for i := 0; i < b.N; i++ {
   287  		e := returnOneFieldErrorPtr()
   288  		err = e
   289  	}
   290  	b.StopTimer()
   291  	unused(err)
   292  }
   293  
   294  func returnOneFieldReasonedPtrErr() sabi.Err {
   295  	return sabi.NewErr(&OneFieldReason{FieldA: "abc"})
   296  }
   297  func BenchmarkErr_oneFieldReasonPtr(b *testing.B) {
   298  	var err sabi.Err
   299  	b.StartTimer()
   300  	for i := 0; i < b.N; i++ {
   301  		e := returnOneFieldReasonedPtrErr()
   302  		err = e
   303  	}
   304  	b.StopTimer()
   305  	unused(err)
   306  }
   307  
   308  func BenchmarkError_oneField_isNotNil(b *testing.B) {
   309  	var err error
   310  	e := returnOneFieldError()
   311  	b.StartTimer()
   312  	for i := 0; i < b.N; i++ {
   313  		if e != nil {
   314  			err = e
   315  		}
   316  	}
   317  	b.StopTimer()
   318  	unused(err)
   319  }
   320  
   321  func BenchmarkErr_oneFieldReason_isNotOk(b *testing.B) {
   322  	var err sabi.Err
   323  	e := returnOneFieldReasonedErr()
   324  	b.StartTimer()
   325  	for i := 0; i < b.N; i++ {
   326  		if !e.IsOk() {
   327  			err = e
   328  		}
   329  	}
   330  	b.StopTimer()
   331  	unused(err)
   332  }
   333  
   334  func BenchmarkError_oneField_typeSwitch(b *testing.B) {
   335  	var err error
   336  	e := returnOneFieldError()
   337  	b.StartTimer()
   338  	for i := 0; i < b.N; i++ {
   339  		switch e.(type) {
   340  		case OneFieldError:
   341  			err = e
   342  		default:
   343  			b.Fail()
   344  		}
   345  	}
   346  	b.StopTimer()
   347  	unused(err)
   348  }
   349  
   350  func BenchmarkErr_oneFieldReason_typeSwitch(b *testing.B) {
   351  	var err sabi.Err
   352  	e := returnOneFieldReasonedErr()
   353  	b.StartTimer()
   354  	for i := 0; i < b.N; i++ {
   355  		switch e.Reason().(type) {
   356  		case OneFieldReason:
   357  			err = e
   358  		default:
   359  			b.Fail()
   360  		}
   361  	}
   362  	b.StopTimer()
   363  	unused(err)
   364  }
   365  
   366  func BenchmarkError_oneField_ErrorString(b *testing.B) {
   367  	var str string
   368  	e := returnOneFieldError()
   369  	b.StartTimer()
   370  	for i := 0; i < b.N; i++ {
   371  		s := e.Error()
   372  		str = s
   373  	}
   374  	b.StopTimer()
   375  	unused(str)
   376  }
   377  
   378  func BenchmarkErr_oneFieldReason_ErrorString(b *testing.B) {
   379  	var str string
   380  	e := returnOneFieldReasonedErr()
   381  	b.StartTimer()
   382  	for i := 0; i < b.N; i++ {
   383  		s := e.Error()
   384  		str = s
   385  	}
   386  	b.StopTimer()
   387  	unused(str)
   388  }
   389  
   390  type FiveFieldError struct {
   391  	FieldA string
   392  	FieldB int
   393  	FieldC bool
   394  	FieldD string
   395  	FieldE string
   396  }
   397  
   398  func (e FiveFieldError) Error() string {
   399  	return "FiveFieldError{FieldA:" + e.FieldA +
   400  		",FieldB:" + strconv.Itoa(e.FieldB) +
   401  		",FieldC:" + strconv.FormatBool(e.FieldC) +
   402  		",FieldD:" + e.FieldD + ",FieldE:" + e.FieldE +
   403  		"}"
   404  }
   405  func returnFiveFieldError() error {
   406  	return FiveFieldError{
   407  		FieldA: "abc", FieldB: 123, FieldC: true, FieldD: "def", FieldE: "ghi",
   408  	}
   409  }
   410  func BenchmarkError_fiveField(b *testing.B) {
   411  	var err error
   412  	b.StartTimer()
   413  	for i := 0; i < b.N; i++ {
   414  		e := returnFiveFieldError()
   415  		err = e
   416  	}
   417  	b.StopTimer()
   418  	unused(err)
   419  }
   420  
   421  type FiveFieldReason struct {
   422  	FieldA string
   423  	FieldB int
   424  	FieldC bool
   425  	FieldD string
   426  	FieldE string
   427  }
   428  
   429  func returnFiveFieldReasonedErr() sabi.Err {
   430  	return sabi.NewErr(FiveFieldReason{
   431  		FieldA: "abc", FieldB: 123, FieldC: true, FieldD: "def", FieldE: "ghi",
   432  	})
   433  }
   434  func BenchmarkErr_fiveFieldReason(b *testing.B) {
   435  	var err sabi.Err
   436  	b.StartTimer()
   437  	for i := 0; i < b.N; i++ {
   438  		e := returnFiveFieldReasonedErr()
   439  		err = e
   440  	}
   441  	b.StopTimer()
   442  	unused(err)
   443  }
   444  
   445  func BenchmarkError_fiveField_isNotNil(b *testing.B) {
   446  	var err error
   447  	e := returnFiveFieldError()
   448  	b.StartTimer()
   449  	for i := 0; i < b.N; i++ {
   450  		if e != nil {
   451  			err = e
   452  		}
   453  	}
   454  	b.StopTimer()
   455  	unused(err)
   456  }
   457  
   458  func BenchmarkErr_fiveFieldReason_isNotOk(b *testing.B) {
   459  	var err sabi.Err
   460  	e := returnFiveFieldReasonedErr()
   461  	b.StartTimer()
   462  	for i := 0; i < b.N; i++ {
   463  		if !e.IsOk() {
   464  			err = e
   465  		}
   466  	}
   467  	b.StopTimer()
   468  	unused(err)
   469  }
   470  
   471  func BenchmarkError_fiveField_typeSwitch(b *testing.B) {
   472  	var err error
   473  	e := returnFiveFieldError()
   474  	b.StartTimer()
   475  	for i := 0; i < b.N; i++ {
   476  		switch e.(type) {
   477  		case FiveFieldError:
   478  			err = e
   479  		default:
   480  			b.Fail()
   481  		}
   482  	}
   483  	b.StopTimer()
   484  	unused(err)
   485  }
   486  
   487  func BenchmarkErr_fiveFieldReason_typeSwitch(b *testing.B) {
   488  	var err sabi.Err
   489  	e := returnFiveFieldReasonedErr()
   490  	b.StartTimer()
   491  	for i := 0; i < b.N; i++ {
   492  		switch e.Reason().(type) {
   493  		case FiveFieldReason:
   494  			err = e
   495  		default:
   496  			b.Fail()
   497  		}
   498  	}
   499  	b.StopTimer()
   500  	unused(err)
   501  }
   502  
   503  func BenchmarkError_fiveField_ErrorString(b *testing.B) {
   504  	var str string
   505  	e := returnFiveFieldError()
   506  	b.StartTimer()
   507  	for i := 0; i < b.N; i++ {
   508  		s := e.Error()
   509  		str = s
   510  	}
   511  	b.StopTimer()
   512  	unused(str)
   513  }
   514  
   515  func BenchmarkErr_fiveFieldReason_ErrorString(b *testing.B) {
   516  	var str string
   517  	e := returnFiveFieldReasonedErr()
   518  	b.StartTimer()
   519  	for i := 0; i < b.N; i++ {
   520  		s := e.Error()
   521  		str = s
   522  	}
   523  	b.StopTimer()
   524  	unused(str)
   525  }
   526  
   527  type HavingCauseError struct {
   528  	Cause error
   529  }
   530  
   531  func (e HavingCauseError) Error() string {
   532  	return "HavingCauseError{cause:" + e.Cause.Error() + "}"
   533  }
   534  func (e HavingCauseError) Unwrap() error {
   535  	return e.Cause
   536  }
   537  func returnHavingCauseError() error {
   538  	return HavingCauseError{Cause: EmptyError{}}
   539  }
   540  func BenchmarkError_havingCause(b *testing.B) {
   541  	var err error
   542  	b.StartTimer()
   543  	for i := 0; i < b.N; i++ {
   544  		e := returnHavingCauseError()
   545  		err = e
   546  	}
   547  	b.StopTimer()
   548  	unused(err)
   549  }
   550  
   551  type HavingCauseReason struct {
   552  }
   553  
   554  func returnHavingCauseReasonedErr() sabi.Err {
   555  	return sabi.NewErr(HavingCauseError{}, EmptyError{})
   556  }
   557  func BenchmarkErr_havingCauseReason(b *testing.B) {
   558  	var err sabi.Err
   559  	b.StartTimer()
   560  	for i := 0; i < b.N; i++ {
   561  		e := returnHavingCauseReasonedErr()
   562  		err = e
   563  	}
   564  	b.StopTimer()
   565  	unused(err)
   566  }
   567  
   568  func BenchmarkError_havingCause_ErrorString(b *testing.B) {
   569  	var str string
   570  	e := returnHavingCauseError()
   571  	b.StartTimer()
   572  	for i := 0; i < b.N; i++ {
   573  		s := e.Error()
   574  		str = s
   575  	}
   576  	b.StopTimer()
   577  	unused(str)
   578  }
   579  
   580  func BenchmarkErr_havingCauseReason_ErrorString(b *testing.B) {
   581  	var str string
   582  	e := returnHavingCauseReasonedErr()
   583  	b.StartTimer()
   584  	for i := 0; i < b.N; i++ {
   585  		s := e.Error()
   586  		str = s
   587  	}
   588  	b.StopTimer()
   589  	unused(str)
   590  }
   591  
   592  func fn() sabi.Err { return sabi.Ok() }
   593  
   594  func BenchmarkError_IfStatement(b *testing.B) {
   595  	var err sabi.Err
   596  	var e error = nil
   597  	b.StartTimer()
   598  	for i := 0; i < b.N; i++ {
   599  		if e == nil {
   600  			err = fn()
   601  		}
   602  	}
   603  	b.StopTimer()
   604  	unused(err)
   605  }
   606  
   607  func BenchmarkErr_IfStatement(b *testing.B) {
   608  	var err sabi.Err
   609  	e := sabi.Ok()
   610  	b.StartTimer()
   611  	for i := 0; i < b.N; i++ {
   612  		if e.IsOk() {
   613  			err = fn()
   614  		}
   615  	}
   616  	b.StopTimer()
   617  	unused(err)
   618  }
   619  
   620  func BenchmarkErr_IfOk(b *testing.B) {
   621  	var err sabi.Err
   622  	e := sabi.Ok()
   623  	b.StartTimer()
   624  	for i := 0; i < b.N; i++ {
   625  		err = e.IfOk(fn)
   626  	}
   627  	b.StopTimer()
   628  	unused(err)
   629  }