Check if a queue/tube does NOT have a given total number of messages

```php
<?php
$I->dontSeeQueueHasTotalCount('default', 10);
?>
```

@param string $queue Queue Name
@param int $expected Number of messages expected
513839
public function dontSeeQueueHasTotalCount($queue, $expected)
    {
        $this->assertNotEquals($expected, $this->queueDriver->getMessagesTotalCountOnQueue($queue));
    }
788331
public function pushToQueue($queue, $message)
    {
        $message = $message instanceof AMQPMessage
            ? $message
            : new AMQPMessage($message);

        $this->getChannel()->queue_declare($queue);
        $this->getChannel()->basic_publish($message, '', $queue);
    }
606446
private function hasRunningJobInQueue($queue)
    {
        $running = $this->configurationManager->findByQueueAndState($queue, JobState::STATE_RUNNING);

        return null !== $running;
    }
968793
public function handleNoticeCommand(Event $event, Queue $queue)
    {
        $params = $event->getCustomParams();
        if (count($params) < 2) {
            $this->handleNoticeHelp($event, $queue);
        } else {
            $channels = array_shift($params);
            $queue->ircNotice($channels, implode(' ', $params));
        }
    }
425183
public function setExpectedAndReceived($expected, $received)
    {
        $this->expected = is_string($expected)
            ? $expected : get_class($expected);

        $this->received = TypeHound::fetch($received);

        $this->message = vsprintf(
            'An instance of a %s was expected but got %s',
            [$this->expected, $this->received]
        );
    }
1371660
public function assertNotInternalType($expected, $message = '')
    {
        Assert::assertNotInternalType($expected, $this->getData(), $message);

        return $this;
    }
175251
public function allServerAre($event, $expected)
    {
        $targets = $this->computeNumberOfTargets();
        $statuses = array_filter($this->statuses[$event], function ($server) use ($expected) {
            return $server === $expected;
        });

        return $targets === count($statuses);
    }
248731
public function handleSayCommand(Event $event, Queue $queue)
    {
        $params = $event->getCustomParams();
        if (count($params) < 2) {
            $this->handleSayHelp($event, $queue);
        } else {
            $channels = array_shift($params);
            $queue->ircPrivmsg($channels, implode(' ', $params));
        }
    }
372746
public function getMessage($queue, $auto_ack = false)
    {
        if (!isset($this->_queues[$queue])) {
            throw new InvalidKeyException(['retrieve message from queue failed: `:queue` queue is NOT exists`', 'queue' => $queue]);
        }

        try {
            $envelope = $this->_queues[$queue]->get($auto_ack ? AMQP_AUTOACK : AMQP_NOPARAM);
        } catch (\Exception $e) {
            throw new AmqpException(['retrieve message from `:queue` queue failed: :error ', 'queue' => $queue, 'error' => $e->getMessage()]);
        }

        return $envelope === false ? false : new Message($this, $queue, $envelope);
    }
54896
protected function ()
    {
        if (!($this->lexer->token['type'] === EmailLexer::INVALID
            || $this->lexer->token['type'] === EmailLexer::C_DEL)) {
            throw new ExpectedQPair();
        }

        $this->warnings[QuotedPart::CODE] =
            new QuotedPart($this->lexer->getPrevious()['type'], $this->lexer->token['type']);
    }
827509
public function assertGreaterThan($expected, $message = '')
    {
        Assert::assertGreaterThan($expected, $this->getData(), $message);

        return $this;
    }
37389
protected function queueDeclare($queue)
    {
        $this->channel->queue_declare($queue, false, true, false, false);
    }
1236192
public function prefix($expected = null)
    {
        $current = null;

        if ($this->Controller->request->prefix !== null) {
            $current = $this->Controller->request->prefix;
        }

        if ($current == $expected) {
            return true;
        }

        return false;
    }
697531
public static function idle(&$queue){

        self::$_idle_event_buffer_counter ++;
        self::$_last_idle_ts = time();

        self::_buffer($queue);
    }
15035
public function assertNotPartialOutput($expected, $type = 'stdout')
    {
        $expected = (string) $expected;
        $actual = $this->getOutputByType($type);

        if (false !== strpos($actual, $expected)) {
            throw new ExpectationException("Failed to assert \"$actual\" does not contain \"$expected\"");
        }
    }
154099
public function handleBigstockHelp(Event $event, Queue $queue)
    {
        $messages = [
            'Usage: bigstock queryString',
            'queryString - the search query (all words are assumed to be part of message)',
            'Searches Bigstock for an image based on the provided query string.',
        ];
        foreach ($messages as $message) {
            $queue->ircPrivmsg($event->getSource(), $message);
        }
    }
58425
private function _ensureExchangeForQueue($queue)
    {
        $serverId = $this->_getQueueServerId($queue);
        $server   = &$this->servers[$serverId];
        
        $reason       = self::REASON_MAIN;
        $exchangeName = self::DEFAULT_EXCHANGE;
        
        if (isset($server[self::SERVER_EXCHANGES][$reason][$exchangeName])) {
            return $server[self::SERVER_EXCHANGES][$reason][$exchangeName];
        }
        
        $this->_serverEnsureConnection($server, $reason);
        $this->_serverEnsureChannel($server, self::REASON_MAIN);
        $exchangeObj = $this->_setupExchange($server, self::REASON_MAIN, $exchangeName);
        
        $server[self::SERVER_EXCHANGES][$reason][$exchangeName] = $exchangeObj;
        
        return $exchangeObj;
    }