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