lib/discovery/testdata/testdata.vdl.go

// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file was auto-generated by the vanadium vdl tool.
// Package: testdata

package testdata

import (
	"fmt"
	"v.io/v23/vdl"
	"v.io/x/ref/lib/discovery"
)

var _ = __VDLInit() // Must be first; see __VDLInit comments for details.

//////////////////////////////////////////////////
// Type definitions

// PackAddressTest represents a test case for PackAddress.
type PackAddressTest struct {
	// In is the addresses to pack.
	In []string
	// Packed is the expected packed output.
	Packed []byte
}

func (PackAddressTest) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/discovery/testdata.PackAddressTest"`
}) {
}

func (m *PackAddressTest) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var var4 bool
	if len(m.In) == 0 {
		var4 = true
	}
	if var4 {
		if err := fieldsTarget1.ZeroField("In"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("In")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			listTarget5, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.In))
			if err != nil {
				return err
			}
			for i, elem7 := range m.In {
				elemTarget6, err := listTarget5.StartElem(i)
				if err != nil {
					return err
				}
				if err := elemTarget6.FromString(string(elem7), tt.NonOptional().Field(0).Type.Elem()); err != nil {
					return err
				}
				if err := listTarget5.FinishElem(elemTarget6); err != nil {
					return err
				}
			}
			if err := fieldTarget3.FinishList(listTarget5); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var var10 bool
	if len(m.Packed) == 0 {
		var10 = true
	}
	if var10 {
		if err := fieldsTarget1.ZeroField("Packed"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Packed")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := fieldTarget9.FromBytes([]byte(m.Packed), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *PackAddressTest) MakeVDLTarget() vdl.Target {
	return &PackAddressTestTarget{Value: m}
}

type PackAddressTestTarget struct {
	Value        *PackAddressTest
	inTarget     vdl.StringSliceTarget
	packedTarget vdl.BytesTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *PackAddressTestTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*PackAddressTest)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *PackAddressTestTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "In":
		t.inTarget.Value = &t.Value.In
		target, err := &t.inTarget, error(nil)
		return nil, target, err
	case "Packed":
		t.packedTarget.Value = &t.Value.Packed
		target, err := &t.packedTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/lib/discovery/testdata.PackAddressTest", name)
	}
}
func (t *PackAddressTestTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *PackAddressTestTarget) ZeroField(name string) error {
	switch name {
	case "In":
		t.Value.In = []string(nil)
		return nil
	case "Packed":
		t.Value.Packed = []byte(nil)
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/x/ref/lib/discovery/testdata.PackAddressTest", name)
	}
}
func (t *PackAddressTestTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *PackAddressTest) VDLRead(dec vdl.Decoder) error {
	*x = PackAddressTest{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if dec.Type().Kind() != vdl.Struct {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	match := 0
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			if match == 0 && dec.Type().NumField() > 0 {
				return fmt.Errorf("no matching fields in struct %T, from %v", *x, dec.Type())
			}
			return dec.FinishValue()
		case "In":
			match++
			if err = __VDLRead1_list(dec, &x.In); err != nil {
				return err
			}
		case "Packed":
			match++
			if err = dec.StartValue(); err != nil {
				return err
			}
			if err = dec.DecodeBytes(-1, &x.Packed); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead1_list(dec vdl.Decoder, x *[]string) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if k := dec.Type().Kind(); k != vdl.Array && k != vdl.List {
		return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type())
	}
	switch len := dec.LenHint(); {
	case len == 0:
		*x = nil
	case len > 0:
		*x = make([]string, 0, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		}
		var elem string
		if err = dec.StartValue(); err != nil {
			return err
		}
		if elem, err = dec.DecodeString(); err != nil {
			return err
		}
		if err = dec.FinishValue(); err != nil {
			return err
		}
		*x = append(*x, elem)
	}
}

// PackEncryptionKeysTest represents a test case for PackEncryptionKeys
type PackEncryptionKeysTest struct {
	// Algo is the algorithm that's in use.
	// but that isn't defined in vdl yet.
	Algo discovery.EncryptionAlgorithm
	// Keys are the encryption keys.
	// but that isn't defined in vdl yet.
	Keys []discovery.EncryptionKey
	// Packed is the expected output bytes.
	Packed []byte
}

func (PackEncryptionKeysTest) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/discovery/testdata.PackEncryptionKeysTest"`
}) {
}

