value_test.go

package dxsvalue

import (
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"reflect"
	"testing"
	"time"
)

func TestDxValue_ForcePath(t *testing.T) {
	v := NewValueFrom(map[string]interface{}{
		"Name":   "不得闲",
		"Age":    33,
		"Weight": 102.34,
	}, true)
	fmt.Println(v.String())
	//v := NewValue(VT_Object)
	//v.SetKeyBool("a",true)
	v.ForcePath(VT_False, "a", "b")
	v.ForcePath(VT_String, "a", "b", "c").SetString("Asdfaf")

	fmt.Println(v.String())

	v.Reset(VT_Array)
	v.SetIndex(0, VT_String).SetString("asdfadf")
	v.SetIndexString(1, "234")
	v.SetIndex(2, VT_Object)
	v.SetIndexBool(3, true)
	fmt.Println(v.String())
	v.SetIndexString(3, "ASdf")
	fmt.Println(v.String())
	v1, _ := NewValueFromJson([]byte(`["asdfadf","234",{},"ASdf"]`), false, false)
	fmt.Println("结果 ", v1.String())
	v2 := v1.Clone(false)
	fmt.Println(v2.String())
	return
}

func TestParseJsonValue(t *testing.T) {
	str := `{"devices":[{"deviceId":"D1473116100pD0a0","services":[{"serviceId":"dtu_work","eventTime":"20221013T020110Z","data":"{\"En_Sec\":2,\"En_Min\":0,\"DTUID\":\"C0112022011300031\",\"BaPowSta\":0,\"En_Month\":10,\"DLALoadCur\":0.0,\"DLBLoadCur\":0.0,\"SLType\":2,\"GPS\":2,\"DYYXZ\":414,\"GCAmp\":0,\"LoadCur\":258.79,\"SENDTOPIC\":\"/v1/devices/C0112022011300031/datas\",\"CUSTOMERID\":\"D1473116100pD0a0\",\"USERNAME\":\"DE9E036C87D649AEB8CA4C672AA91D49\",\"En_Hour\":20,\"PWD\":\"sm[LwuF4:qx[2A8ogs83vTjb\",\"serviceId\":\"dtu_work\",\"EquTem\":29,\"Co_Seg\":2,\"CO_SCALE\":0,\"CSQ\":-59,\"GPSTime\":\"20221012200002\",\"GPSSwitchcnt\":1,\"dlpct\":100,\"En_Year\":2022,\"DLCLoadCur\":0.0,\"CDI1\":0,\"BaVol\":7254,\"En_Day\":12}"}]}]}`
	v, err := NewValueFromJson([]byte(str), false, false)
	if err != nil {
		fmt.Println("发生错误：", err)
	}
	v1 := v.ValueByName("devices")
	v1 = v1.ValueByIndex(0)
	v1 = v1.ValueByName("services").ValueByIndex(0)
	fmt.Println(v1.StringByName("data", ""))
}

func TestNewValue(t *testing.T) {
	v := NewValue(VT_Object)
	v.SetKeyString("Name", "不得闲")
	v.SetKeyInt("Age", 36)
	v.SetKeyFloat("Weight", 23.5)
	arrv := v.SetKey("Children", VT_Array)
	child := arrv.SetIndex(0, VT_Object)
	child.SetKeyString("Name", "Child1")
	child.SetKeyString("Sex", "boy")
	child.SetKeyInt("Age", 3)

	child = arrv.SetIndex(1, VT_Object)
	child.SetKeyString("Name", "Chil\"d2\"")
	child.SetKeyString("Sex", "girl")
	child.SetKeyInt("Age", 3)
	fmt.Println(string(Value2Json(v, JSE_OnlyAnsiChar, false, nil)))
	fmt.Println(string(Value2Json(v, JSE_AllEscape, false, nil)))
	fmt.Println(string(Value2Json(v, JSE_NoEscape, false, nil)))
}

