```Python
old_dict = {
    "old key": "old value",
    "second old key": "second old value",
}
new_dict = {**old_dict, "new key": "new value"}
```

Hier wird `new_dict` alle Schlüssel-Wert-Paare von `old_dict` plus das neue Schlüssel-Wert-Paar enthalten:

```Python
{
    "old key": "old value",
    "second old key": "second old value",
    "new key": "new value",
}
```

        MojoDescriptor mojoDescriptor = new MojoDescriptor();
        Parameter param1 = new Parameter();
        param1.setName("param1");
        param1.setDefaultValue("value1");
        mojoDescriptor.addParameter(param1);

        assertEquals(1, mojoDescriptor.getParameters().size());

        assertEquals(
                mojoDescriptor.getParameters().size(),

			accessKey:          creds.AccessKey,
			secretKey:          creds.SecretKey,
			body:               []byte(`<LifecycleConfiguration><Rule><ID>id</ID><Filter><Prefix>logs/</Prefix><Tag><Key>Key1</Key><Value>Value1</Value></Tag></Filter><Status>Enabled</Status><Expiration><Days>365</Days></Expiration></Rule></LifecycleConfiguration>`),
			expectedRespStatus: http.StatusBadRequest,
			lifecycleResponse:  []byte(``),

pkg reflect, method (Value) Field(int) Value
pkg reflect, method (Value) FieldByIndex([]int) Value
pkg reflect, method (Value) FieldByName(string) Value
pkg reflect, method (Value) FieldByNameFunc(func(string) bool) Value
pkg reflect, method (Value) Float() float64
pkg reflect, method (Value) Index(int) Value
pkg reflect, method (Value) Int() int64
pkg reflect, method (Value) Interface() interface{}

// APIs specific to Eager modes
// -----------------------------------------------------------------------------

// Temporary APIs till we figure out how to create scalar valued Eager
// tensors and how to get value out of eager abstract tensors.
TF_AbstractTensor* TF_CreateAbstractTensorFromEagerTensor(TFE_TensorHandle* t,
                                                          TF_Status* s);

      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)

    private static final String RESULT3 = COMMENT + LINE_SEPARATOR + COMMENT + LINE_SEPARATOR + KEY1A + " = " + VALUE1
            + "\\" + LINE_SEPARATOR + VALUE1 + LINE_SEPARATOR;

    @Test
    public void testSaveComment3() throws Exception {
        properties.put(KEY1, List.of(new String[] {COMMENT, COMMENT}), List.of(new String[] {VALUE1, VALUE1}));
        StringWriter sw = new StringWriter();
        properties.save(sw);

		return p
	}
	return ""
}

// Tags - a rule can either have tag under <filter></filter> or under
// <filter><and></and></filter>. This method returns all the tags from the
// rule in the format tag1=value1&tag2=value2
func (r Rule) Tags() string {
	if !r.Filter.Tag.IsEmpty() {
		return r.Filter.Tag.String()
	}
	if len(r.Filter.And.Tags) != 0 {
		var buf bytes.Buffer
		for _, t := range r.Filter.And.Tags {

 members$lzycompute(); public final scala.collection.immutable.List elements(); public static Enumeration$Value value(String); public static Enumeration$Value value(String, int); public final Enumeration$Value toValue(String); public void Enumeration(); } xsbt/boot/Value$.class package xsbt.boot; public final synchronized class Value$ implements scala.Serializable { public static final Value$ MODULE$; public static void <clinit>(); public static Object get$3652317c(scala.Serializable); public static...

            "loc": [
                "path",
                "item_id"
            ],
            "msg": "value is not a valid integer",
            "type": "type_error.integer"
        }
    ]
}
```

eine Textversion:

```
1 validation error
path -> item_id
  value is not a valid integer (type=type_error.integer)
```

#### `RequestValidationError` vs. `ValidationError`