func (m *PackEncryptionKeysTest) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.Algo == discovery.EncryptionAlgorithm(0))
	if var4 {
		if err := fieldsTarget1.ZeroField("Algo"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Algo")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := m.Algo.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var var7 bool
	if len(m.Keys) == 0 {
		var7 = true
	}
	if var7 {
		if err := fieldsTarget1.ZeroField("Keys"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Keys")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.Keys))
			if err != nil {
				return err
			}
			for i, elem10 := range m.Keys {
				elemTarget9, err := listTarget8.StartElem(i)
				if err != nil {
					return err
				}

				if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(1).Type.Elem()); err != nil {
					return err
				}
				if err := listTarget8.FinishElem(elemTarget9); err != nil {
					return err
				}
			}
			if err := fieldTarget6.FinishList(listTarget8); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	var var13 bool
	if len(m.Packed) == 0 {
		var13 = true
	}
	if var13 {
		if err := fieldsTarget1.ZeroField("Packed"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Packed")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}

			if err := fieldTarget12.FromBytes([]byte(m.Packed), tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *PackEncryptionKeysTest) MakeVDLTarget() vdl.Target {
	return &PackEncryptionKeysTestTarget{Value: m}
}

type PackEncryptionKeysTestTarget struct {
	Value        *PackEncryptionKeysTest
	algoTarget   discovery.EncryptionAlgorithmTarget
	keysTarget   __VDLTarget1_list
	packedTarget vdl.BytesTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *PackEncryptionKeysTestTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*PackEncryptionKeysTest)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *PackEncryptionKeysTestTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Algo":
		t.algoTarget.Value = &t.Value.Algo
		target, err := &t.algoTarget, error(nil)
		return nil, target, err
	case "Keys":
		t.keysTarget.Value = &t.Value.Keys
		target, err := &t.keysTarget, error(nil)
		return nil, target, err
	case "Packed":
		t.packedTarget.Value = &t.Value.Packed
		target, err := &t.packedTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/lib/discovery/testdata.PackEncryptionKeysTest", name)
	}
}
func (t *PackEncryptionKeysTestTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *PackEncryptionKeysTestTarget) ZeroField(name string) error {
	switch name {
	case "Algo":
		t.Value.Algo = discovery.EncryptionAlgorithm(0)
		return nil
	case "Keys":
		t.Value.Keys = []discovery.EncryptionKey(nil)
		return nil
	case "Packed":
		t.Value.Packed = []byte(nil)
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/x/ref/lib/discovery/testdata.PackEncryptionKeysTest", name)
	}
}
func (t *PackEncryptionKeysTestTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

// []discovery.EncryptionKey
type __VDLTarget1_list struct {
	Value      *[]discovery.EncryptionKey
	elemTarget discovery.EncryptionKeyTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget1_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]discovery.EncryptionKey)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]discovery.EncryptionKey, len)
	} else {
		*t.Value = (*t.Value)[:len]
	}
	return t, nil
}
func (t *__VDLTarget1_list) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *__VDLTarget1_list) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *__VDLTarget1_list) FinishList(elem vdl.ListTarget) error {

	return nil
}

func (x *PackEncryptionKeysTest) VDLRead(dec vdl.Decoder) error {
	*x = PackEncryptionKeysTest{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if dec.Type().Kind() != vdl.Struct {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	match := 0
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			if match == 0 && dec.Type().NumField() > 0 {
				return fmt.Errorf("no matching fields in struct %T, from %v", *x, dec.Type())
			}
			return dec.FinishValue()
		case "Algo":
			match++
			if err = x.Algo.VDLRead(dec); err != nil {
				return err
			}
		case "Keys":
			match++
			if err = __VDLRead2_list(dec, &x.Keys); err != nil {
				return err
			}
		case "Packed":
			match++
			if err = dec.StartValue(); err != nil {
				return err
			}
			if err = dec.DecodeBytes(-1, &x.Packed); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

func __VDLRead2_list(dec vdl.Decoder, x *[]discovery.EncryptionKey) error {
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if k := dec.Type().Kind(); k != vdl.Array && k != vdl.List {
		return fmt.Errorf("incompatible list %T, from %v", *x, dec.Type())
	}
	switch len := dec.LenHint(); {
	case len == 0:
		*x = nil
	case len > 0:
		*x = make([]discovery.EncryptionKey, 0, len)
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		}
		var elem discovery.EncryptionKey
		if err = elem.VDLRead(dec); err != nil {
			return err
		}
		*x = append(*x, elem)
	}
}

// UuidTestData represents the inputs and outputs for a uuid test.
type UuidTestData struct {
	// In is the input string.
	In string
	// Want is the expected uuid's human-readable string form.
	Want string
}

func (UuidTestData) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/lib/discovery/testdata.UuidTestData"`
}) {
}

