return nil, fmt.Errorf("Failed to create log file: %w", err)
		}
	}

	go w.listen()

	return w, nil
}

func newFile(path string) (*os.File, error) {
	return os.OpenFile(path, os.O_WRONLY|os.O_TRUNC|os.O_CREATE|os.O_SYNC, 0o666)

	//
	// The lock file is never deleted, to avoid concurrent locks on distinct
	// files with the same path.
	lockName := filepath.Join(os.TempDir(), "go_ios_exec-"+deviceID+".lock")
	lock, err = os.OpenFile(lockName, os.O_CREATE|os.O_RDONLY, 0666)
	if err != nil {
		return 1, err
	}
	if err := syscall.Flock(int(lock.Fd()), syscall.LOCK_EX); err != nil {
		return 1, err
	}

	err = runOnSimulator(appdir)

		t.Fatal(err)
	}

	// 4) Streaming bitrot check on corrupted file
	filePath := pathJoin(storage.String(), volName, fileName)
	f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_SYNC, 0o644)
	if err != nil {
		t.Fatal(err)
	}
	// Replace first 256 with 'a'.
	if _, err := f.WriteString(strings.Repeat("a", 256)); err != nil {
		t.Fatal(err)
	}

			defer zippedFile.Close()
			extractedFilePath := filepath.Join(targetDir, file.Name)
			if file.FileInfo().IsDir() {
				return os.MkdirAll(extractedFilePath, file.Mode())
			}
			outputFile, err := os.OpenFile(extractedFilePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode())
			if err != nil {
				return err
			}
			defer outputFile.Close()
			_, err = io.Copy(outputFile, zippedFile)
			return err
		}()

    }

    @Test
    @DisplayName("openPipe returns a handle bound to this pipe")
    void openPipeReturnsHandleBoundToPipe() throws Exception {
        // Arrange
        SmbNamedPipe pipe = new SmbNamedPipe("smb://server/IPC$/foo", SmbPipeResource.PIPE_TYPE_RDWR, ctx());

        // Act
        SmbPipeHandle handle = pipe.openPipe();

        // Assert: observable handle behavior without network I/O

		metricsLogIf(ctx, err)
	} else {
		loadProcIOMetrics(ctx, io, m)
	}

	l, err := p.Limits()
	if err != nil {
		metricsLogIf(ctx, err)
	} else {
		if l.OpenFiles > 0 {
			m.Set(processFileDescriptorLimitTotal, float64(l.OpenFiles))
		}

		if l.AddressSpace > 0 {
			m.Set(processVirtualMemoryMaxBytes, float64(l.AddressSpace))
		}
	}

	openFDs, err := p.FileDescriptorsLen()
	if err != nil {

        super(tc, DcerpcHandle.parseBinding(url));
        this.pipe = new SmbNamedPipe(makePipeUrl(), pipeFlags, unshared, tc);
        this.handle = this.pipe.openPipe().unwrap(SmbPipeHandleInternal.class);
    }

    private String makePipeUrl() {
        final DcerpcBinding binding = getBinding();
        StringBuilder url =

    @Override
    public int getPipeType() {
        return this.pipeType;
    }

    /**
     * @return a handle for interacting with the pipe
     */
    @Override
    public SmbPipeHandle openPipe() {
        return new SmbPipeHandleImpl(this);
    }

    @BeforeEach
    void setUp() throws IOException {
        // Setup mock behavior with lenient stubbing to avoid UnnecessaryStubbingException
        lenient().when(mockSmbNamedPipe.openPipe()).thenReturn(mockSmbPipeHandle);
        lenient().when(mockSmbPipeHandle.unwrap(SmbPipeHandleInternal.class)).thenReturn(mockSmbPipeHandleInternal);
        lenient().when(mockSmbNamedPipe.getContext()).thenReturn(mockContext);

pkg os, func Lstat(string) (fs.FileInfo, error)
pkg os, func Mkdir(string, fs.FileMode) error
pkg os, func MkdirAll(string, fs.FileMode) error
pkg os, func MkdirTemp(string, string) (string, error)
pkg os, func OpenFile(string, int, fs.FileMode) (*File, error)
pkg os, func ReadDir(string) ([]fs.DirEntry, error)
pkg os, func ReadFile(string) ([]uint8, error)
pkg os, func SameFile(fs.FileInfo, fs.FileInfo) bool