}
        0 * _
    }

    private DaemonConnectDetails daemon(String id) {
        Stub(DaemonConnectDetails) {
            getUid() >> id
        }
    }

    private DaemonContext daemonContext(String id) {
        Stub(DaemonContext) {
            getUid() >> id
        }
    }

    int getGrantedCredits ();


    /**
     * @return status code
     */
    int getErrorCode ();


    /**
     * @param k
     */
    void setMid ( long k );


    /**
     * @return mid
     */
    long getMid ();


    /**
     * 
     * @param buffer
     * @param i
     * @param size
     * @return whether signature verification is successful
     */

        this.daemonLog = daemonLog;
        this.pid = pid;
    }

    /**
     * @return pid. Can be null, it means the daemon was not able to identify its pid.
     */
    public @Nullable Long getPid() {
        return pid;
    }

    public File getDaemonLog() {
        return daemonLog;
    }

    @Override
    public String toString() {
        return "{"
            + "pid=" + pid

 */
package jcifs.internal;


/**
 * @author mbechler
 *
 */
public interface TreeConnectResponse extends CommonServerMessageBlockResponse {

    /**
     * @return tree id
     */
    int getTid ();


    /**
     * @return service
     */
    String getService ();


    /**
     * @return whether the share is in DFS
     */
    boolean isShareDfs ();


    /**

// permission, hasWritePerm reports false if no appropriate permission bit is
// set even if the current user is root.
func hasWritePerm(path string, fi fs.FileInfo) bool {
	if os.Getuid() == 0 {
		// The root user can access any file, but we still want to default to
		// read-only mode if the go.mod file is marked as globally non-writable.
		// (If the user really intends not to be in readonly mode, they can

// it should abandon its work after a signal is received.
func ExampleNotifyContext() {
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
	defer stop()

	p, err := os.FindProcess(os.Getpid())
	if err != nil {
		log.Fatal(err)
	}

	// On a Unix-like system, pressing Ctrl+C on a keyboard sends a
	// SIGINT signal to the process of the program in execution.
	//

            String status = execution.getDaemonStateControl().getState().toString().toUpperCase(Locale.ROOT);
            Status message = new Status(execution.getDaemonContext().getPid(), version, status);
            execution.getConnection().completed(new Success(message));
        } else {
            execution.proceed();
        }
    }

    public Status(Long pid, String version, String status) {
        this.pid = pid;
        this.version = version;
        this.status = status;
    }

    @Nullable
    public Long getPid() {
        return pid;
    }

    public String getVersion() {
        return version;
    }

    public String getStatus() {
        return status;
    }

		exit(EXIT_FAILURE);
	}
}
*/
import "C"

func main() {
	ch := make(chan os.Signal, 1)
	signal.Notify(ch, syscall.SIGUSR2)

	C.register_handler(C.int(syscall.SIGUSR1))
	syscall.Kill(syscall.Getpid(), syscall.SIGUSR1)

	<-ch

        process.setWorkingDirectory(processDir);
    }

    @Override
    public File getProcessDir() {
        return process.getWorkingDirectory();
    }

    @Override
    public Long getPid() {
        return (long) process.getProcessId();
    }

    @Override
    public void detachProcess() {
        process.detach();
    }