func FromBool(b bool) *Value {
	return &Value{value: b}
}

// FromTimestamp creates a Value from a timestamp
func FromTimestamp(t time.Time) *Value {
	return &Value{value: t}
}

// FromNull creates a Value with Null value
func FromNull() *Value {
	return &Value{value: nil}
}

// FromMissing creates a Value with Missing value
func FromMissing() *Value {
	return &Value{value: Missing{}}
}

      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()
    }

      Key key1 = new Key(1);
      String value1 = key1.toString();
      Key key2 = new Key(2);
      String value2 = key2.toString();
      assertSame(value1, cache.getUnchecked(key1));
      assertSame(value2, cache.getUnchecked(key2));
      assertEquals(ImmutableSet.of(key1, key2), cache.asMap().keySet());
      assertThat(cache.asMap().values()).containsExactly(value1, value2);
      assertEquals(

        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)

		t.Errorf("Expected parent goroutine's profile labels to be empty before Do, got %v", gotLabels)
	}

	Do(context.Background(), Labels("key1", "value1", "key2", "value2"), func(ctx context.Context) {
		wantLabels := map[string]string{"key1": "value1", "key2": "value2"}
		if gotLabels := getProfLabel(); !reflect.DeepEqual(gotLabels, wantLabels) {
			t.Errorf("parent goroutine's profile labels: got %v, want %v", gotLabels, wantLabels)
		}

        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)

	for _, x := range a {
		x.Uses++
	}
}
func (v *Value) SetArg(i int, w *Value) {
	v.Args[i].Uses--
	v.Args[i] = w
	w.Uses++
}
func (v *Value) SetArgs1(a *Value) {
	v.resetArgs()
	v.AddArg(a)
}
func (v *Value) SetArgs2(a, b *Value) {
	v.resetArgs()
	v.AddArg(a)
	v.AddArg(b)
}
func (v *Value) SetArgs3(a, b, c *Value) {
	v.resetArgs()
	v.AddArg(a)
	v.AddArg(b)
	v.AddArg(c)