)

func main() {
	foo := &Foo[string, int]{
		valueA: "i am a string",
		valueB: 123,
	}
	if got, want := fmt.Sprintln(foo), "i am a string 123\n"; got != want {
		panic(fmt.Sprintf("got %s, want %s", got, want))
	}
}

type Foo[T1 any, T2 any] struct {
	valueA T1
	valueB T2
}

func (f *Foo[_, _]) String() string {
	return fmt.Sprintf("%v %v", f.valueA, f.valueB)

    def "can add amounts with different units of same quantity"() {
        def sum = Amount.valueOf(valueA, unitsA) + Amount.valueOf(valueB, unitsB)
        expect:
        sum == Amount.valueOf(valueC, unitsC)
        sum.toString() == Amount.valueOf(valueC, unitsC).toString()

        where:
        valueA | unitsA        | valueB | unitsB        | valueC  | unitsC
        0      | Fruit.apples  | 0      | Fruit.oranges | 0       | Fruit.apples

// license that can be found in the LICENSE file.

package b

import "fmt"

type Foo[T1 ~string, T2 ~int] struct {
	ValueA T1
	ValueB T2
}

func (f *Foo[_, _]) String() string {
	return fmt.Sprintf("%v %v", f.ValueA, f.ValueB)

    @TaskAction
    void doSomething() {
    }

    @Option(option = "valueB", description = "descB")
    public void setValueB(boolean value) {
    }

    @Option(option = "valueA", description = "descA")
    public void setValueA(boolean value) {
    }

    @Option(option = "valueC", description = "descC")
    public void setValueC(boolean value) {
    }

// a generic type that has multiple blank type params.

package main

import (
	"./b"
	"fmt"
)

func main() {
	foo := &b.Foo[string, int]{
		ValueA: "i am a string",
		ValueB: 123,
	}
	if got, want := fmt.Sprintln(foo), "i am a string 123\n"; got != want {
		panic(fmt.Sprintf("got %s, want %s", got, want))
	}

		},
		{
			name:  "TokenIssuer1NestedClaims1",
			token: TokenIssuer1WithNestedClaims1,
			wantClaims: map[string]any{
				"nested": map[string]any{
					"key1": []any{"valueA", "valueB"},
					"nested-2": map[string]any{
						"key1": []any{"valueA", "valueB"},
					},
				},
				"iss": "******@****.***",
				"sub": "sub-1",
				"exp": 4757607896.0,
			},
		},
		{
			name:  "TokenIssuer1NestedClaims2",

	// Payload {
	//  "exp": 4757607896,
	//  "iat": 1604007896,
	//  "iss": "******@****.***",
	//  "nested": {
	//    "key1": [
	//      "valueA",
	//      "valueB"
	//    ],
	//    "nested-2": {
	//      "key1": [
	//        "valueA",
	//        "valueB"
	//      ]
	//    }
	//  },
	//  "sub": "sub-1"
	// }

        then:
        output.contains """
Options
     --valueA     descA

     --no-valueA     Disables option --valueA.

     --valueB     descB

     --no-valueB     Disables option --valueB.

     --valueC     descC

     --no-valueC     Disables option --valueC."""
    }

      values: ["valueB"]
  - to:
    - operation:
        paths: ["/nested-non-exist"]
        methods: ["GET"]
    when:
    - key: request.auth.claims[nested][non-exist]
      values: ["valueC"]
  - to:
    - operation:
        paths: ["/nested-key2"]
        methods: ["GET"]
    when:
    - key: request.auth.claims[nested][key2]
      values: ["valueC"]
  - to:
    - operation:

      context: SIDECAR_OUTBOUND
    patch:
      operation: MERGE
      value:
        request_headers_to_add:
        - header:
            key: x-vhost-outbound
            value: "hello world"
  - applyTo: CLUSTER
    match:
      context: SIDECAR_OUTBOUND
      cluster: {}
    patch:
      operation: MERGE
      value:
        http2_protocol_options: {}
---