How to implement a stdin, stdout wrapper ?

Question

I have an interactive program that runs stdin and stdout. I need to create wrapper that will send X to it's stdin, check that it prints Y and then redirects wrapper's stdin and stdout to program's stdin and stdout just like program would be executed directly.

How to implement this ? X and Y can be hardcoded. Bash? Python?

Edit: I can't run the program twice. It has to be one instance. Here is the pseudocode:

def wrap(cmd, in, expected_out):
  p = exec(cmd)
  p.writeToStdin(in)
  out = p.readBytes (expected_out.size())
  if (out != expected_out) return fail;
  # if the above 4 lines would be absent or (in == "" and out == "")
  # then this wrapper would be exactly like direct execution of cmd
  connectpipe (p.stdout, stdout)
  connectpipe (stdin, p.stdin)
  p.continueExecution()

Answer 1

Assuming X and Y are files, and that you can invoke the program more than once:

#!/bin/bash

test "`program <X`" = "`cat Y`" && program

Or, to fail more verbosely:

#!/bin/bash

if [[ `program <X` != `cat Y` ]]; then
    echo -e "Assertion that input X produces Y failed, exiting."
    exit 1
fi

program

If you only invoke the program once, Expect is a much simpler alternative than reassigning standard file I/O on the fly.

Answer 2

Expect is made for automating the running of other programs - essentially you write something like, in plain text,

Start this program. When it prints out the word "username", send it my username. When it sends "password", send it my password.

It's really great for driving other programs.

Answer 3

You can overwrite the sys module's stdin and stdout

import sys
sys.stdin, sys.stdout = wrapper.stdin, wrapper.stdout

These need to be file objects opened for reading and writing respectively. The original stdin and stdout are found at

sys.stdin, sys.stdout = sys.__stdin__, sys.__stdout__

Answer 4

I'm a little confused as to what exactly you're trying to achieve; as I understand you wish to:

1. Start the wrapper program specifying the input X, and expected output Y.
2. Have the wrapper initiate the target program attaching input X to it's stdin, and verifying that it's output matches Y.
3. Have the target program return, and after output is verified, rerun it from the same instance of the wrapper program, this time using the wrapper programs stdin and stdout.

If this is the case you want to do this:

1. Have the wrapper program open pipes for the stdin and stdout of the target program.
2. Fork, and close the appropriate ends of said pipes.
3. Have the parent process and verify the output, while the child exec()s and executes thh target program.
4. Wait for the child process to terminate when it's stdout closes.
5. Have the wrapper program exec() into the target program.
6. Now the target program will be executing as normal.

If this is correct, I can provide a ~30 line C program, or ~10 line Python program that achives this.