tomltestgen: add toml-test unit test generation command (#610)
Tests are hidden behind a "testsuite" build tag for now since many tests are failing. Use `go test -tags testsuite` to activate. Use `go generate` to regenerate toml_testgen_test.go. Co-authored-by: Thomas Pelletier <thomas@pelletier.codes>
This commit is contained in:
Cameron Moore
@@ -0,0 +1,224 @@
|
||||
// tomltestgen retrieves a given version of the language-agnostic TOML test suite in
|
||||
// https://github.com/BurntSushi/toml-test and generates go-toml unit tests.
|
||||
//
|
||||
// Within the go-toml package, run `go generate`. Otherwise, use:
|
||||
//
|
||||
// go run github.com/pelletier/go-toml/cmd/tomltestgen -o toml_testgen_test.go
|
||||
package main
|
||||
|
||||
import (
|
||||
"archive/zip"
|
||||
"bytes"
|
||||
"flag"
|
||||
"fmt"
|
||||
"go/format"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"text/template"
|
||||
"time"
|
||||
)
|
||||
|
||||
type invalid struct {
|
||||
Name string
|
||||
Input string
|
||||
}
|
||||
|
||||
type valid struct {
|
||||
Name string
|
||||
Input string
|
||||
JsonRef string
|
||||
}
|
||||
|
||||
type testsCollection struct {
|
||||
Ref string
|
||||
Timestamp string
|
||||
Invalid []invalid
|
||||
Valid []valid
|
||||
Count int
|
||||
}
|
||||
|
||||
const srcTemplate = "// +build testsuite\n\n" +
|
||||
"// Generated by tomltestgen for toml-test ref {{.Ref}} on {{.Timestamp}}\n" +
|
||||
"package toml_test\n" +
|
||||
" import (\n" +
|
||||
" \"testing\"\n" +
|
||||
")\n" +
|
||||
|
||||
"{{range .Invalid}}\n" +
|
||||
"func TestTOMLTest_Invalid_{{.Name}}(t *testing.T) {\n" +
|
||||
" input := {{.Input|gostr}}\n" +
|
||||
" testgenInvalid(t, input)\n" +
|
||||
"}\n" +
|
||||
"{{end}}\n" +
|
||||
"\n" +
|
||||
"{{range .Valid}}\n" +
|
||||
"func TestTOMLTest_Valid_{{.Name}}(t *testing.T) {\n" +
|
||||
" input := {{.Input|gostr}}\n" +
|
||||
" jsonRef := {{.JsonRef|gostr}}\n" +
|
||||
" testgenValid(t, input, jsonRef)\n" +
|
||||
"}\n" +
|
||||
"{{end}}\n"
|
||||
|
||||
func downloadTmpFile(url string) string {
|
||||
log.Println("starting to download file from", url)
|
||||
resp, err := http.Get(url)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
tmpfile, err := ioutil.TempFile("", "toml-test-*.zip")
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer tmpfile.Close()
|
||||
|
||||
copiedLen, err := io.Copy(tmpfile, resp.Body)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
if resp.ContentLength > 0 && copiedLen != resp.ContentLength {
|
||||
panic(fmt.Errorf("copied %d bytes, request body had %d", copiedLen, resp.ContentLength))
|
||||
}
|
||||
return tmpfile.Name()
|
||||
}
|
||||
|
||||
func kebabToCamel(kebab string) string {
|
||||
camel := ""
|
||||
nextUpper := true
|
||||
for _, c := range kebab {
|
||||
if nextUpper {
|
||||
camel += strings.ToUpper(string(c))
|
||||
nextUpper = false
|
||||
} else if c == '-' {
|
||||
nextUpper = true
|
||||
} else if c == '/' {
|
||||
nextUpper = true
|
||||
camel += "_"
|
||||
} else {
|
||||
camel += string(c)
|
||||
}
|
||||
}
|
||||
return camel
|
||||
}
|
||||
|
||||
func readFileFromZip(f *zip.File) string {
|
||||
reader, err := f.Open()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer reader.Close()
|
||||
bytes, err := ioutil.ReadAll(reader)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return string(bytes)
|
||||
}
|
||||
|
||||
func templateGoStr(input string) string {
|
||||
return strconv.Quote(input)
|
||||
}
|
||||
|
||||
var (
|
||||
ref = flag.String("r", "master", "git reference")
|
||||
out = flag.String("o", "", "output file")
|
||||
)
|
||||
|
||||
func usage() {
|
||||
_, _ = fmt.Fprintf(os.Stderr, "usage: tomltestgen [flags]\n")
|
||||
flag.PrintDefaults()
|
||||
}
|
||||
|
||||
func main() {
|
||||
flag.Usage = usage
|
||||
flag.Parse()
|
||||
|
||||
url := "https://codeload.github.com/BurntSushi/toml-test/zip/" + *ref
|
||||
resultFile := downloadTmpFile(url)
|
||||
defer os.Remove(resultFile)
|
||||
log.Println("file written to", resultFile)
|
||||
|
||||
zipReader, err := zip.OpenReader(resultFile)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
defer zipReader.Close()
|
||||
|
||||
collection := testsCollection{
|
||||
Ref: *ref,
|
||||
Timestamp: time.Now().Format(time.RFC3339),
|
||||
}
|
||||
|
||||
zipFilesMap := map[string]*zip.File{}
|
||||
|
||||
for _, f := range zipReader.File {
|
||||
zipFilesMap[f.Name] = f
|
||||
}
|
||||
|
||||
testFileRegexp := regexp.MustCompile(`([^/]+/tests/(valid|invalid)/(.+))\.(toml)`)
|
||||
for _, f := range zipReader.File {
|
||||
groups := testFileRegexp.FindStringSubmatch(f.Name)
|
||||
if len(groups) > 0 {
|
||||
name := kebabToCamel(groups[3])
|
||||
testType := groups[2]
|
||||
|
||||
log.Printf("> [%s] %s\n", testType, name)
|
||||
|
||||
tomlContent := readFileFromZip(f)
|
||||
|
||||
switch testType {
|
||||
case "invalid":
|
||||
collection.Invalid = append(collection.Invalid, invalid{
|
||||
Name: name,
|
||||
Input: tomlContent,
|
||||
})
|
||||
collection.Count++
|
||||
case "valid":
|
||||
baseFilePath := groups[1]
|
||||
jsonFilePath := baseFilePath + ".json"
|
||||
jsonContent := readFileFromZip(zipFilesMap[jsonFilePath])
|
||||
|
||||
collection.Valid = append(collection.Valid, valid{
|
||||
Name: name,
|
||||
Input: tomlContent,
|
||||
JsonRef: jsonContent,
|
||||
})
|
||||
collection.Count++
|
||||
default:
|
||||
panic(fmt.Sprintf("unknown test type: %s", testType))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
log.Printf("Collected %d tests from toml-test\n", collection.Count)
|
||||
|
||||
funcMap := template.FuncMap{
|
||||
"gostr": templateGoStr,
|
||||
}
|
||||
t := template.Must(template.New("src").Funcs(funcMap).Parse(srcTemplate))
|
||||
buf := new(bytes.Buffer)
|
||||
err = t.Execute(buf, collection)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
outputBytes, err := format.Source(buf.Bytes())
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
if *out == "" {
|
||||
fmt.Println(string(outputBytes))
|
||||
return
|
||||
}
|
||||
|
||||
err = os.WriteFile(*out, outputBytes, 0644)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
package testsuite
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
"time"
|
||||
|
||||
"github.com/pelletier/go-toml/v2"
|
||||
)
|
||||
|
||||
// addTag adds JSON tags to a data structure as expected by toml-test.
|
||||
func addTag(key string, tomlData interface{}) interface{} {
|
||||
// Switch on the data type.
|
||||
switch orig := tomlData.(type) {
|
||||
default:
|
||||
//return map[string]interface{}{}
|
||||
panic(fmt.Sprintf("Unknown type: %T", tomlData))
|
||||
|
||||
// A table: we don't need to add any tags, just recurse for every table
|
||||
// entry.
|
||||
case map[string]interface{}:
|
||||
typed := make(map[string]interface{}, len(orig))
|
||||
for k, v := range orig {
|
||||
typed[k] = addTag(k, v)
|
||||
}
|
||||
return typed
|
||||
|
||||
// An array: we don't need to add any tags, just recurse for every table
|
||||
// entry.
|
||||
case []map[string]interface{}:
|
||||
typed := make([]map[string]interface{}, len(orig))
|
||||
for i, v := range orig {
|
||||
typed[i] = addTag("", v).(map[string]interface{})
|
||||
}
|
||||
return typed
|
||||
case []interface{}:
|
||||
typed := make([]interface{}, len(orig))
|
||||
for i, v := range orig {
|
||||
typed[i] = addTag("", v)
|
||||
}
|
||||
return typed
|
||||
|
||||
// Datetime: tag as datetime.
|
||||
case toml.LocalTime:
|
||||
return tag("time-local", orig.String())
|
||||
case toml.LocalDate:
|
||||
return tag("date-local", orig.String())
|
||||
case toml.LocalDateTime:
|
||||
return tag("datetime-local", orig.String())
|
||||
case time.Time:
|
||||
return tag("datetime", orig.Format("2006-01-02T15:04:05.999999999Z07:00"))
|
||||
|
||||
// Tag primitive values: bool, string, int, and float64.
|
||||
case bool:
|
||||
return tag("bool", fmt.Sprintf("%v", orig))
|
||||
case string:
|
||||
return tag("string", orig)
|
||||
case int64:
|
||||
return tag("integer", fmt.Sprintf("%d", orig))
|
||||
case float64:
|
||||
// Special case for nan since NaN == NaN is false.
|
||||
if math.IsNaN(orig) {
|
||||
return tag("float", "nan")
|
||||
}
|
||||
return tag("float", fmt.Sprintf("%v", orig))
|
||||
}
|
||||
}
|
||||
|
||||
func tag(typeName string, data interface{}) map[string]interface{} {
|
||||
return map[string]interface{}{
|
||||
"type": typeName,
|
||||
"value": data,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
package testsuite
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
|
||||
"github.com/pelletier/go-toml/v2"
|
||||
)
|
||||
|
||||
type parser struct{}
|
||||
|
||||
func (p parser) Decode(input string) (output string, outputIsError bool, retErr error) {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
switch rr := r.(type) {
|
||||
case error:
|
||||
retErr = rr
|
||||
default:
|
||||
retErr = fmt.Errorf("%s", rr)
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
var v interface{}
|
||||
|
||||
if err := toml.Unmarshal([]byte(input), &v); err != nil {
|
||||
return err.Error(), true, nil
|
||||
}
|
||||
|
||||
j, err := json.MarshalIndent(addTag("", v), "", " ")
|
||||
if err != nil {
|
||||
return "", false, retErr
|
||||
}
|
||||
|
||||
return string(j), false, retErr
|
||||
}
|
||||
|
||||
func (p parser) Encode(input string) (output string, outputIsError bool, retErr error) {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
switch rr := r.(type) {
|
||||
case error:
|
||||
retErr = rr
|
||||
default:
|
||||
retErr = fmt.Errorf("%s", rr)
|
||||
}
|
||||
}
|
||||
}()
|
||||
|
||||
var tmp interface{}
|
||||
err := json.Unmarshal([]byte(input), &tmp)
|
||||
if err != nil {
|
||||
return "", false, err
|
||||
}
|
||||
|
||||
rm, err := rmTag(tmp)
|
||||
if err != nil {
|
||||
return err.Error(), true, retErr
|
||||
}
|
||||
|
||||
buf := new(bytes.Buffer)
|
||||
err = toml.NewEncoder(buf).Encode(rm)
|
||||
if err != nil {
|
||||
return err.Error(), true, retErr
|
||||
}
|
||||
|
||||
return buf.String(), false, retErr
|
||||
}
|
||||
+110
@@ -0,0 +1,110 @@
|
||||
package testsuite
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Remove JSON tags to a data structure as returned by toml-test.
|
||||
func rmTag(typedJson interface{}) (interface{}, error) {
|
||||
// Check if key is in the table m.
|
||||
in := func(key string, m map[string]interface{}) bool {
|
||||
_, ok := m[key]
|
||||
return ok
|
||||
}
|
||||
|
||||
// Switch on the data type.
|
||||
switch v := typedJson.(type) {
|
||||
|
||||
// Object: this can either be a TOML table or a primitive with tags.
|
||||
case map[string]interface{}:
|
||||
// This value represents a primitive: remove the tags and return just
|
||||
// the primitive value.
|
||||
if len(v) == 2 && in("type", v) && in("value", v) {
|
||||
ut, err := untag(v)
|
||||
if err != nil {
|
||||
return ut, fmt.Errorf("tag.Remove: %w", err)
|
||||
}
|
||||
return ut, nil
|
||||
}
|
||||
|
||||
// Table: remove tags on all children.
|
||||
m := make(map[string]interface{}, len(v))
|
||||
for k, v2 := range v {
|
||||
var err error
|
||||
m[k], err = rmTag(v2)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return m, nil
|
||||
|
||||
// Array: remove tags from all itenm.
|
||||
case []interface{}:
|
||||
a := make([]interface{}, len(v))
|
||||
for i := range v {
|
||||
var err error
|
||||
a[i], err = rmTag(v[i])
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return a, nil
|
||||
}
|
||||
|
||||
// The top level must be an object or array.
|
||||
return nil, fmt.Errorf("unrecognized JSON format '%T'", typedJson)
|
||||
}
|
||||
|
||||
// Return a primitive: read the "type" and convert the "value" to that.
|
||||
func untag(typed map[string]interface{}) (interface{}, error) {
|
||||
t := typed["type"].(string)
|
||||
v := typed["value"].(string)
|
||||
switch t {
|
||||
case "string":
|
||||
return v, nil
|
||||
case "integer":
|
||||
n, err := strconv.ParseInt(v, 10, 64)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("untag: %w", err)
|
||||
}
|
||||
return n, nil
|
||||
case "float":
|
||||
f, err := strconv.ParseFloat(v, 64)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("untag: %w", err)
|
||||
}
|
||||
return f, nil
|
||||
case "datetime":
|
||||
return parseTime(v, "2006-01-02T15:04:05.999999999Z07:00", false)
|
||||
case "datetime-local":
|
||||
return parseTime(v, "2006-01-02T15:04:05.999999999", true)
|
||||
case "date-local":
|
||||
return parseTime(v, "2006-01-02", true)
|
||||
case "time-local":
|
||||
return parseTime(v, "15:04:05.999999999", true)
|
||||
case "bool":
|
||||
switch v {
|
||||
case "true":
|
||||
return true, nil
|
||||
case "false":
|
||||
return false, nil
|
||||
}
|
||||
return nil, fmt.Errorf("untag: could not parse %q as a boolean", v)
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("untag: unrecognized tag type %q", t)
|
||||
}
|
||||
|
||||
func parseTime(v, format string, local bool) (t time.Time, err error) {
|
||||
if local {
|
||||
t, err = time.ParseInLocation(format, v, time.Local)
|
||||
} else {
|
||||
t, err = time.Parse(format, v)
|
||||
}
|
||||
if err != nil {
|
||||
return time.Time{}, fmt.Errorf("Could not parse %q as a datetime: %w", v, err)
|
||||
}
|
||||
return t, nil
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
// Package testsuite provides helper functions for interoperating with the
|
||||
// language-agnostic TOML test suite at github.com/BurntSushi/toml-test.
|
||||
package testsuite
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"log"
|
||||
"os"
|
||||
|
||||
"github.com/pelletier/go-toml/v2"
|
||||
)
|
||||
|
||||
// Marshal is a helpfer function for calling toml.Marshal
|
||||
//
|
||||
// Only needed to avoid package import loops.
|
||||
func Marshal(v interface{}) ([]byte, error) {
|
||||
return toml.Marshal(v)
|
||||
}
|
||||
|
||||
// Unmarshal is a helper function for calling toml.Unmarshal.
|
||||
//
|
||||
// Only needed to avoid package import loops.
|
||||
func Unmarshal(data []byte, v interface{}) error {
|
||||
return toml.Unmarshal(data, v)
|
||||
}
|
||||
|
||||
// ValueToTaggedJSON takes a data structure and returns the tagged JSON
|
||||
// representation.
|
||||
func ValueToTaggedJSON(doc interface{}) ([]byte, error) {
|
||||
return json.MarshalIndent(addTag("", doc), "", " ")
|
||||
}
|
||||
|
||||
// DecodeStdin is a helper function for the toml-test binary interface. TOML input
|
||||
// is read from STDIN and a resulting tagged JSON representation is written to
|
||||
// STDOUT.
|
||||
func DecodeStdin() {
|
||||
var decoded map[string]interface{}
|
||||
|
||||
if err := toml.NewDecoder(os.Stdin).Decode(&decoded); err != nil {
|
||||
log.Fatalf("Error decoding TOML: %s", err)
|
||||
}
|
||||
|
||||
j := json.NewEncoder(os.Stdout)
|
||||
j.SetIndent("", " ")
|
||||
if err := j.Encode(addTag("", decoded)); err != nil {
|
||||
log.Fatalf("Error encoding JSON: %s", err)
|
||||
}
|
||||
}
|
||||
+14
-121
@@ -1,14 +1,13 @@
|
||||
//go:generate go run ./cmd/tomltestgen/main.go -o toml_testgen_test.go
|
||||
|
||||
// This is a support file for toml_testgen_test.go
|
||||
package toml_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"strconv"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/pelletier/go-toml/v2"
|
||||
"github.com/pelletier/go-toml/v2/testsuite"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
@@ -17,10 +16,14 @@ func testgenInvalid(t *testing.T, input string) {
|
||||
t.Logf("Input TOML:\n%s", input)
|
||||
|
||||
doc := map[string]interface{}{}
|
||||
err := toml.Unmarshal([]byte(input), &doc)
|
||||
err := testsuite.Unmarshal([]byte(input), &doc)
|
||||
|
||||
if err == nil {
|
||||
t.Log(json.Marshal(doc))
|
||||
out, err := json.Marshal(doc)
|
||||
if err != nil {
|
||||
panic("could not marshal map to json")
|
||||
}
|
||||
t.Log("JSON output from unmarshal:", string(out))
|
||||
t.Fatalf("test did not fail")
|
||||
}
|
||||
}
|
||||
@@ -29,124 +32,14 @@ func testgenValid(t *testing.T, input string, jsonRef string) {
|
||||
t.Helper()
|
||||
t.Logf("Input TOML:\n%s", input)
|
||||
|
||||
doc := map[string]interface{}{}
|
||||
// TODO: change this to interface{}
|
||||
var doc map[string]interface{}
|
||||
|
||||
err := toml.Unmarshal([]byte(input), &doc)
|
||||
err := testsuite.Unmarshal([]byte(input), &doc)
|
||||
if err != nil {
|
||||
t.Fatalf("failed parsing toml: %s", err)
|
||||
}
|
||||
|
||||
refDoc := testgenBuildRefDoc(jsonRef)
|
||||
|
||||
require.Equal(t, refDoc, doc)
|
||||
|
||||
out, err := toml.Marshal(doc)
|
||||
j, err := testsuite.ValueToTaggedJSON(doc)
|
||||
require.NoError(t, err)
|
||||
|
||||
doc2 := map[string]interface{}{}
|
||||
err = toml.Unmarshal(out, &doc2)
|
||||
require.NoError(t, err)
|
||||
|
||||
require.Equal(t, refDoc, doc2)
|
||||
}
|
||||
|
||||
func testgenBuildRefDoc(jsonRef string) map[string]interface{} {
|
||||
descTree := map[string]interface{}{}
|
||||
|
||||
err := json.Unmarshal([]byte(jsonRef), &descTree)
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("reference doc should be valid JSON: %s", err))
|
||||
}
|
||||
|
||||
doc := testGenTranslateDesc(descTree)
|
||||
if doc == nil {
|
||||
return map[string]interface{}{}
|
||||
}
|
||||
|
||||
return doc.(map[string]interface{})
|
||||
}
|
||||
|
||||
//nolint:funlen,gocognit,cyclop
|
||||
func testGenTranslateDesc(input interface{}) interface{} {
|
||||
a, ok := input.([]interface{})
|
||||
if ok {
|
||||
xs := make([]interface{}, len(a))
|
||||
for i, v := range a {
|
||||
xs[i] = testGenTranslateDesc(v)
|
||||
}
|
||||
|
||||
return xs
|
||||
}
|
||||
|
||||
d, ok := input.(map[string]interface{})
|
||||
if !ok {
|
||||
panic(fmt.Sprintf("input should be valid map[string]: %v", input))
|
||||
}
|
||||
|
||||
var (
|
||||
dtype string
|
||||
dvalue interface{}
|
||||
)
|
||||
|
||||
//nolint:nestif
|
||||
if len(d) == 2 {
|
||||
dtypeiface, ok := d["type"]
|
||||
if ok {
|
||||
dvalue, ok = d["value"]
|
||||
if ok {
|
||||
dtype = dtypeiface.(string)
|
||||
|
||||
switch dtype {
|
||||
case "string":
|
||||
return dvalue.(string)
|
||||
case "float":
|
||||
v, err := strconv.ParseFloat(dvalue.(string), 64)
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("invalid float '%s': %s", dvalue, err))
|
||||
}
|
||||
|
||||
return v
|
||||
case "integer":
|
||||
v, err := strconv.ParseInt(dvalue.(string), 10, 64)
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("invalid int '%s': %s", dvalue, err))
|
||||
}
|
||||
|
||||
return v
|
||||
case "bool":
|
||||
return dvalue.(string) == "true"
|
||||
case "datetime":
|
||||
dt, err := time.Parse("2006-01-02T15:04:05Z", dvalue.(string))
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("invalid datetime '%s': %s", dvalue, err))
|
||||
}
|
||||
|
||||
return dt
|
||||
case "array":
|
||||
if dvalue == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
a := dvalue.([]interface{})
|
||||
|
||||
xs := make([]interface{}, len(a))
|
||||
|
||||
for i, v := range a {
|
||||
xs[i] = testGenTranslateDesc(v)
|
||||
}
|
||||
|
||||
return xs
|
||||
}
|
||||
|
||||
panic(fmt.Sprintf("unknown type: %s", dtype))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
dest := map[string]interface{}{}
|
||||
for k, v := range d {
|
||||
dest[k] = testGenTranslateDesc(v)
|
||||
}
|
||||
|
||||
return dest
|
||||
require.Equal(t, jsonRef, string(j)+"\n")
|
||||
}
|
||||
|
||||
+1296
-772
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user