result string
	}{
		{JSONSchemaPropsOrBoolHolder{}, `{"val1":false}`},

		{JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{Schema: &JSONSchemaProps{}}}, `{"val1":{}}`},
		{JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{Schema: &JSONSchemaProps{Type: "string"}}}, `{"val1":{"type":"string"}}`},
		{JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{}}, `{"val1":false}`},

		result string
	}{
		{JSONSchemaPropsOrBoolHolder{}, `{"val1":false}`},

		{JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{Schema: &JSONSchemaProps{}}}, `{"val1":{}}`},
		{JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{Schema: &JSONSchemaProps{Type: "string"}}}, `{"val1":{"type":"string"}}`},
		{JSONSchemaPropsOrBoolHolder{JSPoB: JSONSchemaPropsOrBool{}}, `{"val1":false}`},

func.func @f() {
  // CHECK: "tf.VarHandleOp"
  // CHECK: "tf.ReadVariableOp"
  %val0 = "tf.VariableV2"() {_class = ["loc:@v"], container = "", device = "", shape = #tf_type.shape<96>, shared_name = ""} : () -> tensor<96x!tf_type.f32ref>
  %val1 = "tf.Identity"(%val0) : (tensor<96x!tf_type.f32ref>) -> tensor<96xf32>
  func.return
}

// -----

// Test case: Basic converting. '_class' attribute is at IdentityOp.

func.func @f() {

				Topology: map[string]string{
					"key1": "val1",
				},
			},
			internal: discovery.Endpoint{
				DeprecatedTopology: map[string]string{
					"key1": "val1",
				},
			},
		},
		{
			desc: "non empty topology map, with zone",
			external: v1beta1.Endpoint{
				Topology: map[string]string{
					"key1":                   "val1",
					corev1.LabelTopologyZone: "zone1",
				},
			},

	return func(i, j int) {
		if uint(i) >= uint(s.Len) || uint(j) >= uint(s.Len) {
			panic("reflect: slice index out of range")
		}
		val1 := arrayAt(s.Data, i, size, "i < s.Len")
		val2 := arrayAt(s.Data, j, size, "j < s.Len")
		typedmemmove(typ, tmp, val1)
		typedmemmove(typ, val1, val2)
		typedmemmove(typ, val2, tmp)
	}

}

type testRules struct{}

func newTestRules() Rules[int] {
	return testRules{}
}

func (r testRules) Hash(val int) int {
	return val % 16
}

func (r testRules) Equivalent(val1 int, val2 int) bool {
	return val1 == val2
}

func (r testRules) SameRules(other Rules[int]) bool {
	_, ok := other.(testRules)
	return ok
}

type testRules2 struct{}

func newTestRules2() Rules[string] {

import spock.lang.Specification

import static org.gradle.internal.buildoption.BuildOptionFixture.*

class ListBuildOptionTest extends Specification {

    private static final List<String> SAMPLE_VALUES = ['val1', 'val2', 'val3']

    def testSettings = new TestSettings()
    def commandLineParser = new CommandLineParser()

    def "can apply from property"() {
        given:

	return func(i, j int) {
		if uint(i) >= uint(s.Len) || uint(j) >= uint(s.Len) {
			panic("reflect: slice index out of range")
		}
		val1 := arrayAt(s.Data, i, size, "i < s.Len")
		val2 := arrayAt(s.Data, j, size, "j < s.Len")
		typedmemmove(typ, tmp, val1)
		typedmemmove(typ, val1, val2)
		typedmemmove(typ, val2, tmp)
	}

	}
}

var testYaml = `
features:
  values: [hello1, hello2]
  key2:
    values: [val1, val2]
`

const expectedResult = `	Hello1	Feature = "hello1"
	Hello2	Feature = "hello2"
	Key2_Val1	Feature = "key2.val1"
	Key2_Val2	Feature = "key2.val2"`

func TestReadVal(t *testing.T) {
	m := make(map[any]any)

	err := yaml.Unmarshal([]byte(testYaml), &m)

import jcifs.smb1.util.Hexdump;

public abstract class DcerpcHandle implements DcerpcConstants {

    /* Bindings are in the form:
     * proto:\\server[key1=val1,key2=val2]
     * or
     * proto:server[key1=val1,key2=val2]
     * or
     * proto:[key1=val1,key2=val2]
     *
     * If a key is absent it is assumed to be 'endpoint'. Thus the
     * following are equivalent:
     * proto:\\ts0.win.net[endpoint=\pipe\srvsvc]