fragBuf.reset();
            msg.decode_header(fragBuf);
            final int stub_frag_len = msg.length - 24;
            if (off + stub_frag_len > in.length) {
                // shouldn't happen if alloc_hint is correct or greater
                final byte[] tmp = new byte[off + stub_frag_len];
                System.arraycopy(in, 0, tmp, 0, off);
                in = tmp;
            }

	tok := in.Stack.Next()
	if tok != scanner.Int {
		in.expectText("expected line number after #line")
	}
	line, err := strconv.Atoi(in.Stack.Text())
	if err != nil {
		in.Error("error parsing #line (cannot happen):", err)
	}
	tok = in.Stack.Next()
	if tok != scanner.String {
		in.expectText("expected file name in #line")
	}
	file, err := strconv.Unquote(in.Stack.Text())
	if err != nil {

		return x, nil
	case []byte:
		return string(x), nil
	case bool:
		return fmt.Sprintf("%v", x), nil
	case nil:
		// FIXME: verify this case is correct
		return "NULL", nil
	}
	// This does not happen
	return "", errCastFailure(fmt.Sprintf("cannot cast %v to string type", v.GetTypeString()))
}

func timestampCast(v *Value) (t time.Time, _ error) {
	switch x := v.value.(type) {
	case string:

  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  @AndroidIncompatible // TODO(cpovirk): ClassNotFoundException: com.google.common.base.Function
  // (I suspect that this and the other similar failures happen with ArbitraryInstances proxies.)
  public void testEqualsAndSerializable() throws Exception {
    new ClassSanityTester().forAllPublicStaticMethods(Functions.class).testEqualsAndSerializable();
  }

  @J2ktIncompatible

  public void testContainsAll() {
    Range<Integer> range = Range.closed(3, 5);
    assertTrue(range.containsAll(asList(3, 3, 4, 5)));
    assertFalse(range.containsAll(asList(3, 3, 4, 5, 6)));

    // We happen to know that natural-order sorted sets use a different code
    // path, so we test that separately
    assertTrue(range.containsAll(ImmutableSortedSet.of(3, 3, 4, 5)));
    assertTrue(range.containsAll(ImmutableSortedSet.of(3)));

The same would happen if you had something like a <abbr title='A union between multiple types means "any of these types".'>union</abbr> between different types where one or more of them are not valid Pydantic types, for example this would fail 💥:

}

// operand parses a general operand and stores the result in *a.
func (p *Parser) operand(a *obj.Addr) {
	//fmt.Printf("Operand: %v\n", p.input)
	if len(p.input) == 0 {
		p.errorf("empty operand: cannot happen")
		return
	}
	// General address (with a few exceptions) looks like
	//	$sym±offset(SB)(reg)(index*scale)
	// Exceptions are:
	//
	//	R1
	//	offset
	//	$offset

 *       deadlock situation, and the appropriate Policy is executed.
 * </ul>
 *
 * <p>Note that detection of potential deadlock does not necessarily indicate that deadlock will
 * happen, as it is possible that higher level application logic prevents the cyclic lock
 * acquisition from occurring. One example of a false positive is:
 *
 * <pre>
 * LockA -&gt; LockB -&gt; LockC

```

</div>

/// tip | Tipp

Sie können mehr darüber lesen auf <a href="https://12factor.net/config" class="external-link" target="_blank">The Twelve-Factor App: Config</a>.

///

## Typen und Validierung { #types-and-validation }

            baos.write(channel.getRemoteInterface().getAddress().getAddress());
            baos.write(ByteBuffer.allocate(8).putLong(System.currentTimeMillis()).array());
        } catch (IOException e) {
            // Should not happen with ByteArrayOutputStream
            log.error("Error creating binding info", e);
        }

        return baos.toByteArray();
    }