github.com/TeaOSLab/EdgeNode@v1.3.8/internal/utils/kvstore/value_encoder_test.go (about)

     1  // Copyright 2024 GoEdge CDN goedge.cdn@gmail.com. All rights reserved. Official site: https://goedge.cn .
     2  
     3  package kvstore_test
     4  
     5  import (
     6  	"github.com/TeaOSLab/EdgeNode/internal/utils/kvstore"
     7  	"github.com/iwind/TeaGo/assert"
     8  	"testing"
     9  )
    10  
    11  func TestStringValueEncoder_Encode(t *testing.T) {
    12  	var a = assert.NewAssertion(t)
    13  
    14  	var encoder = kvstore.NewStringValueEncoder[string]()
    15  	data, err := encoder.Encode("abcdefg")
    16  	if err != nil {
    17  		t.Fatal(err)
    18  	}
    19  
    20  	value, err := encoder.Decode(data)
    21  	if err != nil {
    22  		t.Fatal(err)
    23  	}
    24  	a.IsTrue(value == "abcdefg")
    25  }
    26  
    27  func TestIntValueEncoder_Encode(t *testing.T) {
    28  	var a = assert.NewAssertion(t)
    29  
    30  	{
    31  		var encoder = kvstore.NewIntValueEncoder[int8]()
    32  		data, err := encoder.Encode(1)
    33  		if err != nil {
    34  			t.Fatal(err)
    35  		}
    36  		v, err := encoder.Decode(data)
    37  		if err != nil {
    38  			t.Fatal(err)
    39  		}
    40  		a.IsTrue(v == 1)
    41  		t.Log("int8", string(data), "=>", data, "=>", v)
    42  	}
    43  
    44  	{
    45  		var encoder = kvstore.NewIntValueEncoder[int8]()
    46  		data, err := encoder.Encode(-1)
    47  		if err != nil {
    48  			t.Fatal(err)
    49  		}
    50  		v, err := encoder.Decode(data)
    51  		if err != nil {
    52  			t.Fatal(err)
    53  		}
    54  		a.IsTrue(v == -1)
    55  		t.Log("int8", string(data), "=>", data, "=>", v)
    56  	}
    57  
    58  	{
    59  		var encoder = kvstore.NewIntValueEncoder[int16]()
    60  		data, err := encoder.Encode(123)
    61  		if err != nil {
    62  			t.Fatal(err)
    63  		}
    64  		v, err := encoder.Decode(data)
    65  		if err != nil {
    66  			t.Fatal(err)
    67  		}
    68  		a.IsTrue(v == 123)
    69  		t.Log("int16", string(data), "=>", data, "=>", v)
    70  	}
    71  
    72  	{
    73  		var encoder = kvstore.NewIntValueEncoder[int16]()
    74  		data, err := encoder.Encode(-123)
    75  		if err != nil {
    76  			t.Fatal(err)
    77  		}
    78  		v, err := encoder.Decode(data)
    79  		if err != nil {
    80  			t.Fatal(err)
    81  		}
    82  		a.IsTrue(v == -123)
    83  		t.Log("int16", string(data), "=>", data, "=>", v)
    84  	}
    85  
    86  	{
    87  		var encoder = kvstore.NewIntValueEncoder[int32]()
    88  		data, err := encoder.Encode(123)
    89  		if err != nil {
    90  			t.Fatal(err)
    91  		}
    92  		v, err := encoder.Decode(data)
    93  		if err != nil {
    94  			t.Fatal(err)
    95  		}
    96  		a.IsTrue(v == 123)
    97  		t.Log("int32", string(data), "=>", data, "=>", v)
    98  	}
    99  
   100  	{
   101  		var encoder = kvstore.NewIntValueEncoder[int32]()
   102  		data, err := encoder.Encode(-123)
   103  		if err != nil {
   104  			t.Fatal(err)
   105  		}
   106  		v, err := encoder.Decode(data)
   107  		if err != nil {
   108  			t.Fatal(err)
   109  		}
   110  		a.IsTrue(v == -123)
   111  		t.Log("int32", string(data), "=>", data, "=>", v)
   112  	}
   113  
   114  	{
   115  		var encoder = kvstore.NewIntValueEncoder[int64]()
   116  		data, err := encoder.Encode(123456)
   117  		if err != nil {
   118  			t.Fatal(err)
   119  		}
   120  		v, err := encoder.Decode(data)
   121  		if err != nil {
   122  			t.Fatal(err)
   123  		}
   124  		a.IsTrue(v == 123456)
   125  		t.Log("int64", string(data), "=>", data, "=>", v)
   126  	}
   127  
   128  	{
   129  		var encoder = kvstore.NewIntValueEncoder[int64]()
   130  		data, err := encoder.Encode(1234567890)
   131  		if err != nil {
   132  			t.Fatal(err)
   133  		}
   134  		v, err := encoder.Decode(data)
   135  		if err != nil {
   136  			t.Fatal(err)
   137  		}
   138  		a.IsTrue(v == 1234567890)
   139  		t.Log("int64", string(data), "=>", data, "=>", v)
   140  	}
   141  
   142  	{
   143  		var encoder = kvstore.NewIntValueEncoder[int64]()
   144  		data, err := encoder.Encode(-123456)
   145  		if err != nil {
   146  			t.Fatal(err)
   147  		}
   148  		v, err := encoder.Decode(data)
   149  		if err != nil {
   150  			t.Fatal(err)
   151  		}
   152  		a.IsTrue(v == -123456)
   153  		t.Log("int64", string(data), "=>", data, "=>", v)
   154  	}
   155  
   156  	{
   157  		var encoder = kvstore.NewIntValueEncoder[int]()
   158  		data, err := encoder.Encode(123)
   159  		if err != nil {
   160  			t.Fatal(err)
   161  		}
   162  		v, err := encoder.Decode(data)
   163  		if err != nil {
   164  			t.Fatal(err)
   165  		}
   166  		a.IsTrue(v == 123)
   167  		t.Log("int", string(data), "=>", data, "=>", v)
   168  	}
   169  
   170  	{
   171  		var encoder = kvstore.NewIntValueEncoder[int]()
   172  		data, err := encoder.Encode(-123)
   173  		if err != nil {
   174  			t.Fatal(err)
   175  		}
   176  		v, err := encoder.Decode(data)
   177  		if err != nil {
   178  			t.Fatal(err)
   179  		}
   180  		a.IsTrue(v == -123)
   181  		t.Log("int", string(data), "=>", data, "=>", v)
   182  	}
   183  
   184  	{
   185  		var encoder = kvstore.NewIntValueEncoder[uint]()
   186  		data, err := encoder.Encode(123)
   187  		if err != nil {
   188  			t.Fatal(err)
   189  		}
   190  		v, err := encoder.Decode(data)
   191  		if err != nil {
   192  			t.Fatal(err)
   193  		}
   194  		a.IsTrue(v == 123)
   195  		t.Log("uint", string(data), "=>", data, "=>", v)
   196  	}
   197  
   198  	{
   199  		var encoder = kvstore.NewIntValueEncoder[uint8]()
   200  		data, err := encoder.Encode(97)
   201  		if err != nil {
   202  			t.Fatal(err)
   203  		}
   204  		v, err := encoder.Decode(data)
   205  		if err != nil {
   206  			t.Fatal(err)
   207  		}
   208  		a.IsTrue(v == 97)
   209  		t.Log("uint8", string(data), "=>", data, "=>", v)
   210  	}
   211  
   212  	{
   213  		var encoder = kvstore.NewIntValueEncoder[uint16]()
   214  		data, err := encoder.Encode(123)
   215  		if err != nil {
   216  			t.Fatal(err)
   217  		}
   218  		v, err := encoder.Decode(data)
   219  		if err != nil {
   220  			t.Fatal(err)
   221  		}
   222  		a.IsTrue(v == 123)
   223  		t.Log("uint16", string(data), "=>", data, "=>", v)
   224  	}
   225  
   226  	{
   227  		var encoder = kvstore.NewIntValueEncoder[uint32]()
   228  		data, err := encoder.Encode(123)
   229  		if err != nil {
   230  			t.Fatal(err)
   231  		}
   232  		v, err := encoder.Decode(data)
   233  		if err != nil {
   234  			t.Fatal(err)
   235  		}
   236  		a.IsTrue(v == 123)
   237  		t.Log("uint32", string(data), "=>", data, "=>", v)
   238  	}
   239  
   240  	{
   241  		var encoder = kvstore.NewIntValueEncoder[uint64]()
   242  		data, err := encoder.Encode(123)
   243  		if err != nil {
   244  			t.Fatal(err)
   245  		}
   246  		v, err := encoder.Decode(data)
   247  		if err != nil {
   248  			t.Fatal(err)
   249  		}
   250  		a.IsTrue(v == 123)
   251  		t.Log("uint64", string(data), "=>", data, "=>", v)
   252  	}
   253  
   254  	{
   255  		var encoder = kvstore.NewIntValueEncoder[uint64]()
   256  		data, err := encoder.Encode(1234567890)
   257  		if err != nil {
   258  			t.Fatal(err)
   259  		}
   260  		v, err := encoder.Decode(data)
   261  		if err != nil {
   262  			t.Fatal(err)
   263  		}
   264  		a.IsTrue(v == 1234567890)
   265  		t.Log("uint64", string(data), "=>", data, "=>", v)
   266  	}
   267  }
   268  
   269  func TestBytesValueEncoder_Encode(t *testing.T) {
   270  	var encoder = kvstore.NewBytesValueEncoder[[]byte]()
   271  	{
   272  		data, err := encoder.Encode(nil)
   273  		if err != nil {
   274  			t.Fatal(err)
   275  		}
   276  		value, err := encoder.Decode(data)
   277  		if err != nil {
   278  			t.Fatal(err)
   279  		}
   280  		t.Log(data, "=>", value)
   281  	}
   282  
   283  	{
   284  		data, err := encoder.Encode([]byte("ABC"))
   285  		if err != nil {
   286  			t.Fatal(err)
   287  		}
   288  		value, err := encoder.Decode(data)
   289  		if err != nil {
   290  			t.Fatal(err)
   291  		}
   292  		t.Log(data, "=>", value)
   293  	}
   294  }
   295  
   296  func TestBytesValueEncoder_Bool(t *testing.T) {
   297  	var encoder = kvstore.NewBoolValueEncoder[bool]()
   298  	{
   299  		data, err := encoder.Encode(true)
   300  		if err != nil {
   301  			t.Fatal(err)
   302  		}
   303  		value, err := encoder.Decode(data)
   304  		if err != nil {
   305  			t.Fatal(err)
   306  		}
   307  		t.Log(data, "=>", value)
   308  	}
   309  
   310  	{
   311  		data, err := encoder.Encode(false)
   312  		if err != nil {
   313  			t.Fatal(err)
   314  		}
   315  		value, err := encoder.Decode(data)
   316  		if err != nil {
   317  			t.Fatal(err)
   318  		}
   319  		t.Log(data, "=>", value)
   320  	}
   321  
   322  	{
   323  		value, err := encoder.Decode(nil)
   324  		if err != nil {
   325  			t.Fatal(err)
   326  		}
   327  		t.Log("nil", "=>", value)
   328  	}
   329  
   330  	{
   331  		value, err := encoder.Decode([]byte{1, 2, 3, 4})
   332  		if err != nil {
   333  			t.Fatal(err)
   334  		}
   335  		t.Log("nil", "=>", value)
   336  	}
   337  }
   338  
   339  type objectType struct {
   340  	Name string `json:"1"`
   341  	Age  int    `json:"2"`
   342  }
   343  
   344  type objectTypeEncoder[T objectType] struct {
   345  	kvstore.BaseObjectEncoder[T]
   346  }
   347  
   348  func (this *objectTypeEncoder[T]) EncodeField(value T, fieldName string) ([]byte, error) {
   349  	return nil, nil
   350  }
   351  
   352  func TestBaseObjectEncoder_Encode(t *testing.T) {
   353  	var encoder = &objectTypeEncoder[objectType]{}
   354  
   355  	{
   356  		data, err := encoder.Encode(objectType{
   357  			Name: "lily",
   358  			Age:  20,
   359  		})
   360  		if err != nil {
   361  			t.Fatal(err)
   362  		}
   363  		t.Log("encoded:", string(data))
   364  	}
   365  
   366  	{
   367  		value, err := encoder.Decode([]byte(`{"1":"lily","2":20}`))
   368  		if err != nil {
   369  			t.Fatal(err)
   370  		}
   371  		t.Logf("decoded: %+v", value)
   372  	}
   373  }
   374  
   375  type objectType2 struct {
   376  	Name string `json:"1"`
   377  	Age  int    `json:"2"`
   378  }
   379  
   380  type objectTypeEncoder2[T interface{ *objectType2 }] struct {
   381  	kvstore.BaseObjectEncoder[T]
   382  }
   383  
   384  func (this *objectTypeEncoder2[T]) EncodeField(value T, fieldName string) ([]byte, error) {
   385  	switch fieldName {
   386  	case "Name":
   387  		return []byte(any(value).(*objectType2).Name), nil
   388  	}
   389  	return nil, nil
   390  }
   391  
   392  func TestBaseObjectEncoder_Encode2(t *testing.T) {
   393  	var encoder = &objectTypeEncoder2[*objectType2]{}
   394  
   395  	{
   396  		data, err := encoder.Encode(&objectType2{
   397  			Name: "lily",
   398  			Age:  20,
   399  		})
   400  		if err != nil {
   401  			t.Fatal(err)
   402  		}
   403  		t.Log("encoded:", string(data))
   404  	}
   405  
   406  	{
   407  		value, err := encoder.Decode([]byte(`{"1":"lily","2":20}`))
   408  		if err != nil {
   409  			t.Fatal(err)
   410  		}
   411  		t.Logf("decoded: %+v", value)
   412  	}
   413  
   414  	{
   415  		field, err := encoder.EncodeField(&objectType2{
   416  			Name: "lily",
   417  			Age:  20,
   418  		}, "Name")
   419  		if err != nil {
   420  			t.Fatal(err)
   421  		}
   422  		t.Log("encoded field:", string(field))
   423  	}
   424  }
   425  
   426  func BenchmarkStringValueEncoder_Encode(b *testing.B) {
   427  	for i := 0; i < b.N; i++ {
   428  		var encoder = kvstore.NewStringValueEncoder[string]()
   429  		data, err := encoder.Encode("1234567890")
   430  		if err != nil {
   431  			b.Fatal(err)
   432  		}
   433  		v, err := encoder.Decode(data)
   434  		if err != nil {
   435  			b.Fatal(err)
   436  		}
   437  		_ = v
   438  	}
   439  }
   440  
   441  func BenchmarkIntValueEncoder_Encode(b *testing.B) {
   442  	for i := 0; i < b.N; i++ {
   443  		var encoder = kvstore.NewIntValueEncoder[int64]()
   444  		data, err := encoder.Encode(1234567890)
   445  		if err != nil {
   446  			b.Fatal(err)
   447  		}
   448  		v, err := encoder.Decode(data)
   449  		if err != nil {
   450  			b.Fatal(err)
   451  		}
   452  		_ = v
   453  	}
   454  }
   455  
   456  func BenchmarkUIntValueEncoder_Encode(b *testing.B) {
   457  	for i := 0; i < b.N; i++ {
   458  		var encoder = kvstore.NewIntValueEncoder[uint64]()
   459  		data, err := encoder.Encode(1234567890)
   460  		if err != nil {
   461  			b.Fatal(err)
   462  		}
   463  		v, err := encoder.Decode(data)
   464  		if err != nil {
   465  			b.Fatal(err)
   466  		}
   467  		_ = v
   468  	}
   469  }