headersOf("header1", "valué1")
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("Unexpected char 0xe9 at 4 in header1 value: valué1")
    }
  }

  @Test fun mapFactoryRejectsUnicodeInHeaderName() {
    assertFailsWith<IllegalArgumentException> {
      mapOf("héader1" to "value1").toHeaders()
    }.also { expected ->
      assertThat(expected.message)

                prop = ['key1': 'value1']
                prop.put('key2', 'value2')
                prop.put('key3', project.provider { 'value3' })
                prop.putAll(['key4': 'value4'])
                prop.putAll(project.provider { ['key5': 'value5'] })
                expected = ['key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4', 'key5': 'value5']
            }
            '''.stripIndent()
    }

        value2.explicit

        def value3 = options.getOption(new InternalFlag("prop3", true))
        !value3.get()
        value3.explicit

        def value4 = options.getOption(new InternalFlag("prop4", false))
        value4.get()
        value4.explicit
    }

    def "uses default for boolean option when system property is not set"() {
        expect:

	// Output:
	// option1=value1
	// option2=value2
	// option3=value3
}

func ExampleRegexp_ExpandString() {
	content := `
	# comment line
	option1: value1
	option2: value2

	# another comment line
	option3: value3
`

	// Regex pattern captures "key: value" pair from the content.
	pattern := regexp.MustCompile(`(?m)(?P<key>\w+):\s+(?P<value>\w+)$`)

			return fmt.Errorf("expected non-nil value, got nil")
		}
	} else {
		// Check that the correlated object has the expected values
		if !reflect.DeepEqual(correlatedObject.Value, c.NewValue) {
			return fmt.Errorf("expected value %v, got %v", c.NewValue, correlatedObject.Value)
		}
		if !reflect.DeepEqual(correlatedObject.OldValue, c.OldValue) {
			return fmt.Errorf("expected old value %v, got %v", c.OldValue, correlatedObject.OldValue)

        properties.setProperty("prop1", "value1")
        properties.setProperty("prop2", "value2")
        configurationCacheRoundtripOf(properties).run {
            assertThat(properties, equalTo(this))
        }
    }

    @Test
    fun `can handle Hashtable`() {
        val hashtable = Hashtable<String, Any>(100)
        hashtable.put("key1", "value1")
        hashtable.put("key2", true)

        "java.util.Collection<String>"        | "['value1', 'value2']"                                | "['value1'] as SortedSet"                                    | null
        "java.util.Set<String>"               | "['value1', 'value2'] as Set"                         | "['value1'] as Set"                                          | null

		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(&v1beta1.AdmissionReview{
			Response: &v1beta1.AdmissionResponse{
				Allowed: true,
				AuditAnnotations: map[string]string{
					"key1": "value1",
				},
			},
		})
	case "/removeLabel":
		w.Header().Set("Content-Type", "application/json")
		pt := v1beta1.PatchTypeJSONPatch
		json.NewEncoder(w).Encode(&v1beta1.AdmissionReview{

//go:generate stringer -type Kind

// Kind specifies the kind of value represented by a [Value].
type Kind int

const (
	// unknown values
	Unknown Kind = iota

	// non-numeric values
	Bool
	String

	// numeric values
	Int
	Float
	Complex
)

// A Value represents the value of a Go constant.
type Value interface {
	// Kind returns the value kind.
	Kind() Kind

package trace

import "fmt"

// Value is a dynamically-typed value obtained from a trace.
type Value struct {
	kind   ValueKind
	scalar uint64
}

// ValueKind is the type of a dynamically-typed value from a trace.
type ValueKind uint8

const (
	ValueBad ValueKind = iota
	ValueUint64
)

// Kind returns the ValueKind of the value.
//
// It represents the underlying structure of the value.