resc := make(chan *ProgResponse, 1)
	if err := c.writeToChild(req, resc); err != nil {
		return nil, err
	}
	select {
	case res := <-resc:
		if res.Err != "" {
			return nil, errors.New(res.Err)
		}
		return res, nil
	case <-ctx.Done():
		return nil, ctx.Err()
	}
}

func (c *ProgCache) writeToChild(req *ProgRequest, resc chan<- *ProgResponse) (err error) {

            lastLogState = logFileProbe.currentState
        }
        if (lastLogState == state) {
            return
        }
        throw new AssertionError("""Timeout waiting for daemon with pid ${context.pid} to reach state ${state}.
Current state is ${lastLogState}.""")
    }

    @Override
    protected void assertHasState(State state) {
        assert logFileProbe.currentState == state
    }

    @Override

     */
    void connectStreams(Process process, String processName, Executor executor);

    /**
     * Starts reading/writing/whatever the process' streams. May block until the streams reach some particular state, e.g. indicate that the process has started successfully.
     */
    void start();

    /**
     * Remove any context associated with tracking the startup of the process.
     */

func findListener() (net.Listener, error) {
	// We start looking for pre-opened sockets at fd=3 because 0, 1, and 2
	// are reserved for stdio. Pre-opened directors also start at fd=3, so
	// we skip fds that aren't sockets. Once we reach EBADF we know there
	// are no more pre-opens.
	for preopenFd := uintptr(3); ; preopenFd++ {
		f := os.NewFile(preopenFd, "")
		l, err := net.FileListener(f)
		f.Close()

		var se syscall.Errno

        }

        @Nullable
        private MetaMethod findGetPropertyMissingMethod(MetaClass metaClass) {
            if (metaClass instanceof MetaClassImpl) {
                // Reach into meta class to avoid lookup
                try {
                    return (MetaMethod) MISSING_PROPERTY_GET_METHOD.get(metaClass);
                } catch (IllegalAccessException e) {

		if err != nil {
			t.Fatalf("Getdirentries: %v", err)
		}
		if n == 0 {
			break
		}
		data := buf[:n]
		for len(data) > 0 {
			// If multiple Dirents are written into buf, sometimes when we reach the final one,
			// we have cap(buf) < Sizeof(Dirent). So use an appropriate slice to copy from data.
			var dirent syscall.Dirent
			copy((*[unsafe.Sizeof(dirent)]byte)(unsafe.Pointer(&dirent))[:], data)

      // should never reach here!
      throw new UnsupportedOperationException();
    }

    @Override
    public Entry<K, V> belowSamplesGreater() {
      // should never reach here!
      throw new UnsupportedOperationException();
    }

    @Override
    public Entry<K, V> aboveSamplesLesser() {
      // should never reach here!
      throw new UnsupportedOperationException();

	case metav1.StatusReasonRequestEntityTooLarge:
		return http.StatusRequestEntityTooLarge
	case metav1.StatusReasonInvalid:
		return http.StatusUnprocessableEntity
	default:
		// It should not reach here since we only allow above reason to be set from API level
		return http.StatusUnprocessableEntity
	}

    if (failed(failure_or_converged)) return signalPassFailure();
    if (!failure_or_converged.value()) {
      getOperation().emitError()
          << "shape inference pass did not reach convergence after "
          << max_iterations_;
      return signalPassFailure();
    }
  }

 private:
  ArrayRef<ArrayRef<int64_t>> input_shapes_;
};
}  // namespace

	defer func() { fixErr(err) }()
	type res struct {
		fd  *netFD
		err error
	}
	resc := make(chan res)
	go func() {
		fd, err := dialPlan9Blocking(ctx, net, laddr, raddr)
		select {
		case resc <- res{fd, err}:
		case <-ctx.Done():
			if fd != nil {
				fd.Close()
			}
		}
	}()
	select {
	case res := <-resc:
		return res.fd, res.err
	case <-ctx.Done():
		return nil, mapErr(ctx.Err())
	}