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

     1  package xmap
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  )
     7  
     8  type rawMap map[string]interface{}
     9  
    10  func (r rawMap) RawMap() map[string]interface{} {
    11  	return r
    12  }
    13  
    14  type baseMap map[string]interface{}
    15  
    16  func (b baseMap) ValueVal(path ...string) (v interface{}, err error) {
    17  	for _, p := range path {
    18  		if val, ok := b[p]; ok {
    19  			v = val
    20  			return
    21  		}
    22  	}
    23  	err = fmt.Errorf("not exists")
    24  	return
    25  }
    26  
    27  // SetValue will set value to path
    28  func (b baseMap) SetValue(path string, val interface{}) (err error) {
    29  	return
    30  }
    31  
    32  // Delete will delete value on path
    33  func (b baseMap) Delete(path string) (err error) {
    34  	return
    35  }
    36  
    37  // Clear will clear all key on map
    38  func (b baseMap) Clear() (err error) {
    39  	return
    40  }
    41  
    42  // Length will return value count
    43  func (b baseMap) Length() (l int) {
    44  	return
    45  }
    46  
    47  // Exist will return true if key having
    48  func (b baseMap) Exist(path ...string) bool {
    49  	return false
    50  }
    51  
    52  func TestWrap(t *testing.T) {
    53  	var err error
    54  	var wrapVals1 = []interface{}{
    55  		M{"a": 1},
    56  		map[string]interface{}{"b": 2},
    57  		rawMap{"c": 3},
    58  	}
    59  	var parseVals1 = append(wrapVals1, "{}", baseMap{"d": 4}, &impl{})
    60  	var wrapSafeVals1 = append(wrapVals1, baseMap{"d": 4}, &impl{})
    61  	var parseSafeVals1 = append(wrapSafeVals1, "{}")
    62  	var errVals1 = []interface{}{nil, "xx"}
    63  	for _, v := range wrapVals1 {
    64  		Wrap(v)
    65  	}
    66  	for _, v := range parseVals1 {
    67  		_, err = Parse(v)
    68  		if err != nil {
    69  			t.Errorf("err:%v,v:%v", err, v)
    70  			return
    71  		}
    72  	}
    73  	for _, v := range errVals1 {
    74  		func() {
    75  			defer func() {
    76  				if recover() == nil {
    77  					t.Error("error")
    78  				}
    79  			}()
    80  			Wrap(v)
    81  		}()
    82  		_, err = Parse(v)
    83  		if err == nil {
    84  			t.Error("error")
    85  		}
    86  	}
    87  	for _, v := range wrapSafeVals1 {
    88  		WrapSafe(v)
    89  	}
    90  	for _, v := range parseSafeVals1 {
    91  		_, err = ParseSafe(v)
    92  		if err != nil {
    93  			t.Errorf("err:%v,v:%v", err, v)
    94  		}
    95  	}
    96  	for _, v := range errVals1 {
    97  		func() {
    98  			defer func() {
    99  				if recover() == nil {
   100  					t.Error("error")
   101  				}
   102  			}()
   103  			WrapSafe(v)
   104  		}()
   105  		_, err = ParseSafe(v)
   106  		if err == nil {
   107  			t.Error("error")
   108  		}
   109  	}
   110  }
   111  
   112  func TestWrapArray(t *testing.T) {
   113  	var err error
   114  	var wrapVals1 = []interface{}{
   115  		nil,
   116  		[]interface{}{nil},
   117  		[]M{{"a": 1}},
   118  		[]map[string]interface{}{{"b": 2}},
   119  		[]rawMap{{"c": 3}},
   120  	}
   121  	var parseVals1 = append(wrapVals1, "[{}]", []baseMap{{"d": 4}}, []*impl{{}})
   122  	var wrapSafeVals1 = append(wrapVals1, []baseMap{{"d": 4}}, []*impl{{}})
   123  	var parseSafeVals1 = append(wrapSafeVals1, "[{}]")
   124  	var errVals1 = []interface{}{"xx", []string{"xx"}}
   125  	for _, v := range wrapVals1 {
   126  		WrapArray(v)
   127  	}
   128  	for _, v := range parseVals1 {
   129  		_, err = ParseArray(v)
   130  		if err != nil {
   131  			t.Errorf("err:%v,v:%v", err, v)
   132  			return
   133  		}
   134  	}
   135  	for _, v := range errVals1 {
   136  		func() {
   137  			defer func() {
   138  				if recover() == nil {
   139  					t.Error("error")
   140  				}
   141  			}()
   142  			WrapArray(v)
   143  		}()
   144  		_, err = ParseArray(v)
   145  		if err == nil {
   146  			t.Errorf("error:%v", v)
   147  		}
   148  	}
   149  	for _, v := range wrapSafeVals1 {
   150  		WrapSafeArray(v)
   151  	}
   152  	for _, v := range parseSafeVals1 {
   153  		_, err = ParseSafeArray(v)
   154  		if err != nil {
   155  			t.Errorf("err:%v,v:%v", err, v)
   156  		}
   157  	}
   158  	for _, v := range errVals1 {
   159  		func() {
   160  			defer func() {
   161  				if recover() == nil {
   162  					t.Error("error")
   163  				}
   164  			}()
   165  			WrapSafeArray(v)
   166  		}()
   167  		_, err = ParseSafeArray(v)
   168  		if err == nil {
   169  			t.Error("error")
   170  		}
   171  	}
   172  }