func (m *UuidTestData) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	var4 := (m.In == "")
	if var4 {
		if err := fieldsTarget1.ZeroField("In"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("In")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget3.FromString(string(m.In), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
				return err
			}
		}
	}
	var7 := (m.Want == "")
	if var7 {
		if err := fieldsTarget1.ZeroField("Want"); err != nil && err != vdl.ErrFieldNoExist {
			return err
		}
	} else {
		keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Want")
		if err != vdl.ErrFieldNoExist {
			if err != nil {
				return err
			}
			if err := fieldTarget6.FromString(string(m.Want), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
			if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
				return err
			}
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *UuidTestData) MakeVDLTarget() vdl.Target {
	return &UuidTestDataTarget{Value: m}
}

type UuidTestDataTarget struct {
	Value      *UuidTestData
	inTarget   vdl.StringTarget
	wantTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *UuidTestDataTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*UuidTestData)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *UuidTestDataTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "In":
		t.inTarget.Value = &t.Value.In
		target, err := &t.inTarget, error(nil)
		return nil, target, err
	case "Want":
		t.wantTarget.Value = &t.Value.Want
		target, err := &t.wantTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/lib/discovery/testdata.UuidTestData", name)
	}
}
func (t *UuidTestDataTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *UuidTestDataTarget) ZeroField(name string) error {
	switch name {
	case "In":
		t.Value.In = ""
		return nil
	case "Want":
		t.Value.Want = ""
		return nil
	default:
		return fmt.Errorf("field %s not in struct v.io/x/ref/lib/discovery/testdata.UuidTestData", name)
	}
}
func (t *UuidTestDataTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}

func (x *UuidTestData) VDLRead(dec vdl.Decoder) error {
	*x = UuidTestData{}
	var err error
	if err = dec.StartValue(); err != nil {
		return err
	}
	if dec.Type().Kind() != vdl.Struct {
		return fmt.Errorf("incompatible struct %T, from %v", *x, dec.Type())
	}
	match := 0
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			if match == 0 && dec.Type().NumField() > 0 {
				return fmt.Errorf("no matching fields in struct %T, from %v", *x, dec.Type())
			}
			return dec.FinishValue()
		case "In":
			match++
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.In, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		case "Want":
			match++
			if err = dec.StartValue(); err != nil {
				return err
			}
			if x.Want, err = dec.DecodeString(); err != nil {
				return err
			}
			if err = dec.FinishValue(); err != nil {
				return err
			}
		default:
			if err = dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

//////////////////////////////////////////////////
// Const definitions

var PackAddressTestData = []PackAddressTest{
	{
		In: []string{
			"a12345",
		},
		Packed: []byte("\x06a12345"),
	},
	{
		In: []string{
			"a1234",
			"b5678",
			"c9012",
		},
		Packed: []byte("\x05a1234\x05b5678\x05c9012"),
	},
	{},
}
var PackEncryptionKeysTestData = []PackEncryptionKeysTest{
	{
		Algo: 1,
		Keys: []discovery.EncryptionKey{
			discovery.EncryptionKey("0123456789"),
		},
		Packed: []byte("\x01\n0123456789"),
	},
	{
		Algo: 2,
		Keys: []discovery.EncryptionKey{
			discovery.EncryptionKey("012345"),
			discovery.EncryptionKey("123456"),
			discovery.EncryptionKey("234567"),
		},
		Packed: []byte("\x02\x06012345\x06123456\x06234567"),
	},
	{
		Packed: []byte("\x00"),
	},
}
var ServiceUuidTest = []UuidTestData{
	{
		In:   "v.io",
		Want: "2101363c-688d-548a-a600-34d506e1aad0",
	},
	{
		In:   "v.io/v23/abc",
		Want: "6726c4e5-b6eb-5547-9228-b2913f4fad52",
	},
	{
		In:   "v.io/v23/abc/xyz",
		Want: "be8a57d7-931d-5ee4-9243-0bebde0029a5",
	},
}
var AttributeUuidTest = []UuidTestData{
	{
		In:   "name",
		Want: "217a496d-3aae-5748-baf0-a77555f8f4f4",
	},
	{
		In:   "_attr",
		Want: "6c020e4b-9a59-5c7f-92e7-45954a16a402",
	},
	{
		In:   "xyz",
		Want: "c10b25a2-2d4d-5a19-bb7c-1ee1c4972b4c",
	},
}

var __VDLInitCalled bool

// __VDLInit performs vdl initialization.  It is safe to call multiple times.
// If you have an init ordering issue, just insert the following line verbatim
// into your source files in this package, right after the "package foo" clause:
//
//    var _ = __VDLInit()
//
// The purpose of this function is to ensure that vdl initialization occurs in
// the right order, and very early in the init sequence.  In particular, vdl
// registration and package variable initialization needs to occur before
// functions like vdl.TypeOf will work properly.
//
// This function returns a dummy value, so that it can be used to initialize the
// first var in the file, to take advantage of Go's defined init order.
func __VDLInit() struct{} {
	if __VDLInitCalled {
		return struct{}{}
	}
	__VDLInitCalled = true

	// Register types.
	vdl.Register((*PackAddressTest)(nil))
	vdl.Register((*PackEncryptionKeysTest)(nil))
	vdl.Register((*UuidTestData)(nil))

	return struct{}{}
}