val rangesPosition = sections.read14BitInt(sectionsIndex + 2)

    val rangesLimit =
      when {
        sectionsIndex + 4 < sections.length -> sections.read14BitInt(sectionsIndex + 6)
        else -> ranges.length / 4
      }

    val rangesIndex = findRangesOffset(codePoint, rangesPosition, rangesLimit)

    when (val b1 = ranges[rangesIndex + 1].code) {
      in 0..63 -> {

        val declaringClassSince = ktFile.ktClassOf(ctDeclaringClass)?.getSince()
        when {
            ctMember is CtMethod && ctMember.isSynthetic -> SinceTagStatus.NotNeeded // synthetic members cannot have kdoc
            ctMember is CtClass -> ktFile.ktClassOf(ctMember).getSinceStatus()
            else -> when (ctMember) {
                is CtField -> ktFile.getSince(ctDeclaringClass, ctMember, fallback = declaringClassSince)

    @BeforeEach
    void setUp() {
        // Setup default mock behavior
        lenient().when(mockConfig.getNetbiosScope()).thenReturn("DEFAULT.SCOPE");
        lenient().when(mockConfig.getOemEncoding()).thenReturn("UTF-8");

        // Setup mock name
        lenient().when(mockName.writeWireFormat(any(byte[].class), anyInt())).thenReturn(34);
        mockName.hexCode = 0x20;
        mockName.name = "TEST";

        val digit =
          when (c) {
            in 'a'..'z' -> c - 'a'
            in 'A'..'Z' -> c - 'A'
            in '0'..'9' -> c - '0' + 26
            else -> return false // Malformed.
          }
        val deltaI = digit * w
        if (i > Int.MAX_VALUE - deltaI) return false // Prevent overflow.
        i += deltaI
        val t =
          when {
            k <= bias -> TMIN

var ErrAlreadyLocked = errors.New("file already locked")

// RLockedFile represents a read locked file, implements a special
// closer which only closes the associated *os.File when the ref count.
// has reached zero, i.e when all the readers have given up their locks.
type RLockedFile struct {
	*LockedFile
	mutex sync.Mutex
	refs  int // Holds read lock refs.
}

    // 'swallowException' when the mock does not throw an exception.
    setupCloseable(false);
    doClose(mockCloseable, false, false);

    setupCloseable(false);
    doClose(mockCloseable, true, false);
  }

  public void testClose_closeableWithEatenException() throws IOException {
    // make sure that no exception is thrown if 'swallowException' is true
    // when the mock does throw an exception.

 * at runtime. When a MIME type is not found in the mapping, a default value
 * is returned.
 */
public class FileTypeHelper {
    /** Logger instance for this class */
    private static final Logger logger = LogManager.getLogger(FileTypeHelper.class);

    /** Default file type value returned when MIME type is not found in mappings */
    protected String defaultValue = "others";

    }

    // Helper to create a minimal FileEntry mock
    private FileEntry entry(String name, int type) {
        FileEntry e = mock(FileEntry.class);
        when(e.getName()).thenReturn(name);
        when(e.getType()).thenReturn(type);
        return e;
    }

    @Test
    @DisplayName("Happy path without filter: iterates all entries in order")

	"github.com/minio/mux"
	"github.com/minio/pkg/v3/policy"
)

var (
	// error returned when remote tier already exists
	errTierAlreadyExists = AdminError{
		Code:       "XMinioAdminTierAlreadyExists",
		Message:    "Specified remote tier already exists",
		StatusCode: http.StatusConflict,
	}
	// error returned when remote tier is not found
	errTierNotFound = AdminError{
		Code:       "XMinioAdminTierNotFound",

internal sealed interface MappedRange {
  val rangeStart: Int

  data class Constant(
    override val rangeStart: Int,
    val type: Int,
  ) : MappedRange {
    val b1: Int
      get() =
        when (type) {
          TYPE_IGNORED -> 119
          TYPE_VALID -> 120
          TYPE_DISALLOWED -> 121
          else -> error("unexpected type: $type")
        }
  }

  data class Inline1(