type People struct {
	Name     string
	Age      int
	Weight   float32
	IsMen    bool
	Children []struct {
		Name string
		Sex  bool
		Age  int
	}
}

func TestDxValue_SetKeyvalue(t *testing.T) {
	value := NewObject(true)
	p := People{Name: `{"DxSoft":"gg"}`, Age: 20, Weight: 23.24, IsMen: true}
	value.SetKeyvalue("one", p, value.ValueCache())
	value.SetKeyvalue("two", &p, value.ValueCache())
	fmt.Println(string(Value2Json(value, JSE_OnlyAnsiChar, false, nil)))
	value.Clear()
	value.SetKeyString("Name", "DxSoft")

	fmt.Println(value.String())
}

type StdType struct {
	TimeOut time.Duration
	Age     string
}

func (tp StdType) EncodeToDxValue(dest *DxValue) {
	dest.Reset(VT_Object)
	dest.SetKeyCached("TimeOut", VT_String, dest.ValueCache()).SetString("1h3m24s")
	dest.SetKeyCached("Age", VT_String, dest.ValueCache()).SetString("3岁")
}

func (tp *StdType) DecodeFromDxValue(from *DxValue) {
	tp.Age = from.AsString("Age", tp.Age)
	timeout := from.AsString("TimeOut", "")
	if timeout != "" {
		duration, err := time.ParseDuration(timeout)
		if err == nil {
			tp.TimeOut = duration
		}
	}
}

func string2Duration(fvalue reflect.Value, value *DxValue) {
	switch value.DataType {
	case VT_Object:
	case VT_Int:
		fvalue.SetInt(value.Int())
	case VT_String:
		duration, err := time.ParseDuration(value.String())
		if err == nil {
			fvalue.SetInt(int64(duration))
		}
	}
}

func TestRegisterTypeMapFunc(t *testing.T) {
	TimeDurationPtrType := reflect.TypeOf((*time.Duration)(nil))
	TimeDurationType := TimeDurationPtrType.Elem()
	RegisterTypeMapFunc(TimeDurationType, string2Duration)
	RegisterTypeMapFunc(TimeDurationPtrType, string2Duration)

	var b StdType
	v := NewValue(VT_Object)
	v.SetKeyString("TimeOut", "1m32s")
	v.SetKeyString("Age", "32岁")
	v.ToStdValue(&b, true)
	fmt.Println(b)
}

func TestDxValueConverter(t *testing.T) {
	var b StdType
	v := NewValue(VT_Object)
	v.SetKeyString("TimeOut", "1m32s")
	v.SetKeyString("Age", "32岁")
	v.ToStdValue(&b, true)
	fmt.Println(b)
	v.SetValue(&b)
	fmt.Println(v.String())
}

func TestDxValue_ToStdValue(t *testing.T) {
	p := People{Name: `{"DxSoft":"gg"}`, Age: 20, Weight: 23.24, IsMen: true}
	var p2 People
	value := NewValueFrom(p, true)
	//fmt.Println(value.String())
	chldValue := value.SetKeyCached("Children", VT_Array, value.ValueCache())
	chldValue = chldValue.SetIndexCached(-1, VT_Object, value.ValueCache())
	chldValue.SetKeyCached("name", VT_String, value.ValueCache()).SetString("子节点")
	fmt.Println(value.String())
	value.ToStdValue(&p2, true)
	fmt.Println(p2)
}

func TestNewValueFromMsgPack(t *testing.T) {
	b, _ := ioutil.ReadFile(`DataProxy.config.msgPack`)
	v, err := NewValueFromMsgPack(b, false, false)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(v.String())

	b = formatValue(v, JSE_OnlyAnsiChar, false, nil, 0)
	fmt.Println(string(b))
	b = Value2MsgPack(v, nil)
	v1, err := NewValueFromMsgPack(b, false, false)
	fmt.Print(v1.String())
}

func TestDxValue_MergeWith(t *testing.T) {
	v1 := NewValue(VT_Object)
	rootv := v1.SetKey("People", VT_Object)
	rootv.SetKeyString("Name", "DxSoft")
	rootv.SetKeyString("Childs", "ChildName1")

	v2 := NewValue(VT_Object)
	rootv = v2.SetKey("People", VT_Object)
	rootv.SetKeyString("Sex", "Men")
	rootv.SetKeyInt("Age", 20)
	rootv.SetKeyString("Childs", "ChildName2")
	fmt.Println(v1.String())
	fmt.Println(v2.String())

	v1.MergeWith(v2, func(keypath string, oldv *DxValue, newv *DxValue) MergeOp {
		fmt.Println(keypath)
		if keypath == "People/Childs" {
			return MO_Replace
		}
		return MO_Normal
	})
	fmt.Println(v1.String())

	//数组合并
	varr1 := NewValue(VT_Array)
	varr1.SetIndexString(0, "Dxsoft")
	varr1.SetIndexString(1, "People")
	varr1.SetIndexInt(2, 20)

	varr2 := NewValue(VT_Array)
	varr2.SetIndexString(0, "Dxsoft")
	varr2.SetIndexString(1, "People")
	varr2.SetIndexInt(2, 40)

	varr1.MergeWith(varr2, nil)
	fmt.Println(varr1.String())
}

func TestDxValue_LoadFromJson(t *testing.T) {
	strBody := `
{
"LastUp\tdate":  "1899-12-30 00:00:00",
"result":true,
"Age":32,
"bb":"asdf"
}
`
	/*v1, _ := NewValueFromJson([]byte(strBody), false, true)
	fmt.Println(v1.String())*/
	value := NewObject(true)
	err := value.LoadFromJson([]byte(strBody), true)
	if err != nil {
		fmt.Println(err)
	}
	value.SetKeyTime("LastUpdate", time.Time{})
	fmt.Println(value.String())
	dst := Value2MsgPack(value, nil)
	value.Clear()
	if value.LoadFromMsgPack(dst, false) != nil {
		fmt.Println("sadfa")
	} else {
		fmt.Println(value.String())
	}
}

func Test_DecodeJson(t *testing.T) {
	f, err := os.Open("./DataProxy.config.json")
	if err != nil {
		return
	}
	v, err := DecodeJson(f)
	f.Close()
	if err != nil {
		fmt.Println("Decode错误")
		return
	}
	fmt.Println(v.String())

}

func TestDxValue_AsDateTime(t *testing.T) {
	rec := NewValue(VT_Object)
	rec.SetKeyString("url", "www.baidu.com")
	rec.SetKeyString("Host", "234")
	rec.SetKeyInt("state", 4)
	rec.SetKeyInt("FileSize", 20)
	rec.SetKeyTime("LastUpdate", time.Now())
	rec.SetKeyString("Content-Type", "zip")
	rec.SetKeyString("ContentEncoding", "br")

	pkg := NewValue(VT_Object)
	pkg.SetKeyString("Name", "Method")
	pkg.SetKeyInt("Type", 1) //1是方法
	pkg.SetKeyValue("Params", rec)

	bt := Value2MsgPack(pkg, nil)
	recv := NewValue(VT_Object)
	err := recv.LoadFromMsgPack(bt, false)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(recv.String())
	}

	rev, _ := NewValueFromMsgPackFile("d:/1.bin", true)
	fmt.Println(rev.String())
}

type delayReader struct {
	r io.Reader
}

func (r *delayReader) Read(p []byte) (n int, err error) {
	idx := 0
	n = 0
	rlen := 0
	plen := len(p)
	for {
		if idx+100 > plen {
			rlen, err = r.r.Read(p[idx:plen])
		} else {
			rlen, err = r.r.Read(p[idx : idx+100])
		}
		n += rlen
		if err != nil {
			return n, err
		}
		time.Sleep(time.Millisecond * 100)
		idx += 100
	}
}

