Golang chk.String函数代码示例

func Test_ind01(tst *testing.T) {

	//verbose()
	chk.PrintTitle("ind01. representation and copying")

	rnd.Init(0)

	nbases := 3
	A := get_individual(0, nbases)
	B := A.GetCopy()
	chk.Scalar(tst, "ova0", 1e-17, B.Ovas[0], 123)
	chk.Scalar(tst, "ova1", 1e-17, B.Ovas[1], 345)
	chk.Scalar(tst, "oor0", 1e-17, B.Oors[0], 10)
	chk.Scalar(tst, "oor1", 1e-17, B.Oors[1], 20)
	chk.Scalar(tst, "oor2", 1e-17, B.Oors[2], 30)

	fmts := map[string][]string{"int": {" %d"}, "flt": {" %.1f"}, "str": {" %q"}, "key": {" %x"}, "byt": {" %q"}, "fun": {" %q"}}

	oA := A.Output(fmts, false)
	oB := B.Output(fmts, false)
	io.Pfyel("\n%v\n", oA)
	io.Pfyel("%v\n\n", oB)
	chk.String(tst, oA, " 1 20 300 4.4 5.5 666.0 \"abc\" \"b\" \"c\" 53 47 41 \"ABC\" \"DEF\" \"GHI\" \"f0\" \"f1\" \"f2\"")
	chk.String(tst, oB, " 1 20 300 4.4 5.5 666.0 \"abc\" \"b\" \"c\" 53 47 41 \"ABC\" \"DEF\" \"GHI\" \"f0\" \"f1\" \"f2\"")

	A.SetFloat(1, 33)
	A.SetFloat(2, 88)
	oA = A.Output(fmts, false)
	io.Pfyel("\n%v\n", oA)
	chk.String(tst, oA, " 1 20 300 4.4 33.0 88.0 \"abc\" \"b\" \"c\" 53 47 41 \"ABC\" \"DEF\" \"GHI\" \"f0\" \"f1\" \"f2\"")
}

func Test_parsing03(tst *testing.T) {

	//verbose()
	chk.PrintTitle("parsing03")

	keys := []string{"ux", "uy", "uz", "pl", "sl"}
	k1, k2, k3 := []string{"ex1", "ex2"}, []string{"more1", "more2"}, []string{"a", "b", "c"}
	allkeys := JoinKeys4(keys, k1, k2, k3, "")
	Pfpink("allkeys = %q\n", allkeys)
	chk.String(tst, allkeys, "ux uy uz pl sl ex1 ex2 more1 more2 a b c")

	allkeys = JoinKeys4(keys, k1, k2, k3, ",")
	Pfpink("allkeys = %q\n", allkeys)
	chk.String(tst, allkeys, "ux uy uz pl sl, ex1 ex2, more1 more2, a b c")

	r0, r1, r2, r3 := SplitKeys4(allkeys)
	Pfblue2("r0 = %v\n", r0)
	Pfblue2("r1 = %v\n", r1)
	Pfblue2("r2 = %v\n", r2)
	Pfblue2("r3 = %v\n", r3)
	chk.Strings(tst, "r0", r0, keys)
	chk.Strings(tst, "r1", r1, k1)
	chk.Strings(tst, "r2", r2, k2)
	chk.Strings(tst, "r3", r3, k3)

	allkeys = JoinKeys4(keys, []string{}, k2, []string{}, ",")
	Pfpink("allkeys = %q\n", allkeys)
	chk.String(tst, allkeys, "ux uy uz pl sl,, more1 more2,")
}

func Test_args01(tst *testing.T) {

	//verbose()
	chk.PrintTitle("args01")

	fn, fnk := ArgToFilename(0, "simulation", ".sim", true)
	Pforan("fn  = %v\n", fn)
	Pforan("fnk = %v\n", fnk)
	chk.String(tst, fn, "simulation.sim")
	chk.String(tst, fnk, "simulation")

	resFloat := ArgToFloat(1, 456)
	chk.Scalar(tst, "456", 1e-17, resFloat, 456)

	resInt := ArgToInt(1, 123)
	if resInt != 123 {
		tst.Errorf("test failed: resInt != 123\n")
		return
	}

	resBool := ArgToBool(1, true)
	if !resBool {
		tst.Errorf("test failed: resBool != true\n")
		return
	}

	resString := ArgToString(1, "myname")
	chk.String(tst, resString, "myname")

	tab := ArgsTable(
		"1 2 3 INPUT PARAMETERS 3 2 1",
		"first argument", "first", true,
		"second argument", "second", "string",
		"third argument", "third", 123,
		"fourth argument", "fourth", 666.0,
	)

	Pf("\n%v\n", tab)

	chk.String(tst, tab,
		`   1 2 3 INPUT PARAMETERS 3 2 1
===================================
     description      key     value
-----------------------------------
  first argument    first      true
 second argument   second    string
  third argument    third       123
 fourth argument   fourth       666
===================================
`)
}

func Test_parsing02(tst *testing.T) {

	//verbose()
	chk.PrintTitle("parsing02")

	keys := []string{"ux", "uy", "uz", "pl", "sl"}
	skeys := JoinKeys(keys)
	kkeys := SplitKeys(skeys)
	Pforan("keys  = %+v\n", keys)
	Pforan("skeys = %q\n", skeys)
	Pforan("kkeys = %+v\n", kkeys)
	chk.Strings(tst, "keys", keys, kkeys)

	k1, k2 := []string{"ex1", "ex2"}, []string{"more1", "more2"}
	allkeys := JoinKeys3(keys, k1, k2, "")
	Pfpink("allkeys = %q\n", allkeys)
	chk.String(tst, allkeys, "ux uy uz pl sl ex1 ex2 more1 more2")

	allkeys = JoinKeys3(keys, k1, k2, ",")
	Pfpink("allkeys = %q\n", allkeys)
	chk.String(tst, allkeys, "ux uy uz pl sl, ex1 ex2, more1 more2")

	r0, r1, r2 := SplitKeys3(allkeys)
	Pfblue2("r0 = %v\n", r0)
	Pfblue2("r1 = %v\n", r1)
	Pfblue2("r2 = %v\n", r2)
	chk.Strings(tst, "r0", r0, keys)
	chk.Strings(tst, "r1", r1, k1)
	chk.Strings(tst, "r2", r2, k2)

	allkeys = JoinKeys3(keys, []string{}, k2, ",")
	Pfpink("allkeys = %q\n", allkeys)
	chk.String(tst, allkeys, "ux uy uz pl sl,, more1 more2")

	allkeys = JoinKeys3(keys, []string{}, []string{}, ",")
	Pfpink("allkeys = %q\n", allkeys)
	chk.String(tst, allkeys, "ux uy uz pl sl,,")

	allkeys = JoinKeys3([]string{}, k1, k2, ",")
	Pfpink("allkeys = %q\n", allkeys)
	chk.String(tst, allkeys, ", ex1 ex2, more1 more2")

	r0, r1, r2 = SplitKeys3("a ,b c,")
	Pfblue2("r0 = %v\n", r0)
	Pfblue2("r1 = %v\n", r1)
	Pfblue2("r2 = %v\n", r2)
	chk.Strings(tst, "r0", r0, []string{"a"})
	chk.Strings(tst, "r1", r1, []string{"b", "c"})
	chk.Strings(tst, "r2", r2, []string{})
}

func Test_parsing05(tst *testing.T) {

	//verbose()
	chk.PrintTitle("parsing05. split by spaces quoted")

	str := " arg1 arg2 '   hello    world' '' \"  another hello world   \" "
	res := SplitSpacesQuoted(str)
	Pforan("res = %q\n", res)
	chk.String(tst, res[0], "arg1")
	chk.String(tst, res[1], "arg2")
	chk.String(tst, res[2], "'   hello    world'")
	chk.String(tst, res[3], "''")
	chk.String(tst, res[4], "\"  another hello world   \"")
}

