/**
* put value into the queue of channel
*
* @param $value
* @return bool
*/
public function put($value)
{
$len = strlen($value);
if ($len > 2147483647) {
throw new \RuntimeException("value is too long");
}
$raw = pack('N', $len) . $value;
$write_len = $this->pipe->write($raw);
return $write_len == strlen($raw);
}
/**
* Test receiving a message from a pipe using a PipeListener.
*/
public function testReceiveMessageViaPipeListener()
{
// create a message with complete constructor args
$messageToSend = new Message(Message::NORMAL, (object) array('testProp' => 'testval'), simplexml_load_string('<testMessage testAtt="Hello" testAtt2="world"/>'), Message::PRIORITY_HIGH);
// create pipe and listener
$pipe = new Pipe();
$listener = new PipeListener($this, 'callBackMethod');
// connect the listener to the pipe and write the message
$connected = $pipe->connect($listener);
$written = $pipe->write($messageToSend);
// test assertions
$this->assertTrue($pipe instanceof Pipe, "Expecting pipe is Pipe");
$this->assertTrue($connected, "Expecting successfully connected listener to pipe");
$this->assertTrue($written, "Expecting wrote message to pipe");
$this->assertTrue($this->messagesReceived instanceof Message, "Expecting \$this->messagesReceived instance of Message");
$this->assertTrue($this->messagesReceived->getType() == Message::NORMAL, "Expecting \$this->messagesReceived->getType() == Message::NORMAL");
$this->assertTrue($this->messagesReceived->getHeader()->testProp == 'testval', "Expecting \$this->messagesReceived->getHeader()->testProp == 'testval'");
$this->assertTrue($this->messagesReceived->getBody()->attributes()->testAtt == 'Hello', "Expecting \$this->messagesReceived->getBody()->attributes()->testAtt == 'Hello'");
$this->assertTrue($this->messagesReceived->getPriority() == Message::PRIORITY_HIGH, "Expecting \$this->messagesReceived->getPriority() == Message::PRIORITY_HIGH");
}
/**
* Test receiving messages from four pipes using a TeeMerge.
*/
public function testReceiveMessagesFromFourPipesViaTeeMerge()
{
// create a message to send on pipe 1
$pipe1Message = new Message(Message::NORMAL, (object) array('testProp' => 1));
$pipe2Message = new Message(Message::NORMAL, (object) array('testProp' => 2));
$pipe3Message = new Message(Message::NORMAL, (object) array('testProp' => 3));
$pipe4Message = new Message(Message::NORMAL, (object) array('testProp' => 4));
// create pipes 1, 2, 3 and 4
$pipe1 = new Pipe();
$pipe2 = new Pipe();
$pipe3 = new Pipe();
$pipe4 = new Pipe();
// create merging tee
$teeMerge = new TeeMerge($pipe1, $pipe2);
$connectedExtraInput3 = $teeMerge->connectInput($pipe3);
$connectedExtraInput4 = $teeMerge->connectInput($pipe4);
// create listener
$listener = new PipeListener($this, 'callBackMethod');
// connect the listener to the tee and write the messages
$connected = $teeMerge->connect($listener);
// write messages to their respective pipes
$pipe1written = $pipe1->write($pipe1Message);
$pipe2written = $pipe2->write($pipe2Message);
$pipe3written = $pipe3->write($pipe3Message);
$pipe4written = $pipe4->write($pipe4Message);
// test assertions
$this->assertTrue($pipe1Message instanceof IPipeMessage, "Expecting \$pipe1Message instanceof IPipeMessage");
$this->assertTrue($pipe2Message instanceof IPipeMessage, "Expecting \$pipe2Message instanceof IPipeMessage");
$this->assertTrue($pipe3Message instanceof IPipeMessage, "Expecting \$pipe3Message instanceof IPipeMessage");
$this->assertTrue($pipe4Message instanceof IPipeMessage, "Expecting \$pipe4Message instanceof IPipeMessage");
$this->assertTrue($pipe1 instanceof Pipe, "Expecting \$pipe1 instanceof Pipe");
$this->assertTrue($pipe2 instanceof Pipe, "Expecting \$pipe2 instanceof Pipe");
$this->assertTrue($pipe3 instanceof Pipe, "Expecting \$pipe3 instanceof Pipe");
$this->assertTrue($pipe4 instanceof Pipe, "Expecting \$pipe4 instanceof Pipe");
$this->assertTrue($teeMerge instanceof TeeMerge, "Expecting teeMerge instanceof TeeMerge");
$this->assertTrue($listener instanceof PipeListener, "Expecting listener instanceof PipeListener");
$this->assertTrue($connected, "Expecting connected listener to merging tee");
$this->assertTrue($connectedExtraInput3, "Expecting connected extra input \$pipe3 to merging tee");
$this->assertTrue($connectedExtraInput4, "Expecting connected extra input \$pipe4 to merging tee");
$this->assertTrue($pipe1written, "Expecting wrote message to pipe 1");
$this->assertTrue($pipe2written, "Expecting wrote message to pipe 2");
$this->assertTrue($pipe3written, "Expecting wrote message to pipe 3");
$this->assertTrue($pipe4written, "Expecting wrote message to pipe 4");
// test that both messages were received, then test
// FIFO order by inspecting the messages themselves
$this->assertTrue(count($this->messagesReceived) == 4, "Expecting received 4 messages");
// test message 1 assertions
$message1 = array_shift($this->messagesReceived);
$this->assertTrue($message1 instanceof IPipeMessage, "Expecting \$message1 instanceof IPipeMessage");
$this->assertTrue($message1 === $pipe1Message, "Expecting \$message1 === \$pipe1Message");
// object equality
$this->assertTrue($message1->getType() == Message::NORMAL, "Expecting \$message1->getType() == Message::NORMAL");
$this->assertTrue($message1->getHeader()->testProp == 1, "Expecting \$message1->getHeader()->testProp == 1");
// test message 2 assertions
$message2 = array_shift($this->messagesReceived);
$this->assertTrue($message2 instanceof IPipeMessage, "Expecting \$message2 instanceof IPipeMessage");
$this->assertTrue($message2 === $pipe2Message, "Expecting \$message2 === \$pipe2Message");
// object equality
$this->assertTrue($message2->getType() == Message::NORMAL, "Expecting \$message2->getType() == Message::NORMAL");
$this->assertTrue($message2->getHeader()->testProp == 2, "Expecting \$message2->getHeader()->testProp == 2");
// test message 3 assertions
$message3 = array_shift($this->messagesReceived);
$this->assertTrue($message3 instanceof IPipeMessage, "Expecting \$message3 instanceof IPipeMessage");
$this->assertTrue($message3 === $pipe3Message, "Expecting \$message3 === \$pipe3Message");
// object equality
$this->assertTrue($message3->getType() == Message::NORMAL, "Expecting \$message3->getType() == Message::NORMAL");
$this->assertTrue($message3->getHeader()->testProp == 3, "Expecting \$message3->getHeader()->testProp == 3");
// test message 4 assertions
$message4 = array_shift($this->messagesReceived);
$this->assertTrue($message4 instanceof IPipeMessage, "Expecting \$message4 instanceof IPipeMessage");
$this->assertTrue($message4 === $pipe4Message, "Expecting \$message4 === \$pipe4Message");
// object equality
$this->assertTrue($message4->getType() == Message::NORMAL, "Expecting \$message4->getType() == Message::NORMAL");
$this->assertTrue($message4->getHeader()->testProp == 4, "Expecting \$message4->getHeader()->testProp == 4");
}
