t.Fatalf("expected = %s, got: %s", errFileNotFound, err)
	}

	file := path.Join(os.TempDir(), "issue")
	if err := os.WriteFile(file, []byte(""), 0o644); err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(file)

	// Check if file is given.
	if _, err := readDir(path.Join(file, "mydir")); err != errFileNotFound {
		t.Fatalf("expected = %s, got: %s", errFileNotFound, err)
	}

      implements Supplier<T> {
    private final Object lock = new Object();

    @SuppressWarnings("UnnecessaryLambda") // Must be a fixed singleton object
    private static final Supplier<@Nullable Void> SUCCESSFULLY_COMPUTED =
        () -> {
          throw new IllegalStateException(); // Should never get called.
        };

    private volatile Supplier<T> delegate;

        void testWatchOperation() throws CIFSException {
            // Given
            int filter = 1; // FILE_NOTIFY_CHANGE_FILE_NAME
            when(mockResource.watch(filter, true)).thenReturn(mockWatchHandle);

            // When
            SmbWatchHandle watchHandle = mockResource.watch(filter, true);

            // Then
            assertNotNull(watchHandle, "Watch handle should not be null");

                boostDocumentRuleService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),
                        this::asEditHtml);
            }

        try {
            Field field = findField(obj.getClass(), fieldName);
            field.setAccessible(true);
            field.set(obj, value);
        } catch (Exception e) {
            throw new RuntimeException("Failed to set field " + fieldName, e);
        }
    }

    private Object getFieldValue(Object obj, String fieldName) {
        try {
            Field field = findField(obj.getClass(), fieldName);

                searchEngineClient.store(index, entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to add {}", entity, e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
            return entity;

        private String getPackageName(File file) throws IOException {
            try (Stream<String> lines = Files.lines(file.toPath())) {
                String packageLine = lines.filter(line -> line.startsWith("package"))
                    .findFirst()
                    .orElseThrow(() -> new IOException("Can't find package definition in file " + file));
                Matcher matcher = pattern.matcher(packageLine);

	h.traverseAndHealDoneCh <- h.healItems(objAPI)
	xioutil.SafeClose(h.traverseAndHealDoneCh)
}

// healMinioSysMeta - heals all files under a given meta prefix, returns a function
// which in-turn heals the respective meta directory path and any files in int.
func (h *healSequence) healMinioSysMeta(objAPI ObjectLayer, metaPrefix string) func() error {
	return func() error {
		// NOTE: Healing on meta is run regardless

package mockwebserver3

import java.io.IOException
import okio.BufferedSink

/**
 * The body of a [MockResponse].
 *
 * Unlike [okhttp3.ResponseBody], this interface is designed to be implemented by writers and not
 * called by readers.
 */
public interface MockResponseBody {
  /** The length of this response in bytes, or -1 if unknown. */
  public val contentLength: Long

  @Throws(IOException::class)

            try {
                failureUrlService.delete(entity);
                saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToDeleteCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
        }).orElse(() -> {