AbstractHttp3FrameTypeValidationHandlerTest Class — netty Architecture

Source Code

codec-http3/src/test/java/io/netty/handler/codec/http3/AbstractHttp3FrameTypeValidationHandlerTest.java lines 43–185

public abstract class AbstractHttp3FrameTypeValidationHandlerTest<T extends Http3Frame> {

    private final QuicStreamType defaultStreamType;
    private final boolean isOutbound;
    private final boolean isInbound;
    protected EmbeddedQuicChannel parent;
    protected QpackAttributes qpackAttributes;

    protected abstract ChannelHandler newHandler(boolean server);

    protected abstract List<T> newValidFrames();

    protected abstract List<Http3Frame> newInvalidFrames();

    protected AbstractHttp3FrameTypeValidationHandlerTest(QuicStreamType defaultStreamType,
                                                          boolean isInbound, boolean isOutbound) {
        this.defaultStreamType = defaultStreamType;
        this.isInbound = isInbound;
        this.isOutbound = isOutbound;
    }

    static Collection<Boolean> data() {
        return Arrays.asList(true, false);
    }

    protected void setUp(boolean server) {
        parent = new EmbeddedQuicChannel(server);
        qpackAttributes = new QpackAttributes(parent, false);
        setQpackAttributes(parent, qpackAttributes);
    }

    @AfterEach
    public void tearDown() {
        if (parent != null) {
            final QpackAttributes qpackAttributes = getQpackAttributes(parent);
            assertNotNull(qpackAttributes);
            if (qpackAttributes.decoderStreamAvailable()) {
                assertFalse(((EmbeddedQuicStreamChannel) qpackAttributes.decoderStream()).finish());
            }
            if (qpackAttributes.encoderStreamAvailable()) {
                assertFalse(((EmbeddedQuicStreamChannel) qpackAttributes.encoderStream()).finish());
            }
            assertFalse(parent.finish());
        }
    }

    @ParameterizedTest(name = "{index}: server = {0}")
    @MethodSource("data")
    public void testValidTypeInbound(boolean server) throws Exception {
        assumeTrue(isInbound);
        setUp(server);
        final EmbeddedQuicStreamChannel channel = newStream(defaultStreamType, newHandler(server));
        List<T> validFrames = newValidFrames();
        for (T valid : validFrames) {
            assertTrue(channel.writeInbound(valid));
            T read = channel.readInbound();
            assertFrameSame(valid, read);
            if (valid instanceof Http3SettingsFrame) {
                afterSettingsFrameRead((Http3SettingsFrame) valid);
            }
        }
        assertFalse(channel.finish());
    }

    protected void afterSettingsFrameRead(Http3SettingsFrame settingsFrame) {
    }

    @ParameterizedTest(name = "{index}: server = {0}")
    @MethodSource("data")
    public void testValidTypeOutbound(boolean server) throws Exception {
        assumeTrue(isOutbound);
        setUp(server);
        final EmbeddedQuicStreamChannel channel = newStream(defaultStreamType, newHandler(server));
        List<T> validFrames = newValidFrames();
        for (T valid : validFrames) {
            assertTrue(channel.writeOutbound(valid));
            T read = channel.readOutbound();
            assertFrameSame(valid, read);
        }
        assertFalse(channel.finish());
    }