func TestMsgPackReader_Decode(t *testing.T) {
	f, _ := os.Open("./DataProxy.config.msgPack")

	delay := delayReader{
		r: f,
	}
	packReader := NewMsgPackReader(&delay)

	v, err := packReader.Decode()
	f.Close()
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(v.String())
}

func TestDeepCopy(t *testing.T) {
	m := make(map[string]struct {
		Age  int
		Name string
	}, 32)
	m["sf"] = struct {
		Age  int
		Name string
	}{Age: 23, Name: "dxsoft"}
	m["gg"] = struct {
		Age  int
		Name string
	}{Age: 33, Name: "dxsoft1"}
	v := NewCacheValue(VT_Object)
	v.SetValue(m)
	fmt.Println(v.String())
}

type A struct {
	A string `json:"a"`
	B int
}

type B struct {
	CA string `msgpack:"a"`
	CB int
}

type PeopleInfo struct {
	Sex string
	Age int
}

type Authors struct {
	DxSoft PeopleInfo `json:"dxsoft"`
	Suiyu  PeopleInfo `json:"suiyunonghen"`
}

func TestDeepCopyTo(t *testing.T) {
	//struct->struct
	/*a := A{
		A: "sfasfd",
		B: 32,
	}
	b := B{}
	DeepCopyTo(a, &b)
	fmt.Println(b)*/

	/*mapSlice := make(map[int][]PeopleInfo, 3)
	mapSlice[1] = []PeopleInfo{
		{
			Sex: "男",
			Age: 32,
		},
		{
			Sex: "女",
			Age: 28,
		},
	}
	mapSlice2 := make(map[int][]interface{}, 3)
	DeepAssignTo(mapSlice, &mapSlice2)
	fmt.Println(mapSlice2)*/

	mapArr := make(map[string]PeopleInfo, 3)
	mapArr["dxsoft"] = PeopleInfo{
		Sex: "男",
		Age: 32,
	}
	mapArr["suiyunonghen"] = PeopleInfo{
		Sex: "男",
		Age: 34,
	}
	mapStruct := Authors{}
	//var mapStruct interface{}
	DeepAssignTo(mapArr, &mapStruct)
	fmt.Println(mapStruct)

	//[]int -> []interface{}
	a := []int{1, 23, 4}
	b := make([]interface{}, 0, 3)
	DeepAssignTo(a, &b)
	fmt.Println(b)

	aMap := make(map[string]map[string]int, 3)
	m1 := make(map[string]int, 3)
	m1["test"] = 2
	m1["gg"] = 3
	aMap["1"] = m1
	b1 := make(map[string]map[string]interface{}, 3)
	DeepAssignTo(aMap, &b1)
	fmt.Println(b1)

	/*bMap := make(map[string]A, 3)
	bMap["MapA"] = A{
		A: "name",
		B: 23,
	}
	bbMap := make(map[string]A, 3)
	DeepCopyTo(bMap, &bbMap)
	fmt.Println(bbMap)*/

	bMap := make(map[interface{}][]interface{}, 1)
	g := make([]interface{}, 0, 3)
	g = append(g, 234)
	g = append(g, 23)
	bMap["12"] = g
	d := make(map[interface{}][]int, 3)
	DeepAssignTo(bMap, &d)
	fmt.Println(d)

	/*a := A{
		A: "sfasfd",
		B: 32,
	}
	b := make(map[string]interface{}, 10)
	DeepCopyTo(a, &b)
	fmt.Println(b)*/
}

func TestBytesValue(t *testing.T) {
	str := `{"connect":"bb\u0026\u0029Parse"}`
	v, _ := NewValueFromJson([]byte(str), true, true)
	mb := v.StringByName("connect", "")
	fmt.Println(mb)
	fmt.Println(v.String())
}