*/
@FunctionalInterface
public interface IoSupplier<T> {
    @Nullable
    T get() throws IOException;

    /**
     * Wraps an {@link IOException}-throwing {@link IoSupplier} into a regular {@link Supplier}.
     *
     * Any {@code IOException}s are rethrown as {@link UncheckedIOException}.
     */
    static <T> Supplier<T> wrap(IoSupplier<T> supplier) {
        return () -> {
            try {

            .get();
    }

    private Supplier<HashCode> hashSafely(ZipEntryContext safeContext) {
        return IoSupplier.wrap(() -> tryHash(safeContext).orElseGet(hashWithDelegate(safeContext)));
    }

    private Supplier<HashCode> hashWithDelegate(ZipEntryContext context) {
        return IoSupplier.wrap(() -> delegate.hash(context));
    }

import org.gradle.internal.fingerprint.hashing.RegularFileSnapshotContext;
import org.gradle.internal.hash.HashCode;
import org.gradle.internal.hash.Hasher;
import org.gradle.internal.hash.Hashing;
import org.gradle.internal.io.IoSupplier;
import org.gradle.internal.snapshot.FileSystemLocationSnapshot;

import javax.annotation.Nullable;
import java.io.IOException;

import org.gradle.internal.fingerprint.hashing.FileSystemLocationSnapshotHasher;
import org.gradle.internal.hash.HashCode;
import org.gradle.internal.hash.Hasher;
import org.gradle.internal.io.IoSupplier;
import org.gradle.internal.snapshot.FileSystemLocationSnapshot;

import javax.annotation.Nullable;
import java.io.File;
import java.io.IOException;
import java.util.Optional;

/**

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.io


import static org.gradle.internal.io.IoSupplier.wrap

class IoSupplierTest extends AbstractIoTest {

    def "executed when it doesn't throw"() {
        expect:
        wrap({ "lajos" }).get() == "lajos"
    }

    @Override

    }

    @Override
    public void withFileLock(Runnable action) {
        crossProcessCacheAccess.withFileLock(toSupplier(action));
    }

    @Override
    public void useCache(Runnable action) {
        useCache(toSupplier(action));
    }

    private static <T> Supplier<T> toSupplier(Runnable action) {
        return () -> {
            action.run();
            return null;
        };
    }