WeightedFairQueueByteDistributorTest Class — netty Architecture

Source Code

codec-http2/src/test/java/io/netty/handler/codec/http2/WeightedFairQueueByteDistributorTest.java lines 43–964

public class WeightedFairQueueByteDistributorTest extends AbstractWeightedFairQueueByteDistributorDependencyTest {
    private static final int STREAM_A = 1;
    private static final int STREAM_B = 3;
    private static final int STREAM_C = 5;
    private static final int STREAM_D = 7;
    private static final int STREAM_E = 9;
    private static final int ALLOCATION_QUANTUM = 100;

    @BeforeEach
    public void setup() throws Http2Exception {
        MockitoAnnotations.initMocks(this);

        // Assume we always write all the allocated bytes.
        doAnswer(writeAnswer(false)).when(writer).write(any(Http2Stream.class), anyInt());

        setup(-1);
    }

    private void setup(int maxStateOnlySize) throws Http2Exception {
        connection = new DefaultHttp2Connection(false);
        distributor = maxStateOnlySize >= 0 ? new WeightedFairQueueByteDistributor(connection, maxStateOnlySize)
                                            : new WeightedFairQueueByteDistributor(connection);
        distributor.allocationQuantum(ALLOCATION_QUANTUM);

        connection.local().createStream(STREAM_A, false);
        connection.local().createStream(STREAM_B, false);
        Http2Stream streamC = connection.local().createStream(STREAM_C, false);
        Http2Stream streamD = connection.local().createStream(STREAM_D, false);
        setPriority(streamC.id(), STREAM_A, DEFAULT_PRIORITY_WEIGHT, false);
        setPriority(streamD.id(), STREAM_A, DEFAULT_PRIORITY_WEIGHT, false);
    }

    /**
     * In this test, we block B such that it has no frames. We distribute enough bytes for all streams and stream B
     * should be preserved in the priority queue structure until it has no "active" children, but it should not be
     * doubly added to stream 0.
     *
     * <pre>
     *         0
     *         |
     *         A
     *         |
     *        [B]
     *         |
     *         C
     *         |
     *         D
     * </pre>
     *
     * After the write:
     * <pre>
     *         0
     * </pre>
     */
    @Test
    public void writeWithNonActiveStreamShouldNotDobuleAddToPriorityQueue() throws Http2Exception {
        initState(STREAM_A, 400, true);
        initState(STREAM_B, 500, true);
        initState(STREAM_C, 600, true);
        initState(STREAM_D, 700, true);

        setPriority(STREAM_B, STREAM_A, DEFAULT_PRIORITY_WEIGHT, true);
        setPriority(STREAM_D, STREAM_C, DEFAULT_PRIORITY_WEIGHT, true);

        // Block B, but it should still remain in the queue/tree structure.
        initState(STREAM_B, 0, false);

        // Get the streams before the write, because they may be closed.
        Http2Stream streamA = stream(STREAM_A);
        Http2Stream streamB = stream(STREAM_B);
        Http2Stream streamC = stream(STREAM_C);
        Http2Stream streamD = stream(STREAM_D);

        reset(writer);
        doAnswer(writeAnswer(true)).when(writer).write(any(Http2Stream.class), anyInt());

        assertFalse(write(400 + 600 + 700));
        assertEquals(400, captureWrites(streamA));
        verifyNeverWrite(streamB);
        assertEquals(600, captureWrites(streamC));
        assertEquals(700, captureWrites(streamD));