main.go

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"reflect"
)

type Element struct {
	Name   string
	Number int
}

type SubStruct struct {
	SubName string
}

type Config struct {
	S  string
	B  bool
	I  int
	SP *string
	BP *bool

	StructList []Element

	SubStruct  SubStruct
	SubStructP *SubStruct
}

func die(err error) {
	fmt.Printf("ERROR: %+v\n", err)
	os.Exit(1)
}

func main() {
	c := &Config{}
	cv := reflect.ValueOf(c)

	err := fillStruct(cv)
	if err != nil {
		die(err)
	}

	j, err := json.MarshalIndent(c, "", "  ")
	if err != nil {
		die(err)
	}
	fmt.Println(string(j))
}

func fillStruct(v reflect.Value) error {
	structType := v.Type()
	if v.Kind() == reflect.Pointer {
		structType = structType.Elem()
		v = v.Elem()
	}
	for idx := range structType.NumField() {
		structField := structType.Field(idx)
		newValue := reflect.New(structField.Type).Elem()
		newValue = setRandValue(newValue)
		fieldValue := v.Field(idx)
		fieldValue.Set(newValue)
	}

	return nil
}

func setRandValue(v reflect.Value) reflect.Value {
	switch v.Kind() {
	case reflect.String:
		v.SetString("foo")
	case reflect.Bool:
		v.SetBool(true)
	case reflect.Int:
		v.SetInt(13)
	case reflect.Slice:
		elemType := v.Type().Elem()
		for range 3 {
			// add 3 elements
			elemValue := reflect.New(elemType).Elem()
			setRandValue(elemValue)
			v = reflect.Append(v, elemValue)
		}
	case reflect.Struct:
		// back to the top
		fillStruct(v)
	case reflect.Pointer:
		// deref and descend
		elemType := v.Type().Elem()

		cvp := reflect.New(elemType)
		cv := cvp.Elem()
		cv = setRandValue(cv)
		v = cvp
	default:
		fmt.Printf("Unhandled type: %#v (%#v)\n", v.Kind(), v)
	}
	return v
}