/**
     *
     *
     * @param key
     * @return InputLocation
     */
    public InputLocation getLocation(Object key) {
        if (key instanceof String) {
            switch ((String) key) {
                case "": {
                    return this.location;
                }
                default: {
                    return getOtherLocation(key);
                }

        assertArgumentNotEmpty("messageCode", messageCode);

        final char messageType = messageCode.charAt(0);
        final String message = MessageFormatter.getSimpleMessage(messageCode, args);
        switch (messageType) {
        case 'D':
            return new LogMessage(LogLevel.DEBUG, message);
        case 'I':
            return new LogMessage(LogLevel.INFO, message);
        case 'W':

    ticker.advance(999999);
    assertEquals(0, stopwatch.elapsed(MILLISECONDS));
    ticker.advance(1);
    assertEquals(1, stopwatch.elapsed(MILLISECONDS));
  }

  @J2ktIncompatible // TODO(b/259213718): Switch J2kt to String.format("%.4g") once that's supported
  public void testToString() {
    stopwatch.start();
    assertEquals("0.000 ns", stopwatch.toString());
    ticker.advance(1);

RUN /setup.python.sh python3.13 builder.requirements.txt

# Since we are using python3.12 as the default python version, we need to
# install python3.12 last for now.
# TODO(b/376338367): switch to pyenv.
RUN /setup.python.sh python3.12 builder.requirements.txt

# Setup links for TensorFlow to compile.
# Referenced in devel.usertools/*.bazelrc.
# Set python3.12 as the default python version.

    public void setInitParameterMap(final Map<String, Object> params) {
        initParamMap = params;
    }

    @Override
    public ResponseData execute(final RequestData request) {
        return switch (request.getMethod()) {
        case GET -> doGet(request.getUrl());
        case HEAD -> doHead(request.getUrl());
        case POST -> doPost(request.getUrl());

  private static void validateMethod(Method method) {
    String desc = method.toString();

    assertTrue(desc, isAnyEnter(method) || isWaitFor(method));

    switch (method.getParameterTypes().length) {
      case 0:
        assertFalse(desc, isGuarded(method));
        assertFalse(desc, isTimed(method));
        break;
      case 1:
        if (isDurationBased(method)) {

	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Namespace":
			{
				var zb0002 string
				zb0002, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Namespace")
					return
				}

		tw.hdr.ModTime = tw.hdr.ModTime.Round(time.Second)
		tw.hdr.AccessTime = time.Time{}
		tw.hdr.ChangeTime = time.Time{}
	}

	allowedFormats, paxHdrs, err := tw.hdr.allowedFormats()
	switch {
	case allowedFormats.has(FormatUSTAR):
		tw.err = tw.writeUSTARHeader(&tw.hdr)
		return tw.err
	case allowedFormats.has(FormatPAX):
		tw.err = tw.writePAXHeader(&tw.hdr, paxHdrs)
		return tw.err

                off += n;
                len -= n;
                bip -= n;
                if( len == 0 ) {
                    return tot;
                }
            }

            switch( SessionServicePacket.readPacketType( in, header, 0 )) {
                case SessionServicePacket.SESSION_KEEP_ALIVE:
                    break;
                case SessionServicePacket.SESSION_MESSAGE:

        return dstIndex - start;
    }


    /**
     * @param informationLevel2
     * @return
     */
    static long mapInformationLevel ( int il ) {
        switch ( il ) {
        case FileInformation.FILE_BASIC_INFO:
            return 0x0101;
        case FileInformation.FILE_STANDARD_INFO:
            return 0x0102;
        case FileInformation.FILE_ENDOFFILE_INFO: