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

Class InvalidConfigurationTest

  • public class InvalidConfigurationTest
extends Object

    • 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()