switch (unit) {
      case NANOSECONDS:
        return "ns";
      case MICROSECONDS:
        return "\u03bcs"; // μs
      case MILLISECONDS:
        return "ms";
      case SECONDS:
        return "s";
      case MINUTES:
        return "min";
      case HOURS:
        return "h";
      case DAYS:
        return "d";
    }
    throw new AssertionError();

					switch msgp.UnsafeString(field) {
					case "ts":
						za0002.TotalSize, err = dc.ReadUint64()
						if err != nil {
							err = msgp.WrapError(err, "Tiers", za0001, "TotalSize")
							return
						}
					case "nv":
						za0002.NumVersions, err = dc.ReadInt()
						if err != nil {
							err = msgp.WrapError(err, "Tiers", za0001, "NumVersions")
							return
						}
					case "no":
						za0002.NumObjects, err = dc.ReadInt()

            switch (arr[ai]) {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                value += arr[ai] - '0';
                break;
            case 'A':
            case 'B':
            case 'C':
            case 'D':

    assumeFalse(
      story === Story.MISSING,
      "Test stories missing, checkout git submodule",
    )

    val newCases = mutableListOf<Case>()
    for (case in story.cases) {
      hpackWriter.writeHeaders(case.headersList)
      newCases += case.copy(wire = bytesOut.readByteString())
    }

    testDecoder(story.copy(cases = newCases))
  }

  companion object {

func (t ScanToken) String() string {
	switch t {
	case scanner.EOF:
		return "EOF"
	case scanner.Ident:
		return "identifier"
	case scanner.Int:
		return "integer constant"
	case scanner.Float:
		return "float constant"
	case scanner.Char:
		return "rune constant"
	case scanner.String:
		return "string constant"
	case scanner.RawString:
		return "raw string constant"
	case scanner.Comment:
		return "comment"
	default:

        switch (returnCode) {
        case ERROR_SUCCESS:
            return "Success";
        case ERROR_INVALID_PARAMETER:
            return "Invalid parameter";
        case ERROR_INSUFFICIENT_BUFFER:
            return "Insufficient buffer";
        case ERROR_NOT_SUPPORTED:
            return "Operation not supported";
        case ERROR_ACCESS_DENIED:
            return "Access denied";

			return
		}
		switch msgp.UnsafeString(field) {
		case "st":
			z.StartTime, err = dc.ReadTime()
			if err != nil {
				err = msgp.WrapError(err, "StartTime")
				return
			}
		case "ss":
			z.StartSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "StartSize")
				return
			}
		case "ts":
			z.TotalSize, err = dc.ReadInt64()
			if err != nil {

        return switch (o) {
        case null -> null;
        case Long l -> l;
        case Number n -> n.longValue();
        case String s -> toLong(s);
        case java.util.Date d -> pattern != null ? Long.valueOf(new SimpleDateFormat(pattern).format(d)) : d.getTime();
        case Boolean b -> b ? 1L : 0L;
        default -> toLong(o.toString());
        };
    }

			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Bucket":
			z.Bucket, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Bucket")
				return
			}
		case "Object":
			z.Object, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Object")
				return
			}
		case "VersionID":
			z.VersionID, err = dc.ReadString()
			if err != nil {

		return v, false, nil
	}

	switch {
	case p[0].Key != nil:
		key := p[0].Key.keyString()

		switch kvs := v.(type) {
		case jstream.KVS:
			for _, kv := range kvs {
				if kv.Key == key {
					return jsonpathEval(p[1:], kv.Value)
				}
			}
			// Key not found - return nil result
			return Missing{}, false, nil
		case simdjson.Object:
			elem := kvs.FindKey(key, nil)
			if elem == nil {