func checkinput(tst *testing.T, m *Mesh, nverts, ncells int, X [][]float64, vtags, ctags, parts []int, types []string, V [][]int, etags, ftags [][]int) {
	if len(m.Verts) != nverts {
		tst.Errorf("nverts is incorrect: %d != %d", len(m.Verts), nverts)
		return
	}
	if len(m.Cells) != ncells {
		tst.Errorf("ncells is incorrect: %d != %d", len(m.Cells), ncells)
		return
	}
	io.Pfyel("\nvertices:\n")
	for i, v := range m.Verts {
		io.Pf("%+v\n", v)
		chk.Vector(tst, io.Sf("vertex %2d: X", v.Id), 1e-15, v.X, X[v.Id])
		if v.Tag != vtags[i] {
			tst.Errorf("vtag is incorrect: %d != %d", v.Tag, vtags[i])
			return
		}
	}
	io.Pfyel("\ncells:\n")
	for i, c := range m.Cells {
		io.Pf("%+v\n", c)
		if c.Tag != ctags[i] {
			tst.Errorf("ctag is incorrect: %d != %d", c.Tag, ctags[i])
			return
		}
		if c.Part != parts[i] {
			tst.Errorf("part is incorrect: %d != %d", c.Part, parts[i])
			return
		}
		chk.String(tst, types[i], c.Type)
		chk.Ints(tst, io.Sf("cell %2d : V", c.Id), c.V, V[c.Id])
		chk.Ints(tst, io.Sf("cell %2d : edgetags", c.Id), c.EdgeTags, etags[c.Id])
	}
}

func Test_basic02(tst *testing.T) {

	//verbose()
	chk.PrintTitle("basic02")

	res := IntSf("%4d", []int{1, 2, 3}) // note that an inner space is always added
	Pforan("res = %q\n", res)
	chk.String(tst, res, "   1    2    3")

	res = DblSf("%8.3f", []float64{1, 2, 3}) // note that an inner space is always added
	Pforan("res = %q\n", res)
	chk.String(tst, res, "   1.000    2.000    3.000")

	res = StrSf("%s", []string{"a", "b", "c"}) // note that an inner space is always added
	Pforan("res = %q\n", res)
	chk.String(tst, res, "a b c")
}

func Test_parsing06(tst *testing.T) {

	//verbose()
	chk.PrintTitle("parsing06. extract within brackets")

	str := "(arg1, (arg2.1, arg2.2),  arg3, arg4, (arg5.1,arg5.2,  arg5.3 ) )"
	res := SplitWithinParentheses(str)
	Pforan("%q\n", str)
	for _, r := range res {
		Pf("%q\n", r)
	}
	chk.String(tst, res[0], "arg1")
	chk.String(tst, res[1], "arg2.1  arg2.2")
	chk.String(tst, res[2], "arg3")
	chk.String(tst, res[3], "arg4")
	chk.String(tst, res[4], "arg5.1 arg5.2   arg5.3 ")
}

func Test_draw02(tst *testing.T) {

	chk.PrintTitle("draw02")

	d := Fmt{"red", "o", "--", 1.2, -1, "gofem", 2}
	l := d.GetArgs("clip_on=0")
	io.Pforan("l = %q\n", l)
	chk.String(tst, l, "clip_on=0,color='red',marker='o',ls='--',lw=1.2,label='gofem',markevery=2")
}

func Test_ind02(tst *testing.T) {

	//verbose()
	chk.PrintTitle("ind02. copy into")

	rnd.Init(0)

	nbases := 1
	A := get_individual(0, nbases)
	B := get_individual(1, nbases)

	fmts := map[string][]string{
		"int": {"%2d", "%4d", "%5d"}, // ints
		"flt": {"%6g", "%6g", "%5g"}, // floats
		"str": {"%4s", "%2s", "%2s"}, // strings
		"key": {"%3x", "%3x", "%3x"}, // keys
		"byt": {"%4s", "%4s", "%4s"}, // bytes
		"fun": {"%3s", "%3s", "%3s"}, // funcs
	}
	io.Pfpink("A = %v\n", A.Output(fmts, false))
	io.Pfcyan("B = %v\n", B.Output(fmts, false))

	var ops OpsData
	ops.SetDefault()
	ops.Pc = 1.0
	ops.Cuts = []int{1, 2}
	ops.Xrange = [][]float64{{0, 1}, {-20, 20}, {-300, 300}}

	a := A.GetCopy()
	b := A.GetCopy()
	IndCrossover(a, b, A, B, 0, &ops)

	io.Pforan("a = %v\n", a.Output(fmts, false))
	io.Pfblue2("b = %v\n", b.Output(fmts, false))

	chk.Ints(tst, "a.Ints   ", a.Ints, []int{1, -20, 300})
	chk.Ints(tst, "b.Ints   ", b.Ints, []int{-1, 20, -300})
	chk.Strings(tst, "a.Strings", a.Strings, []string{"abc", "Y", "c"})
	chk.Strings(tst, "b.Strings", b.Strings, []string{"X", "b", "Z"})
	// TODO: add other tests here
	io.Pf("\n")

	x := get_individual(0, nbases)
	x.Ovas = []float64{0, 0}
	x.Oors = []float64{0, 0, 0}
	io.Pfblue2("x = %v\n", x.Output(fmts, false))
	B.CopyInto(x)

	chk.Scalar(tst, "ova0", 1e-17, x.Ovas[0], 200)
	chk.Scalar(tst, "ova1", 1e-17, x.Ovas[1], 100)
	chk.Scalar(tst, "oor0", 1e-17, x.Oors[0], 15)
	chk.Scalar(tst, "oor1", 1e-17, x.Oors[1], 25)
	chk.Scalar(tst, "oor2", 1e-17, x.Oors[2], 35)

	io.Pforan("x = %v\n", x.Output(fmts, false))
	chk.String(tst, x.Output(fmts, false), B.Output(fmts, false))
}

func Test_texreport01(tst *testing.T) {

	//verbose()
	chk.PrintTitle("texreport01")

	l1 := TexNum("", 123.456, true)
	l2 := TexNum("", 123.456e-8, true)
	l3 := TexNum("%.1e", 123.456e+8, true)
	l4 := TexNum("%.2e", 123.456e-8, false)
	Pforan("l1 = %v\n", l1)
	Pforan("l2 = %v\n", l2)
	Pforan("l3 = %v\n", l3)
	Pforan("l4 = %v\n", l4)
	chk.String(tst, l1, "123.456")
	chk.String(tst, l2, "1.23456\\cdot 10^{-6}")
	chk.String(tst, l3, "1.2\\cdot 10^{10}")
	chk.String(tst, l4, "1.23e-06")
}

func Test_parsing04(tst *testing.T) {

	//verbose()
	chk.PrintTitle("parsing04")

	keys := []string{"ux", "uy", "uz"}
	skeys := JoinKeysPre("R", keys)
	Pforan("keys  = %+v\n", keys)
	Pforan("skeys = %q\n", skeys)
	chk.String(tst, skeys, "Rux Ruy Ruz")
}

func Test_args01(tst *testing.T) {

	//verbose()
	chk.PrintTitle("args01")

	fn, fnk := ArgToFilename(0, "simulation", ".sim", true)
	Pforan("fn  = %v\n", fn)
	Pforan("fnk = %v\n", fnk)
	chk.String(tst, fn, "simulation.sim")
	chk.String(tst, fnk, "simulation")

	resFloat := ArgToFloat(1, 456)
	chk.Scalar(tst, "456", 1e-17, resFloat, 456)

	resInt := ArgToInt(1, 123)
	if resInt != 123 {
		tst.Errorf("test failed: resInt != 123\n")
		return
	}

	resBool := ArgToBool(1, true)
	if !resBool {
		tst.Errorf("test failed: resBool != true\n")
		return
	}

	resString := ArgToString(1, "myname")
	chk.String(tst, resString, "myname")

	Pf("\n%v\n", ArgsTable(
		"first argument", "first", true,
		"second argument", "second", "string",
		"third argument", "third", 123,
		"fourth argument", "fourth", 666.0,
	))
}

func Test_fileIO4(tst *testing.T) {

	//verbose()
	chk.PrintTitle("fileIO4")

	theline := "Hello World !!!"
	WriteFileSD("/tmp/gosl", "filestring.txt", theline)

	f, err := OpenFileR("/tmp/gosl/filestring.txt")
	if err != nil {
		chk.Panic("%v", err)
	}

	ReadLinesFile(f, func(idx int, line string) (stop bool) {
		Pforan("line = %v\n", line)
		chk.String(tst, line, theline)
		return
	})
}

func Test_encoder01(tst *testing.T) {

	//verbose()
	chk.PrintTitle("encoder01")

	// writer and encoder
	var w test_writer
	enc := GetEncoder(&w, "json")
	s_in := test_struct{A: 1, B: 2}
	enc.Encode(&s_in)
	io.Pforan("w = %q\n", string(w))
	chk.String(tst, "{\"A\":1,\"B\":2}\n", string(w))

	// reader and decoder
	var r test_reader
	dec := GetDecoder(&r, "json")
	var s_out test_struct
	dec.Decode(&s_out)
	io.Pforan("r = %v\n", r)
	// TODO: implement test here
}