Define that this expectation should never be met

@return MutableExpectationBuilder
191256
public function never()
    {
        $this->expectation->setSatisfied(true);
        $this->expectation->setPerformCallback(function($name, $args) {
            $this->expectation->setSatisfied(false);
            $message = "$name should never be called";

            if (count($args)) {
                $message .= " with " . Util::printArray($args);
            }

            throw new UnexpectedCallException($message);
        });
        $this->expectation->setPostPerformCallback(function(){});

        $this->commentBuilder->setTimes(0);
        
        return $this;
    }
412275
public function build(): SetRequestInterceptionRequest
	{
		$instance = new SetRequestInterceptionRequest();
		if ($this->patterns === null) {
			throw new BuilderException('Property [patterns] is required.');
		}
		$instance->patterns = $this->patterns;
		return $instance;
	}
30670
public Expectations setBadIssuerExpectations(LibertyServer server) throws Exception {

        Expectations expectations = new Expectations();
        expectations.addExpectation(new ResponseStatusExpectation(HttpServletResponse.SC_UNAUTHORIZED));

        expectations.addExpectation(new ServerMessageExpectation(server, MpJwtMessageConstants.CWWKS5523E_ERROR_CREATING_JWT_USING_TOKEN_IN_REQ, "Messagelog did not contain an error indicating a problem authenticating the request with the provided token."));
        expectations.addExpectation(new ServerMessageExpectation(server, MpJwtMessageConstants.CWWKS6022E_ISSUER_NOT_TRUSTED, "Messagelog did not contain an exception indicating that the issuer is NOT valid."));

        return expectations;

    }
649664
public function newQueryWithoutScopes()
    {
        $builder = $this->newBuilder(
            $this->newBaseQueryBuilder()
        );

        // Once we have the query builders, we will set the model instances so the
        // builder can easily access any information it may need from the model
        // while it is constructing and executing various queries against it.
        return $builder->setModel($this)->with($this->with);
    }
55048
public static <T> WithOrWithoutExpectedArguments<T> when(Class<?> cls, Method method) {
        return new DefaultMethodExpectationSetup<T>(cls, method);
    }
323715
protected function _execute()
    {
        $result = null;
        $spec = function () {
            $this->_expectations = [];
            $closure = $this->_closure;
            $result = $this->_suite->runBlock($this, $closure, 'specification');
            foreach ($this->_expectations as $expectation) {
                $this->_passed = $expectation->process() && $this->_passed;
            }
            return $result;
        };

        $suite = $this->suite();
        return $spec();
    }
1275173
public synchronized Future<Message> setExpectation(final C condition, final MessageAction<P> action) {
        if (this.isStopped()) {
            throw new IllegalStateException("Already stopped.");
        }
        final AbstractExpectation<C, P> expectation = this.createExpectation(condition, action);
        final Future<Message> future = AbstractExpectationManager.EXECUTOR.submit(expectation);
        this.expectations.put(expectation, future);
        AbstractExpectationManager.LOGGER.info("Registered expectation {} with action {}.", expectation, action);
        return future;
    }
690397
public static <T> WithOrWithoutExpectedArguments<T> when(Object instance, Method method) {
        return new DefaultMethodExpectationSetup<T>(instance, method);
    }
1136607
public static <U> CompletableFuture<U> failedFuture(Throwable ex) {
    return new CompletableFuture<U>(new AltResult(Objects.requireNonNull(ex)));
  }
777861
public function build(): SetPressureNotificationsSuppressedRequest
	{
		$instance = new SetPressureNotificationsSuppressedRequest();
		if ($this->suppressed === null) {
			throw new BuilderException('Property [suppressed] is required.');
		}
		$instance->suppressed = $this->suppressed;
		return $instance;
	}
152960
public function newQueryWithoutScopes()
    {
        $builder = $this->newQueryBuilder(
            $this->newBaseQueryBuilder()
        );

        return $builder->setModel($this)->with($this->with);
    }
1336900
public function newQueryWithoutScopes()
    {
        $builder = $this->newEloquentBuilder(
            $this->newBaseQueryBuilder()
        );

        // Once we have the query builders, we will set the model instances so the
        // builder can easily access any information it may need from the model
        // while it is constructing and executing various queries against it.
        $builder->setModel($this)->with($this->with);

        $builder->table = $this->getTable();

        return $builder;
    }
447267
public function asSequence(): Constructed\Sequence
    {
        if (!$this->_element instanceof Constructed\Sequence) {
            throw new \UnexpectedValueException(
                $this->_generateExceptionMessage(Element::TYPE_SEQUENCE));
        }
        return $this->_element;
    }
224409
@Deprecated
    public C expectAtMost(int allowedStatements, Threads threadMatcher) {
        return expect(SqlQueries.maxQueries(allowedStatements).threads(threadMatcher));
    }
61785
@Deprecated
    public C expectBetween(int minAllowedStatements, int maxAllowedStatements, Threads threadMatcher) {
        return expect(SqlQueries.queriesBetween(minAllowedStatements, maxAllowedStatements).threads(threadMatcher));
    }
418340
public function limitExceeded()
    {
        $limit = $this->_agent->getLimit();
        return $limit != CollectionAgentAbstract::NO_LIMIT && $this->_count > $this->_agent->getLimit();
    }
417740
public Object execute( String... args ) throws Exception
    {
        result = new Result( expectation );
        try
        {
            result.setActual( message.send( mergeInputsWith( args ) ) );
        }
        catch (SystemUnderDevelopmentException e)
        {
            if(logger.isDebugEnabled()){
                logger.debug("Error while executing specifications", e.getCause());
            }
            result.exceptionOccured( e.getCause() );
        }

        dispatchForHandling( result );

        return result.getActual();
    }