From 2408d34c712d01fa0dd9382e6068878fc2ee274d Mon Sep 17 00:00:00 2001 From: Evan Boyle Date: Fri, 20 Mar 2020 16:51:33 -0700 Subject: [PATCH] Add missing builtin MapArray to the Go SDK (#4144) --- CHANGELOG.md | 2 + sdk/go/pulumi/generate.go | 6 + sdk/go/pulumi/types_builtins.go | 1180 ++++++++++++++++++++ sdk/go/pulumi/types_builtins_test.go | 1540 ++++++++++++++++++++++++++ 4 files changed, 2728 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 33312ac91..f5deffb06 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ CHANGELOG [#4109](https://github.com/pulumi/pulumi/pull/4109) - Report compile time errors for Go programs during plugin acquisition. [#4141](https://github.com/pulumi/pulumi/pull/4141) +- Add missing builtin `MapArray` to Go SDK. + [#4144](https://github.com/pulumi/pulumi/pull/4144) ## 1.13.0 (2020-03-18) - Add support for plugin acquisition for Go programs diff --git a/sdk/go/pulumi/generate.go b/sdk/go/pulumi/generate.go index bf2de6f76..e9071e598 100644 --- a/sdk/go/pulumi/generate.go +++ b/sdk/go/pulumi/generate.go @@ -197,6 +197,12 @@ func makeBuiltins(primitives []*builtin) []*builtin { elementType: "map[string][]" + p.Type, Example: fmt.Sprintf("%sArrayMap{\"baz\": %sArray{%s}}", name, name, p.Example), }) + builtins = append(builtins, &builtin{ + Name: name + "MapArray", + Type: "[]" + name + "MapInput", + elementType: "[]map[string]" + p.Type, + Example: fmt.Sprintf("%sMapArray{%sMap{\"baz\": %s}}", name, name, p.Example), + }) } nameToBuiltin := map[string]*builtin{} diff --git a/sdk/go/pulumi/types_builtins.go b/sdk/go/pulumi/types_builtins.go index e955132b4..86ae3acef 100644 --- a/sdk/go/pulumi/types_builtins.go +++ b/sdk/go/pulumi/types_builtins.go @@ -60,6 +60,16 @@ func (o *OutputState) ApplyArchiveArrayMapWithContext(ctx context.Context, appli return o.ApplyTWithContext(ctx, applier).(ArchiveArrayMapOutput) } +// ApplyArchiveMapArray is like ApplyT, but returns a ArchiveMapArrayOutput. +func (o *OutputState) ApplyArchiveMapArray(applier interface{}) ArchiveMapArrayOutput { + return o.ApplyT(applier).(ArchiveMapArrayOutput) +} + +// ApplyArchiveMapArrayWithContext is like ApplyTWithContext, but returns a ArchiveMapArrayOutput. +func (o *OutputState) ApplyArchiveMapArrayWithContext(ctx context.Context, applier interface{}) ArchiveMapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(ArchiveMapArrayOutput) +} + // ApplyAsset is like ApplyT, but returns a AssetOutput. func (o *OutputState) ApplyAsset(applier interface{}) AssetOutput { return o.ApplyT(applier).(AssetOutput) @@ -100,6 +110,16 @@ func (o *OutputState) ApplyAssetArrayMapWithContext(ctx context.Context, applier return o.ApplyTWithContext(ctx, applier).(AssetArrayMapOutput) } +// ApplyAssetMapArray is like ApplyT, but returns a AssetMapArrayOutput. +func (o *OutputState) ApplyAssetMapArray(applier interface{}) AssetMapArrayOutput { + return o.ApplyT(applier).(AssetMapArrayOutput) +} + +// ApplyAssetMapArrayWithContext is like ApplyTWithContext, but returns a AssetMapArrayOutput. +func (o *OutputState) ApplyAssetMapArrayWithContext(ctx context.Context, applier interface{}) AssetMapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(AssetMapArrayOutput) +} + // ApplyAssetOrArchive is like ApplyT, but returns a AssetOrArchiveOutput. func (o *OutputState) ApplyAssetOrArchive(applier interface{}) AssetOrArchiveOutput { return o.ApplyT(applier).(AssetOrArchiveOutput) @@ -140,6 +160,16 @@ func (o *OutputState) ApplyAssetOrArchiveArrayMapWithContext(ctx context.Context return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveArrayMapOutput) } +// ApplyAssetOrArchiveMapArray is like ApplyT, but returns a AssetOrArchiveMapArrayOutput. +func (o *OutputState) ApplyAssetOrArchiveMapArray(applier interface{}) AssetOrArchiveMapArrayOutput { + return o.ApplyT(applier).(AssetOrArchiveMapArrayOutput) +} + +// ApplyAssetOrArchiveMapArrayWithContext is like ApplyTWithContext, but returns a AssetOrArchiveMapArrayOutput. +func (o *OutputState) ApplyAssetOrArchiveMapArrayWithContext(ctx context.Context, applier interface{}) AssetOrArchiveMapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveMapArrayOutput) +} + // ApplyBool is like ApplyT, but returns a BoolOutput. func (o *OutputState) ApplyBool(applier interface{}) BoolOutput { return o.ApplyT(applier).(BoolOutput) @@ -190,6 +220,16 @@ func (o *OutputState) ApplyBoolArrayMapWithContext(ctx context.Context, applier return o.ApplyTWithContext(ctx, applier).(BoolArrayMapOutput) } +// ApplyBoolMapArray is like ApplyT, but returns a BoolMapArrayOutput. +func (o *OutputState) ApplyBoolMapArray(applier interface{}) BoolMapArrayOutput { + return o.ApplyT(applier).(BoolMapArrayOutput) +} + +// ApplyBoolMapArrayWithContext is like ApplyTWithContext, but returns a BoolMapArrayOutput. +func (o *OutputState) ApplyBoolMapArrayWithContext(ctx context.Context, applier interface{}) BoolMapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(BoolMapArrayOutput) +} + // ApplyFloat32 is like ApplyT, but returns a Float32Output. func (o *OutputState) ApplyFloat32(applier interface{}) Float32Output { return o.ApplyT(applier).(Float32Output) @@ -240,6 +280,16 @@ func (o *OutputState) ApplyFloat32ArrayMapWithContext(ctx context.Context, appli return o.ApplyTWithContext(ctx, applier).(Float32ArrayMapOutput) } +// ApplyFloat32MapArray is like ApplyT, but returns a Float32MapArrayOutput. +func (o *OutputState) ApplyFloat32MapArray(applier interface{}) Float32MapArrayOutput { + return o.ApplyT(applier).(Float32MapArrayOutput) +} + +// ApplyFloat32MapArrayWithContext is like ApplyTWithContext, but returns a Float32MapArrayOutput. +func (o *OutputState) ApplyFloat32MapArrayWithContext(ctx context.Context, applier interface{}) Float32MapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(Float32MapArrayOutput) +} + // ApplyFloat64 is like ApplyT, but returns a Float64Output. func (o *OutputState) ApplyFloat64(applier interface{}) Float64Output { return o.ApplyT(applier).(Float64Output) @@ -290,6 +340,16 @@ func (o *OutputState) ApplyFloat64ArrayMapWithContext(ctx context.Context, appli return o.ApplyTWithContext(ctx, applier).(Float64ArrayMapOutput) } +// ApplyFloat64MapArray is like ApplyT, but returns a Float64MapArrayOutput. +func (o *OutputState) ApplyFloat64MapArray(applier interface{}) Float64MapArrayOutput { + return o.ApplyT(applier).(Float64MapArrayOutput) +} + +// ApplyFloat64MapArrayWithContext is like ApplyTWithContext, but returns a Float64MapArrayOutput. +func (o *OutputState) ApplyFloat64MapArrayWithContext(ctx context.Context, applier interface{}) Float64MapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(Float64MapArrayOutput) +} + // ApplyID is like ApplyT, but returns a IDOutput. func (o *OutputState) ApplyID(applier interface{}) IDOutput { return o.ApplyT(applier).(IDOutput) @@ -340,6 +400,16 @@ func (o *OutputState) ApplyIDArrayMapWithContext(ctx context.Context, applier in return o.ApplyTWithContext(ctx, applier).(IDArrayMapOutput) } +// ApplyIDMapArray is like ApplyT, but returns a IDMapArrayOutput. +func (o *OutputState) ApplyIDMapArray(applier interface{}) IDMapArrayOutput { + return o.ApplyT(applier).(IDMapArrayOutput) +} + +// ApplyIDMapArrayWithContext is like ApplyTWithContext, but returns a IDMapArrayOutput. +func (o *OutputState) ApplyIDMapArrayWithContext(ctx context.Context, applier interface{}) IDMapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(IDMapArrayOutput) +} + // ApplyArray is like ApplyT, but returns a ArrayOutput. func (o *OutputState) ApplyArray(applier interface{}) ArrayOutput { return o.ApplyT(applier).(ArrayOutput) @@ -370,6 +440,16 @@ func (o *OutputState) ApplyArrayMapWithContext(ctx context.Context, applier inte return o.ApplyTWithContext(ctx, applier).(ArrayMapOutput) } +// ApplyMapArray is like ApplyT, but returns a MapArrayOutput. +func (o *OutputState) ApplyMapArray(applier interface{}) MapArrayOutput { + return o.ApplyT(applier).(MapArrayOutput) +} + +// ApplyMapArrayWithContext is like ApplyTWithContext, but returns a MapArrayOutput. +func (o *OutputState) ApplyMapArrayWithContext(ctx context.Context, applier interface{}) MapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(MapArrayOutput) +} + // ApplyInt is like ApplyT, but returns a IntOutput. func (o *OutputState) ApplyInt(applier interface{}) IntOutput { return o.ApplyT(applier).(IntOutput) @@ -420,6 +500,16 @@ func (o *OutputState) ApplyIntArrayMapWithContext(ctx context.Context, applier i return o.ApplyTWithContext(ctx, applier).(IntArrayMapOutput) } +// ApplyIntMapArray is like ApplyT, but returns a IntMapArrayOutput. +func (o *OutputState) ApplyIntMapArray(applier interface{}) IntMapArrayOutput { + return o.ApplyT(applier).(IntMapArrayOutput) +} + +// ApplyIntMapArrayWithContext is like ApplyTWithContext, but returns a IntMapArrayOutput. +func (o *OutputState) ApplyIntMapArrayWithContext(ctx context.Context, applier interface{}) IntMapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(IntMapArrayOutput) +} + // ApplyInt16 is like ApplyT, but returns a Int16Output. func (o *OutputState) ApplyInt16(applier interface{}) Int16Output { return o.ApplyT(applier).(Int16Output) @@ -470,6 +560,16 @@ func (o *OutputState) ApplyInt16ArrayMapWithContext(ctx context.Context, applier return o.ApplyTWithContext(ctx, applier).(Int16ArrayMapOutput) } +// ApplyInt16MapArray is like ApplyT, but returns a Int16MapArrayOutput. +func (o *OutputState) ApplyInt16MapArray(applier interface{}) Int16MapArrayOutput { + return o.ApplyT(applier).(Int16MapArrayOutput) +} + +// ApplyInt16MapArrayWithContext is like ApplyTWithContext, but returns a Int16MapArrayOutput. +func (o *OutputState) ApplyInt16MapArrayWithContext(ctx context.Context, applier interface{}) Int16MapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(Int16MapArrayOutput) +} + // ApplyInt32 is like ApplyT, but returns a Int32Output. func (o *OutputState) ApplyInt32(applier interface{}) Int32Output { return o.ApplyT(applier).(Int32Output) @@ -520,6 +620,16 @@ func (o *OutputState) ApplyInt32ArrayMapWithContext(ctx context.Context, applier return o.ApplyTWithContext(ctx, applier).(Int32ArrayMapOutput) } +// ApplyInt32MapArray is like ApplyT, but returns a Int32MapArrayOutput. +func (o *OutputState) ApplyInt32MapArray(applier interface{}) Int32MapArrayOutput { + return o.ApplyT(applier).(Int32MapArrayOutput) +} + +// ApplyInt32MapArrayWithContext is like ApplyTWithContext, but returns a Int32MapArrayOutput. +func (o *OutputState) ApplyInt32MapArrayWithContext(ctx context.Context, applier interface{}) Int32MapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(Int32MapArrayOutput) +} + // ApplyInt64 is like ApplyT, but returns a Int64Output. func (o *OutputState) ApplyInt64(applier interface{}) Int64Output { return o.ApplyT(applier).(Int64Output) @@ -570,6 +680,16 @@ func (o *OutputState) ApplyInt64ArrayMapWithContext(ctx context.Context, applier return o.ApplyTWithContext(ctx, applier).(Int64ArrayMapOutput) } +// ApplyInt64MapArray is like ApplyT, but returns a Int64MapArrayOutput. +func (o *OutputState) ApplyInt64MapArray(applier interface{}) Int64MapArrayOutput { + return o.ApplyT(applier).(Int64MapArrayOutput) +} + +// ApplyInt64MapArrayWithContext is like ApplyTWithContext, but returns a Int64MapArrayOutput. +func (o *OutputState) ApplyInt64MapArrayWithContext(ctx context.Context, applier interface{}) Int64MapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(Int64MapArrayOutput) +} + // ApplyInt8 is like ApplyT, but returns a Int8Output. func (o *OutputState) ApplyInt8(applier interface{}) Int8Output { return o.ApplyT(applier).(Int8Output) @@ -620,6 +740,16 @@ func (o *OutputState) ApplyInt8ArrayMapWithContext(ctx context.Context, applier return o.ApplyTWithContext(ctx, applier).(Int8ArrayMapOutput) } +// ApplyInt8MapArray is like ApplyT, but returns a Int8MapArrayOutput. +func (o *OutputState) ApplyInt8MapArray(applier interface{}) Int8MapArrayOutput { + return o.ApplyT(applier).(Int8MapArrayOutput) +} + +// ApplyInt8MapArrayWithContext is like ApplyTWithContext, but returns a Int8MapArrayOutput. +func (o *OutputState) ApplyInt8MapArrayWithContext(ctx context.Context, applier interface{}) Int8MapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(Int8MapArrayOutput) +} + // ApplyString is like ApplyT, but returns a StringOutput. func (o *OutputState) ApplyString(applier interface{}) StringOutput { return o.ApplyT(applier).(StringOutput) @@ -670,6 +800,16 @@ func (o *OutputState) ApplyStringArrayMapWithContext(ctx context.Context, applie return o.ApplyTWithContext(ctx, applier).(StringArrayMapOutput) } +// ApplyStringMapArray is like ApplyT, but returns a StringMapArrayOutput. +func (o *OutputState) ApplyStringMapArray(applier interface{}) StringMapArrayOutput { + return o.ApplyT(applier).(StringMapArrayOutput) +} + +// ApplyStringMapArrayWithContext is like ApplyTWithContext, but returns a StringMapArrayOutput. +func (o *OutputState) ApplyStringMapArrayWithContext(ctx context.Context, applier interface{}) StringMapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(StringMapArrayOutput) +} + // ApplyURN is like ApplyT, but returns a URNOutput. func (o *OutputState) ApplyURN(applier interface{}) URNOutput { return o.ApplyT(applier).(URNOutput) @@ -720,6 +860,16 @@ func (o *OutputState) ApplyURNArrayMapWithContext(ctx context.Context, applier i return o.ApplyTWithContext(ctx, applier).(URNArrayMapOutput) } +// ApplyURNMapArray is like ApplyT, but returns a URNMapArrayOutput. +func (o *OutputState) ApplyURNMapArray(applier interface{}) URNMapArrayOutput { + return o.ApplyT(applier).(URNMapArrayOutput) +} + +// ApplyURNMapArrayWithContext is like ApplyTWithContext, but returns a URNMapArrayOutput. +func (o *OutputState) ApplyURNMapArrayWithContext(ctx context.Context, applier interface{}) URNMapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(URNMapArrayOutput) +} + // ApplyUint is like ApplyT, but returns a UintOutput. func (o *OutputState) ApplyUint(applier interface{}) UintOutput { return o.ApplyT(applier).(UintOutput) @@ -770,6 +920,16 @@ func (o *OutputState) ApplyUintArrayMapWithContext(ctx context.Context, applier return o.ApplyTWithContext(ctx, applier).(UintArrayMapOutput) } +// ApplyUintMapArray is like ApplyT, but returns a UintMapArrayOutput. +func (o *OutputState) ApplyUintMapArray(applier interface{}) UintMapArrayOutput { + return o.ApplyT(applier).(UintMapArrayOutput) +} + +// ApplyUintMapArrayWithContext is like ApplyTWithContext, but returns a UintMapArrayOutput. +func (o *OutputState) ApplyUintMapArrayWithContext(ctx context.Context, applier interface{}) UintMapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(UintMapArrayOutput) +} + // ApplyUint16 is like ApplyT, but returns a Uint16Output. func (o *OutputState) ApplyUint16(applier interface{}) Uint16Output { return o.ApplyT(applier).(Uint16Output) @@ -820,6 +980,16 @@ func (o *OutputState) ApplyUint16ArrayMapWithContext(ctx context.Context, applie return o.ApplyTWithContext(ctx, applier).(Uint16ArrayMapOutput) } +// ApplyUint16MapArray is like ApplyT, but returns a Uint16MapArrayOutput. +func (o *OutputState) ApplyUint16MapArray(applier interface{}) Uint16MapArrayOutput { + return o.ApplyT(applier).(Uint16MapArrayOutput) +} + +// ApplyUint16MapArrayWithContext is like ApplyTWithContext, but returns a Uint16MapArrayOutput. +func (o *OutputState) ApplyUint16MapArrayWithContext(ctx context.Context, applier interface{}) Uint16MapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(Uint16MapArrayOutput) +} + // ApplyUint32 is like ApplyT, but returns a Uint32Output. func (o *OutputState) ApplyUint32(applier interface{}) Uint32Output { return o.ApplyT(applier).(Uint32Output) @@ -870,6 +1040,16 @@ func (o *OutputState) ApplyUint32ArrayMapWithContext(ctx context.Context, applie return o.ApplyTWithContext(ctx, applier).(Uint32ArrayMapOutput) } +// ApplyUint32MapArray is like ApplyT, but returns a Uint32MapArrayOutput. +func (o *OutputState) ApplyUint32MapArray(applier interface{}) Uint32MapArrayOutput { + return o.ApplyT(applier).(Uint32MapArrayOutput) +} + +// ApplyUint32MapArrayWithContext is like ApplyTWithContext, but returns a Uint32MapArrayOutput. +func (o *OutputState) ApplyUint32MapArrayWithContext(ctx context.Context, applier interface{}) Uint32MapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(Uint32MapArrayOutput) +} + // ApplyUint64 is like ApplyT, but returns a Uint64Output. func (o *OutputState) ApplyUint64(applier interface{}) Uint64Output { return o.ApplyT(applier).(Uint64Output) @@ -920,6 +1100,16 @@ func (o *OutputState) ApplyUint64ArrayMapWithContext(ctx context.Context, applie return o.ApplyTWithContext(ctx, applier).(Uint64ArrayMapOutput) } +// ApplyUint64MapArray is like ApplyT, but returns a Uint64MapArrayOutput. +func (o *OutputState) ApplyUint64MapArray(applier interface{}) Uint64MapArrayOutput { + return o.ApplyT(applier).(Uint64MapArrayOutput) +} + +// ApplyUint64MapArrayWithContext is like ApplyTWithContext, but returns a Uint64MapArrayOutput. +func (o *OutputState) ApplyUint64MapArrayWithContext(ctx context.Context, applier interface{}) Uint64MapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(Uint64MapArrayOutput) +} + // ApplyUint8 is like ApplyT, but returns a Uint8Output. func (o *OutputState) ApplyUint8(applier interface{}) Uint8Output { return o.ApplyT(applier).(Uint8Output) @@ -970,6 +1160,16 @@ func (o *OutputState) ApplyUint8ArrayMapWithContext(ctx context.Context, applier return o.ApplyTWithContext(ctx, applier).(Uint8ArrayMapOutput) } +// ApplyUint8MapArray is like ApplyT, but returns a Uint8MapArrayOutput. +func (o *OutputState) ApplyUint8MapArray(applier interface{}) Uint8MapArrayOutput { + return o.ApplyT(applier).(Uint8MapArrayOutput) +} + +// ApplyUint8MapArrayWithContext is like ApplyTWithContext, but returns a Uint8MapArrayOutput. +func (o *OutputState) ApplyUint8MapArrayWithContext(ctx context.Context, applier interface{}) Uint8MapArrayOutput { + return o.ApplyTWithContext(ctx, applier).(Uint8MapArrayOutput) +} + var archiveType = reflect.TypeOf((*Archive)(nil)).Elem() // ArchiveInput is an input type that accepts Archive and ArchiveOutput values. @@ -1171,6 +1371,54 @@ func (o ArchiveArrayMapOutput) MapIndex(k StringInput) ArchiveArrayOutput { }).(ArchiveArrayOutput) } +var archiveMapArrayType = reflect.TypeOf((*[]map[string]Archive)(nil)).Elem() + +// ArchiveMapArrayInput is an input type that accepts ArchiveMapArray and ArchiveMapArrayOutput values. +type ArchiveMapArrayInput interface { + Input + + ToArchiveMapArrayOutput() ArchiveMapArrayOutput + ToArchiveMapArrayOutputWithContext(ctx context.Context) ArchiveMapArrayOutput +} + +// ArchiveMapArray is an input type for []ArchiveMapInput values. +type ArchiveMapArray []ArchiveMapInput + +// ElementType returns the element type of this Input ([]map[string]Archive). +func (ArchiveMapArray) ElementType() reflect.Type { + return archiveMapArrayType +} + +func (in ArchiveMapArray) ToArchiveMapArrayOutput() ArchiveMapArrayOutput { + return ToOutput(in).(ArchiveMapArrayOutput) +} + +func (in ArchiveMapArray) ToArchiveMapArrayOutputWithContext(ctx context.Context) ArchiveMapArrayOutput { + return ToOutputWithContext(ctx, in).(ArchiveMapArrayOutput) +} + +// ArchiveMapArrayOutput is an Output that returns []map[string]Archive values. +type ArchiveMapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]Archive). +func (ArchiveMapArrayOutput) ElementType() reflect.Type { + return archiveMapArrayType +} + +func (o ArchiveMapArrayOutput) ToArchiveMapArrayOutput() ArchiveMapArrayOutput { + return o +} + +func (o ArchiveMapArrayOutput) ToArchiveMapArrayOutputWithContext(ctx context.Context) ArchiveMapArrayOutput { + return o +} + +func (o ArchiveMapArrayOutput) Index(i IntInput) ArchiveMapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]Archive { + return vs[0].([]map[string]Archive)[vs[1].(int)] + }).(ArchiveMapOutput) +} + var assetType = reflect.TypeOf((*Asset)(nil)).Elem() // AssetInput is an input type that accepts Asset and AssetOutput values. @@ -1372,6 +1620,54 @@ func (o AssetArrayMapOutput) MapIndex(k StringInput) AssetArrayOutput { }).(AssetArrayOutput) } +var assetMapArrayType = reflect.TypeOf((*[]map[string]Asset)(nil)).Elem() + +// AssetMapArrayInput is an input type that accepts AssetMapArray and AssetMapArrayOutput values. +type AssetMapArrayInput interface { + Input + + ToAssetMapArrayOutput() AssetMapArrayOutput + ToAssetMapArrayOutputWithContext(ctx context.Context) AssetMapArrayOutput +} + +// AssetMapArray is an input type for []AssetMapInput values. +type AssetMapArray []AssetMapInput + +// ElementType returns the element type of this Input ([]map[string]Asset). +func (AssetMapArray) ElementType() reflect.Type { + return assetMapArrayType +} + +func (in AssetMapArray) ToAssetMapArrayOutput() AssetMapArrayOutput { + return ToOutput(in).(AssetMapArrayOutput) +} + +func (in AssetMapArray) ToAssetMapArrayOutputWithContext(ctx context.Context) AssetMapArrayOutput { + return ToOutputWithContext(ctx, in).(AssetMapArrayOutput) +} + +// AssetMapArrayOutput is an Output that returns []map[string]Asset values. +type AssetMapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]Asset). +func (AssetMapArrayOutput) ElementType() reflect.Type { + return assetMapArrayType +} + +func (o AssetMapArrayOutput) ToAssetMapArrayOutput() AssetMapArrayOutput { + return o +} + +func (o AssetMapArrayOutput) ToAssetMapArrayOutputWithContext(ctx context.Context) AssetMapArrayOutput { + return o +} + +func (o AssetMapArrayOutput) Index(i IntInput) AssetMapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]Asset { + return vs[0].([]map[string]Asset)[vs[1].(int)] + }).(AssetMapOutput) +} + var assetOrArchiveType = reflect.TypeOf((*AssetOrArchive)(nil)).Elem() // AssetOrArchiveInput is an input type that accepts AssetOrArchive and AssetOrArchiveOutput values. @@ -1542,6 +1838,54 @@ func (o AssetOrArchiveArrayMapOutput) MapIndex(k StringInput) AssetOrArchiveArra }).(AssetOrArchiveArrayOutput) } +var assetOrArchiveMapArrayType = reflect.TypeOf((*[]map[string]AssetOrArchive)(nil)).Elem() + +// AssetOrArchiveMapArrayInput is an input type that accepts AssetOrArchiveMapArray and AssetOrArchiveMapArrayOutput values. +type AssetOrArchiveMapArrayInput interface { + Input + + ToAssetOrArchiveMapArrayOutput() AssetOrArchiveMapArrayOutput + ToAssetOrArchiveMapArrayOutputWithContext(ctx context.Context) AssetOrArchiveMapArrayOutput +} + +// AssetOrArchiveMapArray is an input type for []AssetOrArchiveMapInput values. +type AssetOrArchiveMapArray []AssetOrArchiveMapInput + +// ElementType returns the element type of this Input ([]map[string]AssetOrArchive). +func (AssetOrArchiveMapArray) ElementType() reflect.Type { + return assetOrArchiveMapArrayType +} + +func (in AssetOrArchiveMapArray) ToAssetOrArchiveMapArrayOutput() AssetOrArchiveMapArrayOutput { + return ToOutput(in).(AssetOrArchiveMapArrayOutput) +} + +func (in AssetOrArchiveMapArray) ToAssetOrArchiveMapArrayOutputWithContext(ctx context.Context) AssetOrArchiveMapArrayOutput { + return ToOutputWithContext(ctx, in).(AssetOrArchiveMapArrayOutput) +} + +// AssetOrArchiveMapArrayOutput is an Output that returns []map[string]AssetOrArchive values. +type AssetOrArchiveMapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]AssetOrArchive). +func (AssetOrArchiveMapArrayOutput) ElementType() reflect.Type { + return assetOrArchiveMapArrayType +} + +func (o AssetOrArchiveMapArrayOutput) ToAssetOrArchiveMapArrayOutput() AssetOrArchiveMapArrayOutput { + return o +} + +func (o AssetOrArchiveMapArrayOutput) ToAssetOrArchiveMapArrayOutputWithContext(ctx context.Context) AssetOrArchiveMapArrayOutput { + return o +} + +func (o AssetOrArchiveMapArrayOutput) Index(i IntInput) AssetOrArchiveMapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]AssetOrArchive { + return vs[0].([]map[string]AssetOrArchive)[vs[1].(int)] + }).(AssetOrArchiveMapOutput) +} + var boolType = reflect.TypeOf((*bool)(nil)).Elem() // BoolInput is an input type that accepts Bool and BoolOutput values. @@ -1798,6 +2142,54 @@ func (o BoolArrayMapOutput) MapIndex(k StringInput) BoolArrayOutput { }).(BoolArrayOutput) } +var boolMapArrayType = reflect.TypeOf((*[]map[string]bool)(nil)).Elem() + +// BoolMapArrayInput is an input type that accepts BoolMapArray and BoolMapArrayOutput values. +type BoolMapArrayInput interface { + Input + + ToBoolMapArrayOutput() BoolMapArrayOutput + ToBoolMapArrayOutputWithContext(ctx context.Context) BoolMapArrayOutput +} + +// BoolMapArray is an input type for []BoolMapInput values. +type BoolMapArray []BoolMapInput + +// ElementType returns the element type of this Input ([]map[string]bool). +func (BoolMapArray) ElementType() reflect.Type { + return boolMapArrayType +} + +func (in BoolMapArray) ToBoolMapArrayOutput() BoolMapArrayOutput { + return ToOutput(in).(BoolMapArrayOutput) +} + +func (in BoolMapArray) ToBoolMapArrayOutputWithContext(ctx context.Context) BoolMapArrayOutput { + return ToOutputWithContext(ctx, in).(BoolMapArrayOutput) +} + +// BoolMapArrayOutput is an Output that returns []map[string]bool values. +type BoolMapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]bool). +func (BoolMapArrayOutput) ElementType() reflect.Type { + return boolMapArrayType +} + +func (o BoolMapArrayOutput) ToBoolMapArrayOutput() BoolMapArrayOutput { + return o +} + +func (o BoolMapArrayOutput) ToBoolMapArrayOutputWithContext(ctx context.Context) BoolMapArrayOutput { + return o +} + +func (o BoolMapArrayOutput) Index(i IntInput) BoolMapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]bool { + return vs[0].([]map[string]bool)[vs[1].(int)] + }).(BoolMapOutput) +} + var float32Type = reflect.TypeOf((*float32)(nil)).Elem() // Float32Input is an input type that accepts Float32 and Float32Output values. @@ -2054,6 +2446,54 @@ func (o Float32ArrayMapOutput) MapIndex(k StringInput) Float32ArrayOutput { }).(Float32ArrayOutput) } +var float32MapArrayType = reflect.TypeOf((*[]map[string]float32)(nil)).Elem() + +// Float32MapArrayInput is an input type that accepts Float32MapArray and Float32MapArrayOutput values. +type Float32MapArrayInput interface { + Input + + ToFloat32MapArrayOutput() Float32MapArrayOutput + ToFloat32MapArrayOutputWithContext(ctx context.Context) Float32MapArrayOutput +} + +// Float32MapArray is an input type for []Float32MapInput values. +type Float32MapArray []Float32MapInput + +// ElementType returns the element type of this Input ([]map[string]float32). +func (Float32MapArray) ElementType() reflect.Type { + return float32MapArrayType +} + +func (in Float32MapArray) ToFloat32MapArrayOutput() Float32MapArrayOutput { + return ToOutput(in).(Float32MapArrayOutput) +} + +func (in Float32MapArray) ToFloat32MapArrayOutputWithContext(ctx context.Context) Float32MapArrayOutput { + return ToOutputWithContext(ctx, in).(Float32MapArrayOutput) +} + +// Float32MapArrayOutput is an Output that returns []map[string]float32 values. +type Float32MapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]float32). +func (Float32MapArrayOutput) ElementType() reflect.Type { + return float32MapArrayType +} + +func (o Float32MapArrayOutput) ToFloat32MapArrayOutput() Float32MapArrayOutput { + return o +} + +func (o Float32MapArrayOutput) ToFloat32MapArrayOutputWithContext(ctx context.Context) Float32MapArrayOutput { + return o +} + +func (o Float32MapArrayOutput) Index(i IntInput) Float32MapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]float32 { + return vs[0].([]map[string]float32)[vs[1].(int)] + }).(Float32MapOutput) +} + var float64Type = reflect.TypeOf((*float64)(nil)).Elem() // Float64Input is an input type that accepts Float64 and Float64Output values. @@ -2310,6 +2750,54 @@ func (o Float64ArrayMapOutput) MapIndex(k StringInput) Float64ArrayOutput { }).(Float64ArrayOutput) } +var float64MapArrayType = reflect.TypeOf((*[]map[string]float64)(nil)).Elem() + +// Float64MapArrayInput is an input type that accepts Float64MapArray and Float64MapArrayOutput values. +type Float64MapArrayInput interface { + Input + + ToFloat64MapArrayOutput() Float64MapArrayOutput + ToFloat64MapArrayOutputWithContext(ctx context.Context) Float64MapArrayOutput +} + +// Float64MapArray is an input type for []Float64MapInput values. +type Float64MapArray []Float64MapInput + +// ElementType returns the element type of this Input ([]map[string]float64). +func (Float64MapArray) ElementType() reflect.Type { + return float64MapArrayType +} + +func (in Float64MapArray) ToFloat64MapArrayOutput() Float64MapArrayOutput { + return ToOutput(in).(Float64MapArrayOutput) +} + +func (in Float64MapArray) ToFloat64MapArrayOutputWithContext(ctx context.Context) Float64MapArrayOutput { + return ToOutputWithContext(ctx, in).(Float64MapArrayOutput) +} + +// Float64MapArrayOutput is an Output that returns []map[string]float64 values. +type Float64MapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]float64). +func (Float64MapArrayOutput) ElementType() reflect.Type { + return float64MapArrayType +} + +func (o Float64MapArrayOutput) ToFloat64MapArrayOutput() Float64MapArrayOutput { + return o +} + +func (o Float64MapArrayOutput) ToFloat64MapArrayOutputWithContext(ctx context.Context) Float64MapArrayOutput { + return o +} + +func (o Float64MapArrayOutput) Index(i IntInput) Float64MapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]float64 { + return vs[0].([]map[string]float64)[vs[1].(int)] + }).(Float64MapOutput) +} + var idType = reflect.TypeOf((*ID)(nil)).Elem() // IDInput is an input type that accepts ID and IDOutput values. @@ -2581,6 +3069,54 @@ func (o IDArrayMapOutput) MapIndex(k StringInput) IDArrayOutput { }).(IDArrayOutput) } +var iDMapArrayType = reflect.TypeOf((*[]map[string]ID)(nil)).Elem() + +// IDMapArrayInput is an input type that accepts IDMapArray and IDMapArrayOutput values. +type IDMapArrayInput interface { + Input + + ToIDMapArrayOutput() IDMapArrayOutput + ToIDMapArrayOutputWithContext(ctx context.Context) IDMapArrayOutput +} + +// IDMapArray is an input type for []IDMapInput values. +type IDMapArray []IDMapInput + +// ElementType returns the element type of this Input ([]map[string]ID). +func (IDMapArray) ElementType() reflect.Type { + return iDMapArrayType +} + +func (in IDMapArray) ToIDMapArrayOutput() IDMapArrayOutput { + return ToOutput(in).(IDMapArrayOutput) +} + +func (in IDMapArray) ToIDMapArrayOutputWithContext(ctx context.Context) IDMapArrayOutput { + return ToOutputWithContext(ctx, in).(IDMapArrayOutput) +} + +// IDMapArrayOutput is an Output that returns []map[string]ID values. +type IDMapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]ID). +func (IDMapArrayOutput) ElementType() reflect.Type { + return iDMapArrayType +} + +func (o IDMapArrayOutput) ToIDMapArrayOutput() IDMapArrayOutput { + return o +} + +func (o IDMapArrayOutput) ToIDMapArrayOutputWithContext(ctx context.Context) IDMapArrayOutput { + return o +} + +func (o IDMapArrayOutput) Index(i IntInput) IDMapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]ID { + return vs[0].([]map[string]ID)[vs[1].(int)] + }).(IDMapOutput) +} + var arrayType = reflect.TypeOf((*[]interface{})(nil)).Elem() // ArrayInput is an input type that accepts Array and ArrayOutput values. @@ -2725,6 +3261,54 @@ func (o ArrayMapOutput) MapIndex(k StringInput) ArrayOutput { }).(ArrayOutput) } +var mapArrayType = reflect.TypeOf((*[]map[string]interface{})(nil)).Elem() + +// MapArrayInput is an input type that accepts MapArray and MapArrayOutput values. +type MapArrayInput interface { + Input + + ToMapArrayOutput() MapArrayOutput + ToMapArrayOutputWithContext(ctx context.Context) MapArrayOutput +} + +// MapArray is an input type for []MapInput values. +type MapArray []MapInput + +// ElementType returns the element type of this Input ([]map[string]interface{}). +func (MapArray) ElementType() reflect.Type { + return mapArrayType +} + +func (in MapArray) ToMapArrayOutput() MapArrayOutput { + return ToOutput(in).(MapArrayOutput) +} + +func (in MapArray) ToMapArrayOutputWithContext(ctx context.Context) MapArrayOutput { + return ToOutputWithContext(ctx, in).(MapArrayOutput) +} + +// MapArrayOutput is an Output that returns []map[string]interface{} values. +type MapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]interface{}). +func (MapArrayOutput) ElementType() reflect.Type { + return mapArrayType +} + +func (o MapArrayOutput) ToMapArrayOutput() MapArrayOutput { + return o +} + +func (o MapArrayOutput) ToMapArrayOutputWithContext(ctx context.Context) MapArrayOutput { + return o +} + +func (o MapArrayOutput) Index(i IntInput) MapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]interface{} { + return vs[0].([]map[string]interface{})[vs[1].(int)] + }).(MapOutput) +} + var intType = reflect.TypeOf((*int)(nil)).Elem() // IntInput is an input type that accepts Int and IntOutput values. @@ -2981,6 +3565,54 @@ func (o IntArrayMapOutput) MapIndex(k StringInput) IntArrayOutput { }).(IntArrayOutput) } +var intMapArrayType = reflect.TypeOf((*[]map[string]int)(nil)).Elem() + +// IntMapArrayInput is an input type that accepts IntMapArray and IntMapArrayOutput values. +type IntMapArrayInput interface { + Input + + ToIntMapArrayOutput() IntMapArrayOutput + ToIntMapArrayOutputWithContext(ctx context.Context) IntMapArrayOutput +} + +// IntMapArray is an input type for []IntMapInput values. +type IntMapArray []IntMapInput + +// ElementType returns the element type of this Input ([]map[string]int). +func (IntMapArray) ElementType() reflect.Type { + return intMapArrayType +} + +func (in IntMapArray) ToIntMapArrayOutput() IntMapArrayOutput { + return ToOutput(in).(IntMapArrayOutput) +} + +func (in IntMapArray) ToIntMapArrayOutputWithContext(ctx context.Context) IntMapArrayOutput { + return ToOutputWithContext(ctx, in).(IntMapArrayOutput) +} + +// IntMapArrayOutput is an Output that returns []map[string]int values. +type IntMapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]int). +func (IntMapArrayOutput) ElementType() reflect.Type { + return intMapArrayType +} + +func (o IntMapArrayOutput) ToIntMapArrayOutput() IntMapArrayOutput { + return o +} + +func (o IntMapArrayOutput) ToIntMapArrayOutputWithContext(ctx context.Context) IntMapArrayOutput { + return o +} + +func (o IntMapArrayOutput) Index(i IntInput) IntMapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]int { + return vs[0].([]map[string]int)[vs[1].(int)] + }).(IntMapOutput) +} + var int16Type = reflect.TypeOf((*int16)(nil)).Elem() // Int16Input is an input type that accepts Int16 and Int16Output values. @@ -3237,6 +3869,54 @@ func (o Int16ArrayMapOutput) MapIndex(k StringInput) Int16ArrayOutput { }).(Int16ArrayOutput) } +var int16MapArrayType = reflect.TypeOf((*[]map[string]int16)(nil)).Elem() + +// Int16MapArrayInput is an input type that accepts Int16MapArray and Int16MapArrayOutput values. +type Int16MapArrayInput interface { + Input + + ToInt16MapArrayOutput() Int16MapArrayOutput + ToInt16MapArrayOutputWithContext(ctx context.Context) Int16MapArrayOutput +} + +// Int16MapArray is an input type for []Int16MapInput values. +type Int16MapArray []Int16MapInput + +// ElementType returns the element type of this Input ([]map[string]int16). +func (Int16MapArray) ElementType() reflect.Type { + return int16MapArrayType +} + +func (in Int16MapArray) ToInt16MapArrayOutput() Int16MapArrayOutput { + return ToOutput(in).(Int16MapArrayOutput) +} + +func (in Int16MapArray) ToInt16MapArrayOutputWithContext(ctx context.Context) Int16MapArrayOutput { + return ToOutputWithContext(ctx, in).(Int16MapArrayOutput) +} + +// Int16MapArrayOutput is an Output that returns []map[string]int16 values. +type Int16MapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]int16). +func (Int16MapArrayOutput) ElementType() reflect.Type { + return int16MapArrayType +} + +func (o Int16MapArrayOutput) ToInt16MapArrayOutput() Int16MapArrayOutput { + return o +} + +func (o Int16MapArrayOutput) ToInt16MapArrayOutputWithContext(ctx context.Context) Int16MapArrayOutput { + return o +} + +func (o Int16MapArrayOutput) Index(i IntInput) Int16MapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]int16 { + return vs[0].([]map[string]int16)[vs[1].(int)] + }).(Int16MapOutput) +} + var int32Type = reflect.TypeOf((*int32)(nil)).Elem() // Int32Input is an input type that accepts Int32 and Int32Output values. @@ -3493,6 +4173,54 @@ func (o Int32ArrayMapOutput) MapIndex(k StringInput) Int32ArrayOutput { }).(Int32ArrayOutput) } +var int32MapArrayType = reflect.TypeOf((*[]map[string]int32)(nil)).Elem() + +// Int32MapArrayInput is an input type that accepts Int32MapArray and Int32MapArrayOutput values. +type Int32MapArrayInput interface { + Input + + ToInt32MapArrayOutput() Int32MapArrayOutput + ToInt32MapArrayOutputWithContext(ctx context.Context) Int32MapArrayOutput +} + +// Int32MapArray is an input type for []Int32MapInput values. +type Int32MapArray []Int32MapInput + +// ElementType returns the element type of this Input ([]map[string]int32). +func (Int32MapArray) ElementType() reflect.Type { + return int32MapArrayType +} + +func (in Int32MapArray) ToInt32MapArrayOutput() Int32MapArrayOutput { + return ToOutput(in).(Int32MapArrayOutput) +} + +func (in Int32MapArray) ToInt32MapArrayOutputWithContext(ctx context.Context) Int32MapArrayOutput { + return ToOutputWithContext(ctx, in).(Int32MapArrayOutput) +} + +// Int32MapArrayOutput is an Output that returns []map[string]int32 values. +type Int32MapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]int32). +func (Int32MapArrayOutput) ElementType() reflect.Type { + return int32MapArrayType +} + +func (o Int32MapArrayOutput) ToInt32MapArrayOutput() Int32MapArrayOutput { + return o +} + +func (o Int32MapArrayOutput) ToInt32MapArrayOutputWithContext(ctx context.Context) Int32MapArrayOutput { + return o +} + +func (o Int32MapArrayOutput) Index(i IntInput) Int32MapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]int32 { + return vs[0].([]map[string]int32)[vs[1].(int)] + }).(Int32MapOutput) +} + var int64Type = reflect.TypeOf((*int64)(nil)).Elem() // Int64Input is an input type that accepts Int64 and Int64Output values. @@ -3749,6 +4477,54 @@ func (o Int64ArrayMapOutput) MapIndex(k StringInput) Int64ArrayOutput { }).(Int64ArrayOutput) } +var int64MapArrayType = reflect.TypeOf((*[]map[string]int64)(nil)).Elem() + +// Int64MapArrayInput is an input type that accepts Int64MapArray and Int64MapArrayOutput values. +type Int64MapArrayInput interface { + Input + + ToInt64MapArrayOutput() Int64MapArrayOutput + ToInt64MapArrayOutputWithContext(ctx context.Context) Int64MapArrayOutput +} + +// Int64MapArray is an input type for []Int64MapInput values. +type Int64MapArray []Int64MapInput + +// ElementType returns the element type of this Input ([]map[string]int64). +func (Int64MapArray) ElementType() reflect.Type { + return int64MapArrayType +} + +func (in Int64MapArray) ToInt64MapArrayOutput() Int64MapArrayOutput { + return ToOutput(in).(Int64MapArrayOutput) +} + +func (in Int64MapArray) ToInt64MapArrayOutputWithContext(ctx context.Context) Int64MapArrayOutput { + return ToOutputWithContext(ctx, in).(Int64MapArrayOutput) +} + +// Int64MapArrayOutput is an Output that returns []map[string]int64 values. +type Int64MapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]int64). +func (Int64MapArrayOutput) ElementType() reflect.Type { + return int64MapArrayType +} + +func (o Int64MapArrayOutput) ToInt64MapArrayOutput() Int64MapArrayOutput { + return o +} + +func (o Int64MapArrayOutput) ToInt64MapArrayOutputWithContext(ctx context.Context) Int64MapArrayOutput { + return o +} + +func (o Int64MapArrayOutput) Index(i IntInput) Int64MapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]int64 { + return vs[0].([]map[string]int64)[vs[1].(int)] + }).(Int64MapOutput) +} + var int8Type = reflect.TypeOf((*int8)(nil)).Elem() // Int8Input is an input type that accepts Int8 and Int8Output values. @@ -4005,6 +4781,54 @@ func (o Int8ArrayMapOutput) MapIndex(k StringInput) Int8ArrayOutput { }).(Int8ArrayOutput) } +var int8MapArrayType = reflect.TypeOf((*[]map[string]int8)(nil)).Elem() + +// Int8MapArrayInput is an input type that accepts Int8MapArray and Int8MapArrayOutput values. +type Int8MapArrayInput interface { + Input + + ToInt8MapArrayOutput() Int8MapArrayOutput + ToInt8MapArrayOutputWithContext(ctx context.Context) Int8MapArrayOutput +} + +// Int8MapArray is an input type for []Int8MapInput values. +type Int8MapArray []Int8MapInput + +// ElementType returns the element type of this Input ([]map[string]int8). +func (Int8MapArray) ElementType() reflect.Type { + return int8MapArrayType +} + +func (in Int8MapArray) ToInt8MapArrayOutput() Int8MapArrayOutput { + return ToOutput(in).(Int8MapArrayOutput) +} + +func (in Int8MapArray) ToInt8MapArrayOutputWithContext(ctx context.Context) Int8MapArrayOutput { + return ToOutputWithContext(ctx, in).(Int8MapArrayOutput) +} + +// Int8MapArrayOutput is an Output that returns []map[string]int8 values. +type Int8MapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]int8). +func (Int8MapArrayOutput) ElementType() reflect.Type { + return int8MapArrayType +} + +func (o Int8MapArrayOutput) ToInt8MapArrayOutput() Int8MapArrayOutput { + return o +} + +func (o Int8MapArrayOutput) ToInt8MapArrayOutputWithContext(ctx context.Context) Int8MapArrayOutput { + return o +} + +func (o Int8MapArrayOutput) Index(i IntInput) Int8MapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]int8 { + return vs[0].([]map[string]int8)[vs[1].(int)] + }).(Int8MapOutput) +} + var stringType = reflect.TypeOf((*string)(nil)).Elem() // StringInput is an input type that accepts String and StringOutput values. @@ -4261,6 +5085,54 @@ func (o StringArrayMapOutput) MapIndex(k StringInput) StringArrayOutput { }).(StringArrayOutput) } +var stringMapArrayType = reflect.TypeOf((*[]map[string]string)(nil)).Elem() + +// StringMapArrayInput is an input type that accepts StringMapArray and StringMapArrayOutput values. +type StringMapArrayInput interface { + Input + + ToStringMapArrayOutput() StringMapArrayOutput + ToStringMapArrayOutputWithContext(ctx context.Context) StringMapArrayOutput +} + +// StringMapArray is an input type for []StringMapInput values. +type StringMapArray []StringMapInput + +// ElementType returns the element type of this Input ([]map[string]string). +func (StringMapArray) ElementType() reflect.Type { + return stringMapArrayType +} + +func (in StringMapArray) ToStringMapArrayOutput() StringMapArrayOutput { + return ToOutput(in).(StringMapArrayOutput) +} + +func (in StringMapArray) ToStringMapArrayOutputWithContext(ctx context.Context) StringMapArrayOutput { + return ToOutputWithContext(ctx, in).(StringMapArrayOutput) +} + +// StringMapArrayOutput is an Output that returns []map[string]string values. +type StringMapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]string). +func (StringMapArrayOutput) ElementType() reflect.Type { + return stringMapArrayType +} + +func (o StringMapArrayOutput) ToStringMapArrayOutput() StringMapArrayOutput { + return o +} + +func (o StringMapArrayOutput) ToStringMapArrayOutputWithContext(ctx context.Context) StringMapArrayOutput { + return o +} + +func (o StringMapArrayOutput) Index(i IntInput) StringMapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]string { + return vs[0].([]map[string]string)[vs[1].(int)] + }).(StringMapOutput) +} + var urnType = reflect.TypeOf((*URN)(nil)).Elem() // URNInput is an input type that accepts URN and URNOutput values. @@ -4532,6 +5404,54 @@ func (o URNArrayMapOutput) MapIndex(k StringInput) URNArrayOutput { }).(URNArrayOutput) } +var uRNMapArrayType = reflect.TypeOf((*[]map[string]URN)(nil)).Elem() + +// URNMapArrayInput is an input type that accepts URNMapArray and URNMapArrayOutput values. +type URNMapArrayInput interface { + Input + + ToURNMapArrayOutput() URNMapArrayOutput + ToURNMapArrayOutputWithContext(ctx context.Context) URNMapArrayOutput +} + +// URNMapArray is an input type for []URNMapInput values. +type URNMapArray []URNMapInput + +// ElementType returns the element type of this Input ([]map[string]URN). +func (URNMapArray) ElementType() reflect.Type { + return uRNMapArrayType +} + +func (in URNMapArray) ToURNMapArrayOutput() URNMapArrayOutput { + return ToOutput(in).(URNMapArrayOutput) +} + +func (in URNMapArray) ToURNMapArrayOutputWithContext(ctx context.Context) URNMapArrayOutput { + return ToOutputWithContext(ctx, in).(URNMapArrayOutput) +} + +// URNMapArrayOutput is an Output that returns []map[string]URN values. +type URNMapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]URN). +func (URNMapArrayOutput) ElementType() reflect.Type { + return uRNMapArrayType +} + +func (o URNMapArrayOutput) ToURNMapArrayOutput() URNMapArrayOutput { + return o +} + +func (o URNMapArrayOutput) ToURNMapArrayOutputWithContext(ctx context.Context) URNMapArrayOutput { + return o +} + +func (o URNMapArrayOutput) Index(i IntInput) URNMapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]URN { + return vs[0].([]map[string]URN)[vs[1].(int)] + }).(URNMapOutput) +} + var uintType = reflect.TypeOf((*uint)(nil)).Elem() // UintInput is an input type that accepts Uint and UintOutput values. @@ -4788,6 +5708,54 @@ func (o UintArrayMapOutput) MapIndex(k StringInput) UintArrayOutput { }).(UintArrayOutput) } +var uintMapArrayType = reflect.TypeOf((*[]map[string]uint)(nil)).Elem() + +// UintMapArrayInput is an input type that accepts UintMapArray and UintMapArrayOutput values. +type UintMapArrayInput interface { + Input + + ToUintMapArrayOutput() UintMapArrayOutput + ToUintMapArrayOutputWithContext(ctx context.Context) UintMapArrayOutput +} + +// UintMapArray is an input type for []UintMapInput values. +type UintMapArray []UintMapInput + +// ElementType returns the element type of this Input ([]map[string]uint). +func (UintMapArray) ElementType() reflect.Type { + return uintMapArrayType +} + +func (in UintMapArray) ToUintMapArrayOutput() UintMapArrayOutput { + return ToOutput(in).(UintMapArrayOutput) +} + +func (in UintMapArray) ToUintMapArrayOutputWithContext(ctx context.Context) UintMapArrayOutput { + return ToOutputWithContext(ctx, in).(UintMapArrayOutput) +} + +// UintMapArrayOutput is an Output that returns []map[string]uint values. +type UintMapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]uint). +func (UintMapArrayOutput) ElementType() reflect.Type { + return uintMapArrayType +} + +func (o UintMapArrayOutput) ToUintMapArrayOutput() UintMapArrayOutput { + return o +} + +func (o UintMapArrayOutput) ToUintMapArrayOutputWithContext(ctx context.Context) UintMapArrayOutput { + return o +} + +func (o UintMapArrayOutput) Index(i IntInput) UintMapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]uint { + return vs[0].([]map[string]uint)[vs[1].(int)] + }).(UintMapOutput) +} + var uint16Type = reflect.TypeOf((*uint16)(nil)).Elem() // Uint16Input is an input type that accepts Uint16 and Uint16Output values. @@ -5044,6 +6012,54 @@ func (o Uint16ArrayMapOutput) MapIndex(k StringInput) Uint16ArrayOutput { }).(Uint16ArrayOutput) } +var uint16MapArrayType = reflect.TypeOf((*[]map[string]uint16)(nil)).Elem() + +// Uint16MapArrayInput is an input type that accepts Uint16MapArray and Uint16MapArrayOutput values. +type Uint16MapArrayInput interface { + Input + + ToUint16MapArrayOutput() Uint16MapArrayOutput + ToUint16MapArrayOutputWithContext(ctx context.Context) Uint16MapArrayOutput +} + +// Uint16MapArray is an input type for []Uint16MapInput values. +type Uint16MapArray []Uint16MapInput + +// ElementType returns the element type of this Input ([]map[string]uint16). +func (Uint16MapArray) ElementType() reflect.Type { + return uint16MapArrayType +} + +func (in Uint16MapArray) ToUint16MapArrayOutput() Uint16MapArrayOutput { + return ToOutput(in).(Uint16MapArrayOutput) +} + +func (in Uint16MapArray) ToUint16MapArrayOutputWithContext(ctx context.Context) Uint16MapArrayOutput { + return ToOutputWithContext(ctx, in).(Uint16MapArrayOutput) +} + +// Uint16MapArrayOutput is an Output that returns []map[string]uint16 values. +type Uint16MapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]uint16). +func (Uint16MapArrayOutput) ElementType() reflect.Type { + return uint16MapArrayType +} + +func (o Uint16MapArrayOutput) ToUint16MapArrayOutput() Uint16MapArrayOutput { + return o +} + +func (o Uint16MapArrayOutput) ToUint16MapArrayOutputWithContext(ctx context.Context) Uint16MapArrayOutput { + return o +} + +func (o Uint16MapArrayOutput) Index(i IntInput) Uint16MapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]uint16 { + return vs[0].([]map[string]uint16)[vs[1].(int)] + }).(Uint16MapOutput) +} + var uint32Type = reflect.TypeOf((*uint32)(nil)).Elem() // Uint32Input is an input type that accepts Uint32 and Uint32Output values. @@ -5300,6 +6316,54 @@ func (o Uint32ArrayMapOutput) MapIndex(k StringInput) Uint32ArrayOutput { }).(Uint32ArrayOutput) } +var uint32MapArrayType = reflect.TypeOf((*[]map[string]uint32)(nil)).Elem() + +// Uint32MapArrayInput is an input type that accepts Uint32MapArray and Uint32MapArrayOutput values. +type Uint32MapArrayInput interface { + Input + + ToUint32MapArrayOutput() Uint32MapArrayOutput + ToUint32MapArrayOutputWithContext(ctx context.Context) Uint32MapArrayOutput +} + +// Uint32MapArray is an input type for []Uint32MapInput values. +type Uint32MapArray []Uint32MapInput + +// ElementType returns the element type of this Input ([]map[string]uint32). +func (Uint32MapArray) ElementType() reflect.Type { + return uint32MapArrayType +} + +func (in Uint32MapArray) ToUint32MapArrayOutput() Uint32MapArrayOutput { + return ToOutput(in).(Uint32MapArrayOutput) +} + +func (in Uint32MapArray) ToUint32MapArrayOutputWithContext(ctx context.Context) Uint32MapArrayOutput { + return ToOutputWithContext(ctx, in).(Uint32MapArrayOutput) +} + +// Uint32MapArrayOutput is an Output that returns []map[string]uint32 values. +type Uint32MapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]uint32). +func (Uint32MapArrayOutput) ElementType() reflect.Type { + return uint32MapArrayType +} + +func (o Uint32MapArrayOutput) ToUint32MapArrayOutput() Uint32MapArrayOutput { + return o +} + +func (o Uint32MapArrayOutput) ToUint32MapArrayOutputWithContext(ctx context.Context) Uint32MapArrayOutput { + return o +} + +func (o Uint32MapArrayOutput) Index(i IntInput) Uint32MapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]uint32 { + return vs[0].([]map[string]uint32)[vs[1].(int)] + }).(Uint32MapOutput) +} + var uint64Type = reflect.TypeOf((*uint64)(nil)).Elem() // Uint64Input is an input type that accepts Uint64 and Uint64Output values. @@ -5556,6 +6620,54 @@ func (o Uint64ArrayMapOutput) MapIndex(k StringInput) Uint64ArrayOutput { }).(Uint64ArrayOutput) } +var uint64MapArrayType = reflect.TypeOf((*[]map[string]uint64)(nil)).Elem() + +// Uint64MapArrayInput is an input type that accepts Uint64MapArray and Uint64MapArrayOutput values. +type Uint64MapArrayInput interface { + Input + + ToUint64MapArrayOutput() Uint64MapArrayOutput + ToUint64MapArrayOutputWithContext(ctx context.Context) Uint64MapArrayOutput +} + +// Uint64MapArray is an input type for []Uint64MapInput values. +type Uint64MapArray []Uint64MapInput + +// ElementType returns the element type of this Input ([]map[string]uint64). +func (Uint64MapArray) ElementType() reflect.Type { + return uint64MapArrayType +} + +func (in Uint64MapArray) ToUint64MapArrayOutput() Uint64MapArrayOutput { + return ToOutput(in).(Uint64MapArrayOutput) +} + +func (in Uint64MapArray) ToUint64MapArrayOutputWithContext(ctx context.Context) Uint64MapArrayOutput { + return ToOutputWithContext(ctx, in).(Uint64MapArrayOutput) +} + +// Uint64MapArrayOutput is an Output that returns []map[string]uint64 values. +type Uint64MapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]uint64). +func (Uint64MapArrayOutput) ElementType() reflect.Type { + return uint64MapArrayType +} + +func (o Uint64MapArrayOutput) ToUint64MapArrayOutput() Uint64MapArrayOutput { + return o +} + +func (o Uint64MapArrayOutput) ToUint64MapArrayOutputWithContext(ctx context.Context) Uint64MapArrayOutput { + return o +} + +func (o Uint64MapArrayOutput) Index(i IntInput) Uint64MapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]uint64 { + return vs[0].([]map[string]uint64)[vs[1].(int)] + }).(Uint64MapOutput) +} + var uint8Type = reflect.TypeOf((*uint8)(nil)).Elem() // Uint8Input is an input type that accepts Uint8 and Uint8Output values. @@ -5812,6 +6924,54 @@ func (o Uint8ArrayMapOutput) MapIndex(k StringInput) Uint8ArrayOutput { }).(Uint8ArrayOutput) } +var uint8MapArrayType = reflect.TypeOf((*[]map[string]uint8)(nil)).Elem() + +// Uint8MapArrayInput is an input type that accepts Uint8MapArray and Uint8MapArrayOutput values. +type Uint8MapArrayInput interface { + Input + + ToUint8MapArrayOutput() Uint8MapArrayOutput + ToUint8MapArrayOutputWithContext(ctx context.Context) Uint8MapArrayOutput +} + +// Uint8MapArray is an input type for []Uint8MapInput values. +type Uint8MapArray []Uint8MapInput + +// ElementType returns the element type of this Input ([]map[string]uint8). +func (Uint8MapArray) ElementType() reflect.Type { + return uint8MapArrayType +} + +func (in Uint8MapArray) ToUint8MapArrayOutput() Uint8MapArrayOutput { + return ToOutput(in).(Uint8MapArrayOutput) +} + +func (in Uint8MapArray) ToUint8MapArrayOutputWithContext(ctx context.Context) Uint8MapArrayOutput { + return ToOutputWithContext(ctx, in).(Uint8MapArrayOutput) +} + +// Uint8MapArrayOutput is an Output that returns []map[string]uint8 values. +type Uint8MapArrayOutput struct{ *OutputState } + +// ElementType returns the element type of this Output ([]map[string]uint8). +func (Uint8MapArrayOutput) ElementType() reflect.Type { + return uint8MapArrayType +} + +func (o Uint8MapArrayOutput) ToUint8MapArrayOutput() Uint8MapArrayOutput { + return o +} + +func (o Uint8MapArrayOutput) ToUint8MapArrayOutputWithContext(ctx context.Context) Uint8MapArrayOutput { + return o +} + +func (o Uint8MapArrayOutput) Index(i IntInput) Uint8MapOutput { + return All(o, i).ApplyT(func(vs []interface{}) map[string]uint8 { + return vs[0].([]map[string]uint8)[vs[1].(int)] + }).(Uint8MapOutput) +} + func getResolvedValue(input Input) (reflect.Value, bool) { switch input := input.(type) { case *asset, *archive: @@ -5826,95 +6986,115 @@ func init() { RegisterOutputType(ArchiveArrayOutput{}) RegisterOutputType(ArchiveMapOutput{}) RegisterOutputType(ArchiveArrayMapOutput{}) + RegisterOutputType(ArchiveMapArrayOutput{}) RegisterOutputType(AssetOutput{}) RegisterOutputType(AssetArrayOutput{}) RegisterOutputType(AssetMapOutput{}) RegisterOutputType(AssetArrayMapOutput{}) + RegisterOutputType(AssetMapArrayOutput{}) RegisterOutputType(AssetOrArchiveOutput{}) RegisterOutputType(AssetOrArchiveArrayOutput{}) RegisterOutputType(AssetOrArchiveMapOutput{}) RegisterOutputType(AssetOrArchiveArrayMapOutput{}) + RegisterOutputType(AssetOrArchiveMapArrayOutput{}) RegisterOutputType(BoolOutput{}) RegisterOutputType(BoolPtrOutput{}) RegisterOutputType(BoolArrayOutput{}) RegisterOutputType(BoolMapOutput{}) RegisterOutputType(BoolArrayMapOutput{}) + RegisterOutputType(BoolMapArrayOutput{}) RegisterOutputType(Float32Output{}) RegisterOutputType(Float32PtrOutput{}) RegisterOutputType(Float32ArrayOutput{}) RegisterOutputType(Float32MapOutput{}) RegisterOutputType(Float32ArrayMapOutput{}) + RegisterOutputType(Float32MapArrayOutput{}) RegisterOutputType(Float64Output{}) RegisterOutputType(Float64PtrOutput{}) RegisterOutputType(Float64ArrayOutput{}) RegisterOutputType(Float64MapOutput{}) RegisterOutputType(Float64ArrayMapOutput{}) + RegisterOutputType(Float64MapArrayOutput{}) RegisterOutputType(IDOutput{}) RegisterOutputType(IDPtrOutput{}) RegisterOutputType(IDArrayOutput{}) RegisterOutputType(IDMapOutput{}) RegisterOutputType(IDArrayMapOutput{}) + RegisterOutputType(IDMapArrayOutput{}) RegisterOutputType(ArrayOutput{}) RegisterOutputType(MapOutput{}) RegisterOutputType(ArrayMapOutput{}) + RegisterOutputType(MapArrayOutput{}) RegisterOutputType(IntOutput{}) RegisterOutputType(IntPtrOutput{}) RegisterOutputType(IntArrayOutput{}) RegisterOutputType(IntMapOutput{}) RegisterOutputType(IntArrayMapOutput{}) + RegisterOutputType(IntMapArrayOutput{}) RegisterOutputType(Int16Output{}) RegisterOutputType(Int16PtrOutput{}) RegisterOutputType(Int16ArrayOutput{}) RegisterOutputType(Int16MapOutput{}) RegisterOutputType(Int16ArrayMapOutput{}) + RegisterOutputType(Int16MapArrayOutput{}) RegisterOutputType(Int32Output{}) RegisterOutputType(Int32PtrOutput{}) RegisterOutputType(Int32ArrayOutput{}) RegisterOutputType(Int32MapOutput{}) RegisterOutputType(Int32ArrayMapOutput{}) + RegisterOutputType(Int32MapArrayOutput{}) RegisterOutputType(Int64Output{}) RegisterOutputType(Int64PtrOutput{}) RegisterOutputType(Int64ArrayOutput{}) RegisterOutputType(Int64MapOutput{}) RegisterOutputType(Int64ArrayMapOutput{}) + RegisterOutputType(Int64MapArrayOutput{}) RegisterOutputType(Int8Output{}) RegisterOutputType(Int8PtrOutput{}) RegisterOutputType(Int8ArrayOutput{}) RegisterOutputType(Int8MapOutput{}) RegisterOutputType(Int8ArrayMapOutput{}) + RegisterOutputType(Int8MapArrayOutput{}) RegisterOutputType(StringOutput{}) RegisterOutputType(StringPtrOutput{}) RegisterOutputType(StringArrayOutput{}) RegisterOutputType(StringMapOutput{}) RegisterOutputType(StringArrayMapOutput{}) + RegisterOutputType(StringMapArrayOutput{}) RegisterOutputType(URNOutput{}) RegisterOutputType(URNPtrOutput{}) RegisterOutputType(URNArrayOutput{}) RegisterOutputType(URNMapOutput{}) RegisterOutputType(URNArrayMapOutput{}) + RegisterOutputType(URNMapArrayOutput{}) RegisterOutputType(UintOutput{}) RegisterOutputType(UintPtrOutput{}) RegisterOutputType(UintArrayOutput{}) RegisterOutputType(UintMapOutput{}) RegisterOutputType(UintArrayMapOutput{}) + RegisterOutputType(UintMapArrayOutput{}) RegisterOutputType(Uint16Output{}) RegisterOutputType(Uint16PtrOutput{}) RegisterOutputType(Uint16ArrayOutput{}) RegisterOutputType(Uint16MapOutput{}) RegisterOutputType(Uint16ArrayMapOutput{}) + RegisterOutputType(Uint16MapArrayOutput{}) RegisterOutputType(Uint32Output{}) RegisterOutputType(Uint32PtrOutput{}) RegisterOutputType(Uint32ArrayOutput{}) RegisterOutputType(Uint32MapOutput{}) RegisterOutputType(Uint32ArrayMapOutput{}) + RegisterOutputType(Uint32MapArrayOutput{}) RegisterOutputType(Uint64Output{}) RegisterOutputType(Uint64PtrOutput{}) RegisterOutputType(Uint64ArrayOutput{}) RegisterOutputType(Uint64MapOutput{}) RegisterOutputType(Uint64ArrayMapOutput{}) + RegisterOutputType(Uint64MapArrayOutput{}) RegisterOutputType(Uint8Output{}) RegisterOutputType(Uint8PtrOutput{}) RegisterOutputType(Uint8ArrayOutput{}) RegisterOutputType(Uint8MapOutput{}) RegisterOutputType(Uint8ArrayMapOutput{}) + RegisterOutputType(Uint8MapArrayOutput{}) } diff --git a/sdk/go/pulumi/types_builtins_test.go b/sdk/go/pulumi/types_builtins_test.go index cf3f5854b..93ae91a16 100644 --- a/sdk/go/pulumi/types_builtins_test.go +++ b/sdk/go/pulumi/types_builtins_test.go @@ -179,6 +179,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyArchiveMapArray", func(t *testing.T) { + o2 := out.ApplyArchiveMapArray(func(v int) []map[string]Archive { return *new([]map[string]Archive) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyArchiveMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]Archive { return *new([]map[string]Archive) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyAsset", func(t *testing.T) { o2 := out.ApplyAsset(func(v int) Asset { return *new(Asset) }) _, known, _, err := await(o2) @@ -227,6 +239,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyAssetMapArray", func(t *testing.T) { + o2 := out.ApplyAssetMapArray(func(v int) []map[string]Asset { return *new([]map[string]Asset) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyAssetMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]Asset { return *new([]map[string]Asset) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyAssetOrArchive", func(t *testing.T) { o2 := out.ApplyAssetOrArchive(func(v int) AssetOrArchive { return *new(AssetOrArchive) }) _, known, _, err := await(o2) @@ -275,6 +299,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyAssetOrArchiveMapArray", func(t *testing.T) { + o2 := out.ApplyAssetOrArchiveMapArray(func(v int) []map[string]AssetOrArchive { return *new([]map[string]AssetOrArchive) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyAssetOrArchiveMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]AssetOrArchive { return *new([]map[string]AssetOrArchive) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyBool", func(t *testing.T) { o2 := out.ApplyBool(func(v int) bool { return *new(bool) }) _, known, _, err := await(o2) @@ -335,6 +371,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyBoolMapArray", func(t *testing.T) { + o2 := out.ApplyBoolMapArray(func(v int) []map[string]bool { return *new([]map[string]bool) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyBoolMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]bool { return *new([]map[string]bool) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyFloat32", func(t *testing.T) { o2 := out.ApplyFloat32(func(v int) float32 { return *new(float32) }) _, known, _, err := await(o2) @@ -395,6 +443,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyFloat32MapArray", func(t *testing.T) { + o2 := out.ApplyFloat32MapArray(func(v int) []map[string]float32 { return *new([]map[string]float32) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyFloat32MapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]float32 { return *new([]map[string]float32) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyFloat64", func(t *testing.T) { o2 := out.ApplyFloat64(func(v int) float64 { return *new(float64) }) _, known, _, err := await(o2) @@ -455,6 +515,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyFloat64MapArray", func(t *testing.T) { + o2 := out.ApplyFloat64MapArray(func(v int) []map[string]float64 { return *new([]map[string]float64) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyFloat64MapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]float64 { return *new([]map[string]float64) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyID", func(t *testing.T) { o2 := out.ApplyID(func(v int) ID { return *new(ID) }) _, known, _, err := await(o2) @@ -515,6 +587,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyIDMapArray", func(t *testing.T) { + o2 := out.ApplyIDMapArray(func(v int) []map[string]ID { return *new([]map[string]ID) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyIDMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]ID { return *new([]map[string]ID) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyArray", func(t *testing.T) { o2 := out.ApplyArray(func(v int) []interface{} { return *new([]interface{}) }) _, known, _, err := await(o2) @@ -551,6 +635,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyMapArray", func(t *testing.T) { + o2 := out.ApplyMapArray(func(v int) []map[string]interface{} { return *new([]map[string]interface{}) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]interface{} { return *new([]map[string]interface{}) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyInt", func(t *testing.T) { o2 := out.ApplyInt(func(v int) int { return *new(int) }) _, known, _, err := await(o2) @@ -611,6 +707,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyIntMapArray", func(t *testing.T) { + o2 := out.ApplyIntMapArray(func(v int) []map[string]int { return *new([]map[string]int) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyIntMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]int { return *new([]map[string]int) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyInt16", func(t *testing.T) { o2 := out.ApplyInt16(func(v int) int16 { return *new(int16) }) _, known, _, err := await(o2) @@ -671,6 +779,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyInt16MapArray", func(t *testing.T) { + o2 := out.ApplyInt16MapArray(func(v int) []map[string]int16 { return *new([]map[string]int16) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyInt16MapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]int16 { return *new([]map[string]int16) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyInt32", func(t *testing.T) { o2 := out.ApplyInt32(func(v int) int32 { return *new(int32) }) _, known, _, err := await(o2) @@ -731,6 +851,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyInt32MapArray", func(t *testing.T) { + o2 := out.ApplyInt32MapArray(func(v int) []map[string]int32 { return *new([]map[string]int32) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyInt32MapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]int32 { return *new([]map[string]int32) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyInt64", func(t *testing.T) { o2 := out.ApplyInt64(func(v int) int64 { return *new(int64) }) _, known, _, err := await(o2) @@ -791,6 +923,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyInt64MapArray", func(t *testing.T) { + o2 := out.ApplyInt64MapArray(func(v int) []map[string]int64 { return *new([]map[string]int64) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyInt64MapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]int64 { return *new([]map[string]int64) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyInt8", func(t *testing.T) { o2 := out.ApplyInt8(func(v int) int8 { return *new(int8) }) _, known, _, err := await(o2) @@ -851,6 +995,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyInt8MapArray", func(t *testing.T) { + o2 := out.ApplyInt8MapArray(func(v int) []map[string]int8 { return *new([]map[string]int8) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyInt8MapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]int8 { return *new([]map[string]int8) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyString", func(t *testing.T) { o2 := out.ApplyString(func(v int) string { return *new(string) }) _, known, _, err := await(o2) @@ -911,6 +1067,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyStringMapArray", func(t *testing.T) { + o2 := out.ApplyStringMapArray(func(v int) []map[string]string { return *new([]map[string]string) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyStringMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]string { return *new([]map[string]string) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyURN", func(t *testing.T) { o2 := out.ApplyURN(func(v int) URN { return *new(URN) }) _, known, _, err := await(o2) @@ -971,6 +1139,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyURNMapArray", func(t *testing.T) { + o2 := out.ApplyURNMapArray(func(v int) []map[string]URN { return *new([]map[string]URN) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyURNMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]URN { return *new([]map[string]URN) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyUint", func(t *testing.T) { o2 := out.ApplyUint(func(v int) uint { return *new(uint) }) _, known, _, err := await(o2) @@ -1031,6 +1211,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyUintMapArray", func(t *testing.T) { + o2 := out.ApplyUintMapArray(func(v int) []map[string]uint { return *new([]map[string]uint) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyUintMapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]uint { return *new([]map[string]uint) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyUint16", func(t *testing.T) { o2 := out.ApplyUint16(func(v int) uint16 { return *new(uint16) }) _, known, _, err := await(o2) @@ -1091,6 +1283,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyUint16MapArray", func(t *testing.T) { + o2 := out.ApplyUint16MapArray(func(v int) []map[string]uint16 { return *new([]map[string]uint16) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyUint16MapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]uint16 { return *new([]map[string]uint16) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyUint32", func(t *testing.T) { o2 := out.ApplyUint32(func(v int) uint32 { return *new(uint32) }) _, known, _, err := await(o2) @@ -1151,6 +1355,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyUint32MapArray", func(t *testing.T) { + o2 := out.ApplyUint32MapArray(func(v int) []map[string]uint32 { return *new([]map[string]uint32) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyUint32MapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]uint32 { return *new([]map[string]uint32) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyUint64", func(t *testing.T) { o2 := out.ApplyUint64(func(v int) uint64 { return *new(uint64) }) _, known, _, err := await(o2) @@ -1211,6 +1427,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyUint64MapArray", func(t *testing.T) { + o2 := out.ApplyUint64MapArray(func(v int) []map[string]uint64 { return *new([]map[string]uint64) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyUint64MapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]uint64 { return *new([]map[string]uint64) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + t.Run("ApplyUint8", func(t *testing.T) { o2 := out.ApplyUint8(func(v int) uint8 { return *new(uint8) }) _, known, _, err := await(o2) @@ -1271,6 +1499,18 @@ func TestOutputApply(t *testing.T) { assert.NoError(t, err) }) + t.Run("ApplyUint8MapArray", func(t *testing.T) { + o2 := out.ApplyUint8MapArray(func(v int) []map[string]uint8 { return *new([]map[string]uint8) }) + _, known, _, err := await(o2) + assert.True(t, known) + assert.NoError(t, err) + + o2 = out.ApplyUint8MapArrayWithContext(context.Background(), func(_ context.Context, v int) []map[string]uint8 { return *new([]map[string]uint8) }) + _, known, _, err = await(o2) + assert.True(t, known) + assert.NoError(t, err) + }) + } // Test that applies return appropriate concrete implementations of Output based on the callback type { @@ -1297,6 +1537,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::ArchiveMapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]Archive { return *new([]map[string]Archive) }).(ArchiveMapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::AssetOutput", func(t *testing.T) { _, ok := out.ApplyT(func(v int) Asset { return *new(Asset) }).(AssetOutput) assert.True(t, ok) @@ -1317,6 +1562,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::AssetMapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]Asset { return *new([]map[string]Asset) }).(AssetMapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::AssetOrArchiveOutput", func(t *testing.T) { _, ok := out.ApplyT(func(v int) AssetOrArchive { return *new(AssetOrArchive) }).(AssetOrArchiveOutput) assert.True(t, ok) @@ -1337,6 +1587,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::AssetOrArchiveMapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]AssetOrArchive { return *new([]map[string]AssetOrArchive) }).(AssetOrArchiveMapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::BoolOutput", func(t *testing.T) { _, ok := out.ApplyT(func(v int) bool { return *new(bool) }).(BoolOutput) assert.True(t, ok) @@ -1362,6 +1617,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::BoolMapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]bool { return *new([]map[string]bool) }).(BoolMapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::Float32Output", func(t *testing.T) { _, ok := out.ApplyT(func(v int) float32 { return *new(float32) }).(Float32Output) assert.True(t, ok) @@ -1387,6 +1647,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::Float32MapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]float32 { return *new([]map[string]float32) }).(Float32MapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::Float64Output", func(t *testing.T) { _, ok := out.ApplyT(func(v int) float64 { return *new(float64) }).(Float64Output) assert.True(t, ok) @@ -1412,6 +1677,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::Float64MapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]float64 { return *new([]map[string]float64) }).(Float64MapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::IDOutput", func(t *testing.T) { _, ok := out.ApplyT(func(v int) ID { return *new(ID) }).(IDOutput) assert.True(t, ok) @@ -1437,6 +1707,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::IDMapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]ID { return *new([]map[string]ID) }).(IDMapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::ArrayOutput", func(t *testing.T) { _, ok := out.ApplyT(func(v int) []interface{} { return *new([]interface{}) }).(ArrayOutput) assert.True(t, ok) @@ -1452,6 +1727,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::MapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]interface{} { return *new([]map[string]interface{}) }).(MapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::IntOutput", func(t *testing.T) { _, ok := out.ApplyT(func(v int) int { return *new(int) }).(IntOutput) assert.True(t, ok) @@ -1477,6 +1757,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::IntMapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]int { return *new([]map[string]int) }).(IntMapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::Int16Output", func(t *testing.T) { _, ok := out.ApplyT(func(v int) int16 { return *new(int16) }).(Int16Output) assert.True(t, ok) @@ -1502,6 +1787,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::Int16MapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]int16 { return *new([]map[string]int16) }).(Int16MapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::Int32Output", func(t *testing.T) { _, ok := out.ApplyT(func(v int) int32 { return *new(int32) }).(Int32Output) assert.True(t, ok) @@ -1527,6 +1817,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::Int32MapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]int32 { return *new([]map[string]int32) }).(Int32MapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::Int64Output", func(t *testing.T) { _, ok := out.ApplyT(func(v int) int64 { return *new(int64) }).(Int64Output) assert.True(t, ok) @@ -1552,6 +1847,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::Int64MapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]int64 { return *new([]map[string]int64) }).(Int64MapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::Int8Output", func(t *testing.T) { _, ok := out.ApplyT(func(v int) int8 { return *new(int8) }).(Int8Output) assert.True(t, ok) @@ -1577,6 +1877,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::Int8MapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]int8 { return *new([]map[string]int8) }).(Int8MapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::StringOutput", func(t *testing.T) { _, ok := out.ApplyT(func(v int) string { return *new(string) }).(StringOutput) assert.True(t, ok) @@ -1602,6 +1907,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::StringMapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]string { return *new([]map[string]string) }).(StringMapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::URNOutput", func(t *testing.T) { _, ok := out.ApplyT(func(v int) URN { return *new(URN) }).(URNOutput) assert.True(t, ok) @@ -1627,6 +1937,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::URNMapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]URN { return *new([]map[string]URN) }).(URNMapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::UintOutput", func(t *testing.T) { _, ok := out.ApplyT(func(v int) uint { return *new(uint) }).(UintOutput) assert.True(t, ok) @@ -1652,6 +1967,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::UintMapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]uint { return *new([]map[string]uint) }).(UintMapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::Uint16Output", func(t *testing.T) { _, ok := out.ApplyT(func(v int) uint16 { return *new(uint16) }).(Uint16Output) assert.True(t, ok) @@ -1677,6 +1997,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::Uint16MapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]uint16 { return *new([]map[string]uint16) }).(Uint16MapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::Uint32Output", func(t *testing.T) { _, ok := out.ApplyT(func(v int) uint32 { return *new(uint32) }).(Uint32Output) assert.True(t, ok) @@ -1702,6 +2027,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::Uint32MapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]uint32 { return *new([]map[string]uint32) }).(Uint32MapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::Uint64Output", func(t *testing.T) { _, ok := out.ApplyT(func(v int) uint64 { return *new(uint64) }).(Uint64Output) assert.True(t, ok) @@ -1727,6 +2057,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::Uint64MapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]uint64 { return *new([]map[string]uint64) }).(Uint64MapArrayOutput) + assert.True(t, ok) + }) + t.Run("ApplyT::Uint8Output", func(t *testing.T) { _, ok := out.ApplyT(func(v int) uint8 { return *new(uint8) }).(Uint8Output) assert.True(t, ok) @@ -1752,6 +2087,11 @@ func TestOutputApply(t *testing.T) { assert.True(t, ok) }) + t.Run("ApplyT::Uint8MapArrayOutput", func(t *testing.T) { + _, ok := out.ApplyT(func(v int) []map[string]uint8 { return *new([]map[string]uint8) }).(Uint8MapArrayOutput) + assert.True(t, ok) + }) + } // Test some chained applies. { @@ -1936,6 +2276,24 @@ func TestToOutputArchiveArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputArchiveMapArray(t *testing.T) { + out := ToOutput(ArchiveMapArray{ArchiveMap{"baz": NewFileArchive("foo.zip")}}) + _, ok := out.(ArchiveMapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(ArchiveMapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputAsset(t *testing.T) { out := ToOutput(NewFileAsset("foo.txt")) _, ok := out.(AssetInput) @@ -2008,6 +2366,24 @@ func TestToOutputAssetArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputAssetMapArray(t *testing.T) { + out := ToOutput(AssetMapArray{AssetMap{"baz": NewFileAsset("foo.txt")}}) + _, ok := out.(AssetMapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(AssetMapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputAssetOrArchive(t *testing.T) { out := ToOutput(NewFileArchive("foo.zip")) _, ok := out.(AssetOrArchiveInput) @@ -2080,6 +2456,24 @@ func TestToOutputAssetOrArchiveArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputAssetOrArchiveMapArray(t *testing.T) { + out := ToOutput(AssetOrArchiveMapArray{AssetOrArchiveMap{"baz": NewFileArchive("foo.zip")}}) + _, ok := out.(AssetOrArchiveMapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(AssetOrArchiveMapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputBool(t *testing.T) { out := ToOutput(Bool(true)) _, ok := out.(BoolInput) @@ -2170,6 +2564,24 @@ func TestToOutputBoolArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputBoolMapArray(t *testing.T) { + out := ToOutput(BoolMapArray{BoolMap{"baz": Bool(true)}}) + _, ok := out.(BoolMapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(BoolMapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputFloat32(t *testing.T) { out := ToOutput(Float32(1.3)) _, ok := out.(Float32Input) @@ -2260,6 +2672,24 @@ func TestToOutputFloat32ArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputFloat32MapArray(t *testing.T) { + out := ToOutput(Float32MapArray{Float32Map{"baz": Float32(1.3)}}) + _, ok := out.(Float32MapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(Float32MapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputFloat64(t *testing.T) { out := ToOutput(Float64(999.9)) _, ok := out.(Float64Input) @@ -2350,6 +2780,24 @@ func TestToOutputFloat64ArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputFloat64MapArray(t *testing.T) { + out := ToOutput(Float64MapArray{Float64Map{"baz": Float64(999.9)}}) + _, ok := out.(Float64MapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(Float64MapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputID(t *testing.T) { out := ToOutput(ID("foo")) _, ok := out.(IDInput) @@ -2440,6 +2888,24 @@ func TestToOutputIDArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputIDMapArray(t *testing.T) { + out := ToOutput(IDMapArray{IDMap{"baz": ID("foo")}}) + _, ok := out.(IDMapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(IDMapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputArray(t *testing.T) { out := ToOutput(Array{String("any")}) _, ok := out.(ArrayInput) @@ -2494,6 +2960,24 @@ func TestToOutputArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputMapArray(t *testing.T) { + out := ToOutput(MapArray{Map{"baz": String("any")}}) + _, ok := out.(MapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(MapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputInt(t *testing.T) { out := ToOutput(Int(42)) _, ok := out.(IntInput) @@ -2584,6 +3068,24 @@ func TestToOutputIntArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputIntMapArray(t *testing.T) { + out := ToOutput(IntMapArray{IntMap{"baz": Int(42)}}) + _, ok := out.(IntMapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(IntMapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputInt16(t *testing.T) { out := ToOutput(Int16(33)) _, ok := out.(Int16Input) @@ -2674,6 +3176,24 @@ func TestToOutputInt16ArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputInt16MapArray(t *testing.T) { + out := ToOutput(Int16MapArray{Int16Map{"baz": Int16(33)}}) + _, ok := out.(Int16MapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(Int16MapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputInt32(t *testing.T) { out := ToOutput(Int32(24)) _, ok := out.(Int32Input) @@ -2764,6 +3284,24 @@ func TestToOutputInt32ArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputInt32MapArray(t *testing.T) { + out := ToOutput(Int32MapArray{Int32Map{"baz": Int32(24)}}) + _, ok := out.(Int32MapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(Int32MapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputInt64(t *testing.T) { out := ToOutput(Int64(15)) _, ok := out.(Int64Input) @@ -2854,6 +3392,24 @@ func TestToOutputInt64ArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputInt64MapArray(t *testing.T) { + out := ToOutput(Int64MapArray{Int64Map{"baz": Int64(15)}}) + _, ok := out.(Int64MapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(Int64MapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputInt8(t *testing.T) { out := ToOutput(Int8(6)) _, ok := out.(Int8Input) @@ -2944,6 +3500,24 @@ func TestToOutputInt8ArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputInt8MapArray(t *testing.T) { + out := ToOutput(Int8MapArray{Int8Map{"baz": Int8(6)}}) + _, ok := out.(Int8MapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(Int8MapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputString(t *testing.T) { out := ToOutput(String("foo")) _, ok := out.(StringInput) @@ -3034,6 +3608,24 @@ func TestToOutputStringArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputStringMapArray(t *testing.T) { + out := ToOutput(StringMapArray{StringMap{"baz": String("foo")}}) + _, ok := out.(StringMapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(StringMapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputURN(t *testing.T) { out := ToOutput(URN("foo")) _, ok := out.(URNInput) @@ -3124,6 +3716,24 @@ func TestToOutputURNArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputURNMapArray(t *testing.T) { + out := ToOutput(URNMapArray{URNMap{"baz": URN("foo")}}) + _, ok := out.(URNMapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(URNMapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputUint(t *testing.T) { out := ToOutput(Uint(42)) _, ok := out.(UintInput) @@ -3214,6 +3824,24 @@ func TestToOutputUintArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputUintMapArray(t *testing.T) { + out := ToOutput(UintMapArray{UintMap{"baz": Uint(42)}}) + _, ok := out.(UintMapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(UintMapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputUint16(t *testing.T) { out := ToOutput(Uint16(33)) _, ok := out.(Uint16Input) @@ -3304,6 +3932,24 @@ func TestToOutputUint16ArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputUint16MapArray(t *testing.T) { + out := ToOutput(Uint16MapArray{Uint16Map{"baz": Uint16(33)}}) + _, ok := out.(Uint16MapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(Uint16MapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputUint32(t *testing.T) { out := ToOutput(Uint32(24)) _, ok := out.(Uint32Input) @@ -3394,6 +4040,24 @@ func TestToOutputUint32ArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputUint32MapArray(t *testing.T) { + out := ToOutput(Uint32MapArray{Uint32Map{"baz": Uint32(24)}}) + _, ok := out.(Uint32MapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(Uint32MapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputUint64(t *testing.T) { out := ToOutput(Uint64(15)) _, ok := out.(Uint64Input) @@ -3484,6 +4148,24 @@ func TestToOutputUint64ArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputUint64MapArray(t *testing.T) { + out := ToOutput(Uint64MapArray{Uint64Map{"baz": Uint64(15)}}) + _, ok := out.(Uint64MapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(Uint64MapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToOutputUint8(t *testing.T) { out := ToOutput(Uint8(6)) _, ok := out.(Uint8Input) @@ -3574,6 +4256,24 @@ func TestToOutputUint8ArrayMap(t *testing.T) { assert.NoError(t, err) } +func TestToOutputUint8MapArray(t *testing.T) { + out := ToOutput(Uint8MapArray{Uint8Map{"baz": Uint8(6)}}) + _, ok := out.(Uint8MapArrayInput) + assert.True(t, ok) + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = ToOutput(out) + _, ok = out.(Uint8MapArrayInput) + assert.True(t, ok) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + // Test that type-specific ToOutput methods work with all builtin input and output types func TestToArchiveOutput(t *testing.T) { @@ -3688,6 +4388,34 @@ func TestToArchiveArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToArchiveMapArrayOutput(t *testing.T) { + in := ArchiveMapArrayInput(ArchiveMapArray{ArchiveMap{"baz": NewFileArchive("foo.zip")}}) + + out := in.ToArchiveMapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToArchiveMapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToArchiveMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToArchiveMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToAssetOutput(t *testing.T) { in := AssetInput(NewFileAsset("foo.txt")) @@ -3800,6 +4528,34 @@ func TestToAssetArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToAssetMapArrayOutput(t *testing.T) { + in := AssetMapArrayInput(AssetMapArray{AssetMap{"baz": NewFileAsset("foo.txt")}}) + + out := in.ToAssetMapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToAssetMapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToAssetMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToAssetMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToAssetOrArchiveOutput(t *testing.T) { in := AssetOrArchiveInput(NewFileArchive("foo.zip")) @@ -3912,6 +4668,34 @@ func TestToAssetOrArchiveArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToAssetOrArchiveMapArrayOutput(t *testing.T) { + in := AssetOrArchiveMapArrayInput(AssetOrArchiveMapArray{AssetOrArchiveMap{"baz": NewFileArchive("foo.zip")}}) + + out := in.ToAssetOrArchiveMapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToAssetOrArchiveMapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToAssetOrArchiveMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToAssetOrArchiveMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToBoolOutput(t *testing.T) { in := BoolInput(Bool(true)) @@ -4052,6 +4836,34 @@ func TestToBoolArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToBoolMapArrayOutput(t *testing.T) { + in := BoolMapArrayInput(BoolMapArray{BoolMap{"baz": Bool(true)}}) + + out := in.ToBoolMapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToBoolMapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToBoolMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToBoolMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToFloat32Output(t *testing.T) { in := Float32Input(Float32(1.3)) @@ -4192,6 +5004,34 @@ func TestToFloat32ArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToFloat32MapArrayOutput(t *testing.T) { + in := Float32MapArrayInput(Float32MapArray{Float32Map{"baz": Float32(1.3)}}) + + out := in.ToFloat32MapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToFloat32MapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToFloat32MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToFloat32MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToFloat64Output(t *testing.T) { in := Float64Input(Float64(999.9)) @@ -4332,6 +5172,34 @@ func TestToFloat64ArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToFloat64MapArrayOutput(t *testing.T) { + in := Float64MapArrayInput(Float64MapArray{Float64Map{"baz": Float64(999.9)}}) + + out := in.ToFloat64MapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToFloat64MapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToFloat64MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToFloat64MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToIDOutput(t *testing.T) { in := IDInput(ID("foo")) @@ -4472,6 +5340,34 @@ func TestToIDArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToIDMapArrayOutput(t *testing.T) { + in := IDMapArrayInput(IDMapArray{IDMap{"baz": ID("foo")}}) + + out := in.ToIDMapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToIDMapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToIDMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToIDMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToArrayOutput(t *testing.T) { in := ArrayInput(Array{String("any")}) @@ -4556,6 +5452,34 @@ func TestToArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToMapArrayOutput(t *testing.T) { + in := MapArrayInput(MapArray{Map{"baz": String("any")}}) + + out := in.ToMapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToMapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToIntOutput(t *testing.T) { in := IntInput(Int(42)) @@ -4696,6 +5620,34 @@ func TestToIntArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToIntMapArrayOutput(t *testing.T) { + in := IntMapArrayInput(IntMapArray{IntMap{"baz": Int(42)}}) + + out := in.ToIntMapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToIntMapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToIntMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToIntMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToInt16Output(t *testing.T) { in := Int16Input(Int16(33)) @@ -4836,6 +5788,34 @@ func TestToInt16ArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToInt16MapArrayOutput(t *testing.T) { + in := Int16MapArrayInput(Int16MapArray{Int16Map{"baz": Int16(33)}}) + + out := in.ToInt16MapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToInt16MapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToInt16MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToInt16MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToInt32Output(t *testing.T) { in := Int32Input(Int32(24)) @@ -4976,6 +5956,34 @@ func TestToInt32ArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToInt32MapArrayOutput(t *testing.T) { + in := Int32MapArrayInput(Int32MapArray{Int32Map{"baz": Int32(24)}}) + + out := in.ToInt32MapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToInt32MapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToInt32MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToInt32MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToInt64Output(t *testing.T) { in := Int64Input(Int64(15)) @@ -5116,6 +6124,34 @@ func TestToInt64ArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToInt64MapArrayOutput(t *testing.T) { + in := Int64MapArrayInput(Int64MapArray{Int64Map{"baz": Int64(15)}}) + + out := in.ToInt64MapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToInt64MapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToInt64MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToInt64MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToInt8Output(t *testing.T) { in := Int8Input(Int8(6)) @@ -5256,6 +6292,34 @@ func TestToInt8ArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToInt8MapArrayOutput(t *testing.T) { + in := Int8MapArrayInput(Int8MapArray{Int8Map{"baz": Int8(6)}}) + + out := in.ToInt8MapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToInt8MapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToInt8MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToInt8MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToStringOutput(t *testing.T) { in := StringInput(String("foo")) @@ -5396,6 +6460,34 @@ func TestToStringArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToStringMapArrayOutput(t *testing.T) { + in := StringMapArrayInput(StringMapArray{StringMap{"baz": String("foo")}}) + + out := in.ToStringMapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToStringMapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToStringMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToStringMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToURNOutput(t *testing.T) { in := URNInput(URN("foo")) @@ -5536,6 +6628,34 @@ func TestToURNArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToURNMapArrayOutput(t *testing.T) { + in := URNMapArrayInput(URNMapArray{URNMap{"baz": URN("foo")}}) + + out := in.ToURNMapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToURNMapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToURNMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToURNMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToUintOutput(t *testing.T) { in := UintInput(Uint(42)) @@ -5676,6 +6796,34 @@ func TestToUintArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToUintMapArrayOutput(t *testing.T) { + in := UintMapArrayInput(UintMapArray{UintMap{"baz": Uint(42)}}) + + out := in.ToUintMapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToUintMapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToUintMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToUintMapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToUint16Output(t *testing.T) { in := Uint16Input(Uint16(33)) @@ -5816,6 +6964,34 @@ func TestToUint16ArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToUint16MapArrayOutput(t *testing.T) { + in := Uint16MapArrayInput(Uint16MapArray{Uint16Map{"baz": Uint16(33)}}) + + out := in.ToUint16MapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToUint16MapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToUint16MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToUint16MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToUint32Output(t *testing.T) { in := Uint32Input(Uint32(24)) @@ -5956,6 +7132,34 @@ func TestToUint32ArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToUint32MapArrayOutput(t *testing.T) { + in := Uint32MapArrayInput(Uint32MapArray{Uint32Map{"baz": Uint32(24)}}) + + out := in.ToUint32MapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToUint32MapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToUint32MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToUint32MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToUint64Output(t *testing.T) { in := Uint64Input(Uint64(15)) @@ -6096,6 +7300,34 @@ func TestToUint64ArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToUint64MapArrayOutput(t *testing.T) { + in := Uint64MapArrayInput(Uint64MapArray{Uint64Map{"baz": Uint64(15)}}) + + out := in.ToUint64MapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToUint64MapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToUint64MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToUint64MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + func TestToUint8Output(t *testing.T) { in := Uint8Input(Uint8(6)) @@ -6236,6 +7468,34 @@ func TestToUint8ArrayMapOutput(t *testing.T) { assert.NoError(t, err) } +func TestToUint8MapArrayOutput(t *testing.T) { + in := Uint8MapArrayInput(Uint8MapArray{Uint8Map{"baz": Uint8(6)}}) + + out := in.ToUint8MapArrayOutput() + + _, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToUint8MapArrayOutput() + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = in.ToUint8MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) + + out = out.ToUint8MapArrayOutputWithContext(context.Background()) + + _, known, _, err = await(out) + assert.True(t, known) + assert.NoError(t, err) +} + // Test type-specific ToOutput methods for builtins that implement other builtin input types. func TestBuiltinConversions(t *testing.T) { archiveIn := NewFileArchive("foo.zip") @@ -6537,6 +7797,20 @@ func TestArchiveArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]Archive)[0], iv) } +func TestArchiveMapArrayIndex(t *testing.T) { + out := (ArchiveMapArray{ArchiveMap{"baz": NewFileArchive("foo.zip")}}).ToArchiveMapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]Archive)[0], iv) +} + func TestAssetArrayIndex(t *testing.T) { out := (AssetArray{NewFileAsset("foo.txt")}).ToAssetArrayOutput() @@ -6551,6 +7825,20 @@ func TestAssetArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]Asset)[0], iv) } +func TestAssetMapArrayIndex(t *testing.T) { + out := (AssetMapArray{AssetMap{"baz": NewFileAsset("foo.txt")}}).ToAssetMapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]Asset)[0], iv) +} + func TestAssetOrArchiveArrayIndex(t *testing.T) { out := (AssetOrArchiveArray{NewFileArchive("foo.zip")}).ToAssetOrArchiveArrayOutput() @@ -6565,6 +7853,20 @@ func TestAssetOrArchiveArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]AssetOrArchive)[0], iv) } +func TestAssetOrArchiveMapArrayIndex(t *testing.T) { + out := (AssetOrArchiveMapArray{AssetOrArchiveMap{"baz": NewFileArchive("foo.zip")}}).ToAssetOrArchiveMapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]AssetOrArchive)[0], iv) +} + func TestBoolArrayIndex(t *testing.T) { out := (BoolArray{Bool(true)}).ToBoolArrayOutput() @@ -6579,6 +7881,20 @@ func TestBoolArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]bool)[0], iv) } +func TestBoolMapArrayIndex(t *testing.T) { + out := (BoolMapArray{BoolMap{"baz": Bool(true)}}).ToBoolMapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]bool)[0], iv) +} + func TestFloat32ArrayIndex(t *testing.T) { out := (Float32Array{Float32(1.3)}).ToFloat32ArrayOutput() @@ -6593,6 +7909,20 @@ func TestFloat32ArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]float32)[0], iv) } +func TestFloat32MapArrayIndex(t *testing.T) { + out := (Float32MapArray{Float32Map{"baz": Float32(1.3)}}).ToFloat32MapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]float32)[0], iv) +} + func TestFloat64ArrayIndex(t *testing.T) { out := (Float64Array{Float64(999.9)}).ToFloat64ArrayOutput() @@ -6607,6 +7937,20 @@ func TestFloat64ArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]float64)[0], iv) } +func TestFloat64MapArrayIndex(t *testing.T) { + out := (Float64MapArray{Float64Map{"baz": Float64(999.9)}}).ToFloat64MapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]float64)[0], iv) +} + func TestIDArrayIndex(t *testing.T) { out := (IDArray{ID("foo")}).ToIDArrayOutput() @@ -6621,6 +7965,20 @@ func TestIDArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]ID)[0], iv) } +func TestIDMapArrayIndex(t *testing.T) { + out := (IDMapArray{IDMap{"baz": ID("foo")}}).ToIDMapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]ID)[0], iv) +} + func TestArrayIndex(t *testing.T) { out := (Array{String("any")}).ToArrayOutput() @@ -6635,6 +7993,20 @@ func TestArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]interface{})[0], iv) } +func TestMapArrayIndex(t *testing.T) { + out := (MapArray{Map{"baz": String("any")}}).ToMapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]interface{})[0], iv) +} + func TestIntArrayIndex(t *testing.T) { out := (IntArray{Int(42)}).ToIntArrayOutput() @@ -6649,6 +8021,20 @@ func TestIntArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]int)[0], iv) } +func TestIntMapArrayIndex(t *testing.T) { + out := (IntMapArray{IntMap{"baz": Int(42)}}).ToIntMapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]int)[0], iv) +} + func TestInt16ArrayIndex(t *testing.T) { out := (Int16Array{Int16(33)}).ToInt16ArrayOutput() @@ -6663,6 +8049,20 @@ func TestInt16ArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]int16)[0], iv) } +func TestInt16MapArrayIndex(t *testing.T) { + out := (Int16MapArray{Int16Map{"baz": Int16(33)}}).ToInt16MapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]int16)[0], iv) +} + func TestInt32ArrayIndex(t *testing.T) { out := (Int32Array{Int32(24)}).ToInt32ArrayOutput() @@ -6677,6 +8077,20 @@ func TestInt32ArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]int32)[0], iv) } +func TestInt32MapArrayIndex(t *testing.T) { + out := (Int32MapArray{Int32Map{"baz": Int32(24)}}).ToInt32MapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]int32)[0], iv) +} + func TestInt64ArrayIndex(t *testing.T) { out := (Int64Array{Int64(15)}).ToInt64ArrayOutput() @@ -6691,6 +8105,20 @@ func TestInt64ArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]int64)[0], iv) } +func TestInt64MapArrayIndex(t *testing.T) { + out := (Int64MapArray{Int64Map{"baz": Int64(15)}}).ToInt64MapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]int64)[0], iv) +} + func TestInt8ArrayIndex(t *testing.T) { out := (Int8Array{Int8(6)}).ToInt8ArrayOutput() @@ -6705,6 +8133,20 @@ func TestInt8ArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]int8)[0], iv) } +func TestInt8MapArrayIndex(t *testing.T) { + out := (Int8MapArray{Int8Map{"baz": Int8(6)}}).ToInt8MapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]int8)[0], iv) +} + func TestStringArrayIndex(t *testing.T) { out := (StringArray{String("foo")}).ToStringArrayOutput() @@ -6719,6 +8161,20 @@ func TestStringArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]string)[0], iv) } +func TestStringMapArrayIndex(t *testing.T) { + out := (StringMapArray{StringMap{"baz": String("foo")}}).ToStringMapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]string)[0], iv) +} + func TestURNArrayIndex(t *testing.T) { out := (URNArray{URN("foo")}).ToURNArrayOutput() @@ -6733,6 +8189,20 @@ func TestURNArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]URN)[0], iv) } +func TestURNMapArrayIndex(t *testing.T) { + out := (URNMapArray{URNMap{"baz": URN("foo")}}).ToURNMapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]URN)[0], iv) +} + func TestUintArrayIndex(t *testing.T) { out := (UintArray{Uint(42)}).ToUintArrayOutput() @@ -6747,6 +8217,20 @@ func TestUintArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]uint)[0], iv) } +func TestUintMapArrayIndex(t *testing.T) { + out := (UintMapArray{UintMap{"baz": Uint(42)}}).ToUintMapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]uint)[0], iv) +} + func TestUint16ArrayIndex(t *testing.T) { out := (Uint16Array{Uint16(33)}).ToUint16ArrayOutput() @@ -6761,6 +8245,20 @@ func TestUint16ArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]uint16)[0], iv) } +func TestUint16MapArrayIndex(t *testing.T) { + out := (Uint16MapArray{Uint16Map{"baz": Uint16(33)}}).ToUint16MapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]uint16)[0], iv) +} + func TestUint32ArrayIndex(t *testing.T) { out := (Uint32Array{Uint32(24)}).ToUint32ArrayOutput() @@ -6775,6 +8273,20 @@ func TestUint32ArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]uint32)[0], iv) } +func TestUint32MapArrayIndex(t *testing.T) { + out := (Uint32MapArray{Uint32Map{"baz": Uint32(24)}}).ToUint32MapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]uint32)[0], iv) +} + func TestUint64ArrayIndex(t *testing.T) { out := (Uint64Array{Uint64(15)}).ToUint64ArrayOutput() @@ -6789,6 +8301,20 @@ func TestUint64ArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]uint64)[0], iv) } +func TestUint64MapArrayIndex(t *testing.T) { + out := (Uint64MapArray{Uint64Map{"baz": Uint64(15)}}).ToUint64MapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]uint64)[0], iv) +} + func TestUint8ArrayIndex(t *testing.T) { out := (Uint8Array{Uint8(6)}).ToUint8ArrayOutput() @@ -6803,6 +8329,20 @@ func TestUint8ArrayIndex(t *testing.T) { assert.EqualValues(t, av.([]uint8)[0], iv) } +func TestUint8MapArrayIndex(t *testing.T) { + out := (Uint8MapArray{Uint8Map{"baz": Uint8(6)}}).ToUint8MapArrayOutput() + + av, known, _, err := await(out) + assert.True(t, known) + assert.NoError(t, err) + + iv, known, _, err := await(out.Index(Int(0))) + assert.True(t, known) + assert.NoError(t, err) + + assert.EqualValues(t, av.([]map[string]uint8)[0], iv) +} + // Test map indexers. func TestArchiveMapIndex(t *testing.T) {