docs: def run_via_binary_in_foreground(
              self, run_command_instance=None, command=None, volumes=None,
              additional_opts=None, popen_params=None, container_name=None):
          """
          Create a container using this image and run it in foreground;
          this method is useful to test real user scenarios when users invoke containers using
          binary and pass input into the container via STDIN. You are also responsible for:
  
           * redirecting STDIN when intending to use container.write_to_stdin afterwards by setting
                popen_params={"stdin": subprocess.PIPE} during run_via_binary_in_foreground
  
           * checking whether the container exited successfully via:
                container.popen_instance.returncode
  
          Please consult the documentation for subprocess python module for best practices on
          how you should work with instance of Popen
  
          :param run_command_instance: instance of PodmanRunBuilder
          :param command: list of str, command to run in the container, examples:
              - ["ls", "/"]
              - ["bash", "-c", "ls / | grep bin"]
          :param volumes: tuple or list of tuples in the form:
  
              * `("/path/to/directory", )`
              * `("/host/path", "/container/path")`
              * `("/host/path", "/container/path", "mode")`
              * `(conu.Directory('/host/path'), "/container/path")` (source can be also
                  Directory instance)
  
          :param additional_opts: list of str, additional options for `docker run`
          :param popen_params: dict, keyword arguments passed to Popen constructor
          :param container_name: str, pretty container identifier
          :return: instance of PodmanContainer
          """
          logger.info("run container via binary in foreground")
  
          if (command is not None or additional_opts is not None) \
                  and run_command_instance is not None:
              raise ConuException(
                  "run_command_instance and command parameters cannot be "
                  "passed into method at same time")
  
          if run_command_instance is None:
              command = command or []
              additional_opts = additional_opts or []
  
              if (isinstance(command, list) or isinstance(command, tuple) and
                 isinstance(additional_opts, list) or isinstance(additional_opts, tuple)):
                  run_command_instance = PodmanRunBuilder(
                      command=command, additional_opts=additional_opts)
              else:
                  raise ConuException("command and additional_opts needs to be list of str or None")
          else:
              run_command_instance = run_command_instance or PodmanRunBuilder()
              if not isinstance(run_command_instance, PodmanRunBuilder):
                  raise ConuException("run_command_instance needs to be an "
                                      "instance of PodmanRunBuilder")
  
          popen_params = popen_params or {}
  
          run_command_instance.image_name = self.get_id()
          if container_name:
              run_command_instance.options += ["--name", container_name]
  
          if volumes:
              run_command_instance.options += self.get_volume_options(volumes=volumes)
  
          def callback():
              return subprocess.Popen(run_command_instance.build(), **popen_params)
  
          container_id, popen_instance = self._run_container(run_command_instance, callback)
  
          actual_name = graceful_get(self._inspect(container_id), "Name")
  
          if container_name and container_name != actual_name:
              raise ConuException(
                  "Unexpected container name value. Expected = "
                  + str(container_name) + " Actual = " + str(actual_name))
          if not container_name:
              container_name = actual_name
          return PodmanContainer(
              self, container_id, popen_instance=popen_instance, name=container_name)