github.com/codingeasygo/util@v0.0.0-20231206062002-1ce2f004b7d9/xmap/should_test.go (about)

     1  package xmap
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  )
     7  
     8  func TestShould(t *testing.T) {
     9  	var ptr string
    10  	var ptr2 *string
    11  	vals := M{
    12  		"int":     123,
    13  		"int2":    0,
    14  		"uint":    uint(123),
    15  		"uint2":   uint(0),
    16  		"float":   float64(123),
    17  		"float2":  float64(0),
    18  		"string":  "123",
    19  		"string2": "",
    20  		"ptr":     &ptr,
    21  		"ptr2":    ptr2,
    22  		"invalid": nil,
    23  		"slice":   []int{123},
    24  		"slice2":  []int{},
    25  		"map": map[string]int{
    26  			"a": 123,
    27  		},
    28  		"map2": map[string]int{},
    29  	}
    30  	{ //check
    31  		if err := vals.Should("int", 123); err != nil {
    32  			t.Error(err)
    33  			return
    34  		}
    35  		if err := vals.Should("uint", uint(123)); err != nil {
    36  			t.Error(err)
    37  			return
    38  		}
    39  		if err := vals.Should("float", float64(123)); err != nil {
    40  			t.Error(err)
    41  			return
    42  		}
    43  		if err := vals.Should("string", "123"); err != nil {
    44  			t.Error(err)
    45  			return
    46  		}
    47  		if err := vals.Should("int", ShouldIsNoZero); err != nil {
    48  			t.Error(err)
    49  			return
    50  		}
    51  		if err := vals.Should("ptr", ShouldIsNoNil); err != nil {
    52  			t.Error(err)
    53  			return
    54  		}
    55  		if err := vals.Should("slice", ShouldIsNoEmpty); err != nil {
    56  			t.Error(err)
    57  			return
    58  		}
    59  		if err := vals.Should("map", ShouldIsNoEmpty); err != nil {
    60  			t.Error(err)
    61  			return
    62  		}
    63  		if err := vals.Should("ptr2", ShouldIsNil); err != nil {
    64  			t.Error(err)
    65  			return
    66  		}
    67  		if err := vals.Should("invalid", ShouldIsNil); err != nil {
    68  			t.Error(err)
    69  			return
    70  		}
    71  		if err := vals.Should("invalid", ShouldIsZero); err != nil {
    72  			t.Error(err)
    73  			return
    74  		}
    75  		if err := vals.Should("slice2", ShouldIsEmpty); err != nil {
    76  			t.Error(err)
    77  			return
    78  		}
    79  		if err := vals.Should("map2", ShouldIsEmpty); err != nil {
    80  			t.Error(err)
    81  			return
    82  		}
    83  		//not
    84  		if err := vals.Should("int2", 123); err == nil {
    85  			t.Error(err)
    86  			return
    87  		}
    88  		if err := vals.Should("uint2", uint(123)); err == nil {
    89  			t.Error(err)
    90  			return
    91  		}
    92  		if err := vals.Should("float2", float64(123)); err == nil {
    93  			t.Error(err)
    94  			return
    95  		}
    96  		if err := vals.Should("string2", "123"); err == nil {
    97  			t.Error(err)
    98  			return
    99  		}
   100  		if err := vals.Should("int", ShouldIsZero); err == nil {
   101  			t.Error(err)
   102  			return
   103  		}
   104  		if err := vals.Should("ptr", ShouldIsNil); err == nil {
   105  			t.Error(err)
   106  			return
   107  		}
   108  		if err := vals.Should("slice", ShouldIsEmpty); err == nil {
   109  			t.Error(err)
   110  			return
   111  		}
   112  		if err := vals.Should("map", ShouldIsEmpty); err == nil {
   113  			t.Error(err)
   114  			return
   115  		}
   116  		if err := vals.Should("int2", ShouldIsNoZero); err == nil {
   117  			t.Error(err)
   118  			return
   119  		}
   120  		if err := vals.Should("ptr2", ShouldIsNoNil); err == nil {
   121  			t.Error(err)
   122  			return
   123  		}
   124  		if err := vals.Should("invalid", ShouldIsNoNil); err == nil {
   125  			t.Error(err)
   126  			return
   127  		}
   128  		if err := vals.Should("slice2", ShouldIsNoEmpty); err == nil {
   129  			t.Error(err)
   130  			return
   131  		}
   132  		if err := vals.Should("map2", ShouldIsNoEmpty); err == nil {
   133  			t.Error(err)
   134  			return
   135  		}
   136  		if err := vals.Should("ptr", ShouldIsInt); err == nil {
   137  			t.Error(err)
   138  			return
   139  		}
   140  		if err := vals.Should("ptr", ShouldIsUint); err == nil {
   141  			t.Error(err)
   142  			return
   143  		}
   144  		if err := vals.Should("ptr", ShouldIsFloat); err == nil {
   145  			t.Error(err)
   146  			return
   147  		}
   148  	}
   149  	{ //compare
   150  		if err := vals.Should("int", ShouldEQ, 123); err != nil {
   151  			t.Error(err)
   152  			return
   153  		}
   154  		if err := vals.Should("uint", ShouldEQ, uint(123)); err != nil {
   155  			t.Error(err)
   156  			return
   157  		}
   158  		if err := vals.Should("float", ShouldEQ, float64(123)); err != nil {
   159  			t.Error(err)
   160  			return
   161  		}
   162  		if err := vals.Should("int", ShouldEQ, uint(123)); err != nil {
   163  			t.Error(err)
   164  			return
   165  		}
   166  		if err := vals.Should("uint", ShouldEQ, 123); err != nil {
   167  			t.Error(err)
   168  			return
   169  		}
   170  		if err := vals.Should("float", ShouldEQ, 123); err != nil {
   171  			t.Error(err)
   172  			return
   173  		}
   174  		if err := vals.Should("int", ShouldGT, 122); err != nil {
   175  			t.Error(err)
   176  			return
   177  		}
   178  		if err := vals.Should("uint", ShouldGT, uint(122)); err != nil {
   179  			t.Error(err)
   180  			return
   181  		}
   182  		if err := vals.Should("float", ShouldGT, float64(122)); err != nil {
   183  			t.Error(err)
   184  			return
   185  		}
   186  		if err := vals.Should("int", ShouldGTE, 123); err != nil {
   187  			t.Error(err)
   188  			return
   189  		}
   190  		if err := vals.Should("uint", ShouldGTE, uint(123)); err != nil {
   191  			t.Error(err)
   192  			return
   193  		}
   194  		if err := vals.Should("float", ShouldGTE, float64(123)); err != nil {
   195  			t.Error(err)
   196  			return
   197  		}
   198  		if err := vals.Should("int", ShouldLT, 124); err != nil {
   199  			t.Error(err)
   200  			return
   201  		}
   202  		if err := vals.Should("uint", ShouldLT, uint(124)); err != nil {
   203  			t.Error(err)
   204  			return
   205  		}
   206  		if err := vals.Should("float", ShouldLT, float64(124)); err != nil {
   207  			t.Error(err)
   208  			return
   209  		}
   210  		if err := vals.Should("int", ShouldLTE, 123); err != nil {
   211  			t.Error(err)
   212  			return
   213  		}
   214  		if err := vals.Should("uint", ShouldLTE, uint(123)); err != nil {
   215  			t.Error(err)
   216  			return
   217  		}
   218  		if err := vals.Should("float", ShouldLTE, float64(123)); err != nil {
   219  			t.Error(err)
   220  			return
   221  		}
   222  		//not
   223  		if err := vals.Should("int", ShouldEQ, 124); err == nil {
   224  			t.Error(err)
   225  			return
   226  		}
   227  		if err := vals.Should("uint", ShouldEQ, uint(124)); err == nil {
   228  			t.Error(err)
   229  			return
   230  		}
   231  		if err := vals.Should("float", ShouldEQ, float64(124)); err == nil {
   232  			t.Error(err)
   233  			return
   234  		}
   235  		if err := vals.Should("int", ShouldGT, 124); err == nil {
   236  			t.Error(err)
   237  			return
   238  		}
   239  		if err := vals.Should("uint", ShouldGT, uint(124)); err == nil {
   240  			t.Error(err)
   241  			return
   242  		}
   243  		if err := vals.Should("float", ShouldGT, float64(124)); err == nil {
   244  			t.Error(err)
   245  			return
   246  		}
   247  		if err := vals.Should("int", ShouldGTE, 124); err == nil {
   248  			t.Error(err)
   249  			return
   250  		}
   251  		if err := vals.Should("uint", ShouldGTE, uint(124)); err == nil {
   252  			t.Error(err)
   253  			return
   254  		}
   255  		if err := vals.Should("float", ShouldGTE, float64(124)); err == nil {
   256  			t.Error(err)
   257  			return
   258  		}
   259  		if err := vals.Should("int", ShouldLT, 122); err == nil {
   260  			t.Error(err)
   261  			return
   262  		}
   263  		if err := vals.Should("uint", ShouldLT, uint(122)); err == nil {
   264  			t.Error(err)
   265  			return
   266  		}
   267  		if err := vals.Should("float", ShouldLT, float64(122)); err == nil {
   268  			t.Error(err)
   269  			return
   270  		}
   271  		if err := vals.Should("int", ShouldLTE, 122); err == nil {
   272  			t.Error(err)
   273  			return
   274  		}
   275  		if err := vals.Should("uint", ShouldLTE, uint(122)); err == nil {
   276  			t.Error(err)
   277  			return
   278  		}
   279  		if err := vals.Should("float", ShouldLTE, float64(122)); err == nil {
   280  			t.Error(err)
   281  			return
   282  		}
   283  	}
   284  	{ //error
   285  		if err := vals.Should("xx"); err == nil {
   286  			t.Error(err)
   287  			return
   288  		}
   289  		if err := vals.Should(1, 2); err == nil {
   290  			t.Error(err)
   291  			return
   292  		}
   293  		if err := vals.Should("xxx", ShouldLTE); err == nil {
   294  			t.Error(err)
   295  			return
   296  		}
   297  	}
   298  }
   299  
   300  func TestShoulder(t *testing.T) {
   301  	(&Shoulder{}).Should(t).Valid(1, M{"code": 0}, nil)
   302  	(&Shoulder{}).Should(t, "code", 0).Valid(1, M{"code": 0}, nil)
   303  	(&Shoulder{}).ShouldError(t).Valid(1, M{"code": 0}, fmt.Errorf("err"))
   304  	(&Shoulder{}).OnlyLog(true).Should(t, "code", 0).Valid(1, M{"code": 1}, nil)
   305  	(&Shoulder{}).OnlyLog(true).Should(t).Valid(1, M{"code": 1}, fmt.Errorf("err"))
   306  	(&Shoulder{}).OnlyLog(true).ShouldError(t).Valid(1, M{"code": 1}, nil)
   307  	func() {
   308  		defer func() {
   309  			fmt.Println(recover())
   310  		}()
   311  		(&Shoulder{}).Should(nil, "code", 0).Valid(1, M{"code": 1}, nil)
   312  	}()
   313  	{
   314  		shoulder := &Shoulder{}
   315  		shoulder.testerFail = func() {}
   316  		shoulder.testerSkip = func() {}
   317  		shoulder.Should(nil, "code", 0).Valid(1, M{"code": 1}, nil)
   318  	}
   319  }