org.eclipse.microprofile.reactive.messaging.tck.invalid

## Class InvalidConfigurationTest

- java.lang.Object
- - org.eclipse.microprofile.reactive.messaging.tck.invalid.InvalidConfigurationTest

    public class InvalidConfigurationTest
    extends Object

### Constructor Summary

Constructors
Constructor and Description
`InvalidConfigurationTest()`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `channelMissingUpstream()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `channelMultipleUpstreams()`
`void` `checkThatChannelWithMultipleUpstreamsAreDetected()`
`void` `checkThatChannelWithoutUpstreamAreDetected()`
`void` `checkThatEmitterWithMultipleDownstreamsAreDetected()`
`void` `checkThatEmitterWithoutDownstreamAreDetected()`
`void` `checkThatEmptyIncomingAreRejected()`
`void` `checkThatEmptyOutgoingAreRejected()`
`void` `checkThatIncomingConnectorWithMultipleDownstreamAreDetected()`
`void` `checkThatIncomingConnectorWithoutDownstreamAreDetected()`
`void` `checkThatIncompleteChainsAreDetected()`
`void` `checkThatInvalidOutgoingSignaturesAreRejected()`
`void` `checkThatOutgoingConnectorWithMultipleUpstreamsAreDetected()`
`void` `checkThatOutgoingConnectorWithoutUpstreamAreDetected()`
`void` `checkThatProcessorsWithoutDownstreamAreDetected()`
`void` `checkThatProcessorsWithoutUpstreamAreDetected()`
`void` `checkThatProcessorsWithTooManyDownstreamsAreDetected()`
`void` `checkThatProcessorsWithTooManyUpstreamsAreDetected()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `connectorMissingDownstream()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `connectorMissingUpstream()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `connectorMultipleDownstreams()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `connectorMultipleUpstreams()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `emitterMissingDownstream()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `emitterMultipleDownstreams()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `emptyIncoming()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `emptyOutgoing()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `incompleteChain()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `invalidPublisherMethod()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `processorMissingDownstream()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `processorMissingUpstream()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `processorMultipleDownstreams()`
`static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive>` `processorMultipleUpstreams()`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### InvalidConfigurationTest

    public InvalidConfigurationTest()

### Method Detail

#### emptyIncoming

    @Deployment(managed=false,
                name="empty-incoming")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> emptyIncoming()

#### emptyOutgoing

    @Deployment(managed=false,
                name="empty-outgoing")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> emptyOutgoing()

#### invalidPublisherMethod

    @Deployment(managed=false,
                name="invalid-publisher-method")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> invalidPublisherMethod()

#### incompleteChain

    @Deployment(managed=false,
                name="incomplete-chain")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> incompleteChain()

#### processorMissingUpstream

    @Deployment(managed=false,
                name="processor-missing-upstream")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> processorMissingUpstream()

#### processorMissingDownstream

    @Deployment(managed=false,
                name="processor-missing-downstream")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> processorMissingDownstream()

#### processorMultipleUpstreams

    @Deployment(managed=false,
                name="processor-multiple-upstreams")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> processorMultipleUpstreams()

#### processorMultipleDownstreams

    @Deployment(managed=false,
                name="processor-multiple-downstreams")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> processorMultipleDownstreams()

#### emitterMissingDownstream

    @Deployment(managed=false,
                name="emitter-missing-downstream")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> emitterMissingDownstream()

#### emitterMultipleDownstreams

    @Deployment(managed=false,
                name="emitter-multiple-downstreams")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> emitterMultipleDownstreams()

#### channelMissingUpstream

    @Deployment(managed=false,
                name="channel-missing-upstream")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> channelMissingUpstream()

#### channelMultipleUpstreams

    @Deployment(managed=false,
                name="channel-multiple-upstreams")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> channelMultipleUpstreams()

#### connectorMissingUpstream

    @Deployment(managed=false,
                name="connector-missing-upstream")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> connectorMissingUpstream()

#### connectorMissingDownstream

    @Deployment(managed=false,
                name="connector-missing-downstream")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> connectorMissingDownstream()

#### connectorMultipleDownstreams

    @Deployment(managed=false,
                name="connector-multiple-downstreams")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> connectorMultipleDownstreams()

#### connectorMultipleUpstreams

    @Deployment(managed=false,
                name="connector-multiple-upstreams")
     @ShouldThrowException(value=jakarta.enterprise.inject.spi.DeploymentException.class,
                          testable=true)
    public static org.jboss.shrinkwrap.api.Archive<org.jboss.shrinkwrap.api.spec.JavaArchive> connectorMultipleUpstreams()

#### checkThatEmptyIncomingAreRejected

    public void checkThatEmptyIncomingAreRejected()

#### checkThatEmptyOutgoingAreRejected

    public void checkThatEmptyOutgoingAreRejected()

#### checkThatInvalidOutgoingSignaturesAreRejected

    public void checkThatInvalidOutgoingSignaturesAreRejected()

#### checkThatIncompleteChainsAreDetected

    public void checkThatIncompleteChainsAreDetected()

#### checkThatProcessorsWithoutUpstreamAreDetected

    public void checkThatProcessorsWithoutUpstreamAreDetected()

#### checkThatProcessorsWithoutDownstreamAreDetected

    public void checkThatProcessorsWithoutDownstreamAreDetected()

#### checkThatProcessorsWithTooManyUpstreamsAreDetected

    public void checkThatProcessorsWithTooManyUpstreamsAreDetected()

#### checkThatProcessorsWithTooManyDownstreamsAreDetected

    public void checkThatProcessorsWithTooManyDownstreamsAreDetected()

#### checkThatEmitterWithoutDownstreamAreDetected

    public void checkThatEmitterWithoutDownstreamAreDetected()

#### checkThatEmitterWithMultipleDownstreamsAreDetected

    public void checkThatEmitterWithMultipleDownstreamsAreDetected()

#### checkThatChannelWithoutUpstreamAreDetected

    public void checkThatChannelWithoutUpstreamAreDetected()

#### checkThatChannelWithMultipleUpstreamsAreDetected

    public void checkThatChannelWithMultipleUpstreamsAreDetected()

#### checkThatIncomingConnectorWithoutDownstreamAreDetected

    public void checkThatIncomingConnectorWithoutDownstreamAreDetected()

#### checkThatIncomingConnectorWithMultipleDownstreamAreDetected

    public void checkThatIncomingConnectorWithMultipleDownstreamAreDetected()

#### checkThatOutgoingConnectorWithoutUpstreamAreDetected

    public void checkThatOutgoingConnectorWithoutUpstreamAreDetected()

#### checkThatOutgoingConnectorWithMultipleUpstreamsAreDetected

    public void checkThatOutgoingConnectorWithMultipleUpstreamsAreDetected()