org.springframework.http.ReactiveHttpInputMessage#io.netty.util.IllegalReferenceCountException源码实例Demo

@Test // SPR-17054
public void unsupportedMediaTypeShouldConsumeAndCancel() {
	NettyDataBufferFactory factory = new NettyDataBufferFactory(new PooledByteBufAllocator(true));
	NettyDataBuffer buffer = factory.wrap(ByteBuffer.wrap("spring".getBytes(StandardCharsets.UTF_8)));
	TestPublisher<DataBuffer> body = TestPublisher.create();

	MockClientHttpResponse response = new MockClientHttpResponse(HttpStatus.OK);
	response.getHeaders().setContentType(MediaType.APPLICATION_PDF);
	response.setBody(body.flux());

	BodyExtractor<Mono<User>, ReactiveHttpInputMessage> extractor = BodyExtractors.toMono(User.class);
	StepVerifier.create(extractor.extract(response, this.context))
			.then(() -> {
				body.assertWasSubscribed();
				body.emit(buffer);
			})
			.expectErrorSatisfies(throwable -> {
				assertTrue(throwable instanceof UnsupportedMediaTypeException);
				try {
					buffer.release();
					Assert.fail("releasing the buffer should have failed");
				}
				catch (IllegalReferenceCountException exc) {
				}
				body.assertCancelled();
			}).verify();
}
 

@Override
public void dispose() {
    int refCnt;

    do {
        refCnt = get();

        if (refCnt <= 0) {
            throw new IllegalReferenceCountException(refCnt);
        }
    } while (!compareAndSet(refCnt, refCnt - 1));
}
 

@Override
public void dispose() {
    int last = getAndDecrement();
    if (last <= 0) {
        throw new IllegalReferenceCountException(last);
    }
}
 

@Test(expected = IllegalReferenceCountException.class)
public void shouldErrorOnDoubleReleaseArrayReferenceCounted() throws Exception {
    ByteBuf buf = Unpooled.buffer();
    buf.writeBytes(byteBufOf("*2\r\n"));
    buf.writeBytes(byteBufOf("*3\r\n:1\r\n:2\r\n:3\r\n"));
    buf.writeBytes(byteBufOf("*2\r\n+Foo\r\n-Bar\r\n"));
    assertTrue(channel.writeInbound(buf));

    ArrayRedisMessage msg = channel.readInbound();

    ReferenceCountUtil.release(msg);
    ReferenceCountUtil.release(msg);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void shouldErrorOnReleaseArrayChildReferenceCounted() throws Exception {
    ByteBuf buf = Unpooled.buffer();
    buf.writeBytes(byteBufOf("*2\r\n"));
    buf.writeBytes(byteBufOf("*3\r\n:1\r\n:2\r\n:3\r\n"));
    buf.writeBytes(byteBufOf("$3\r\nFoo\r\n"));
    assertTrue(channel.writeInbound(buf));

    ArrayRedisMessage msg = channel.readInbound();

    List<RedisMessage> children = msg.children();
    ReferenceCountUtil.release(msg);
    ReferenceCountUtil.release(children.get(1));
}
 

@Test(expected = IllegalReferenceCountException.class)
public void shouldErrorOnReleasecontentOfArrayChildReferenceCounted() throws Exception {
    ByteBuf buf = Unpooled.buffer();
    buf.writeBytes(byteBufOf("*2\r\n"));
    buf.writeBytes(byteBufOf("$3\r\nFoo\r\n$3\r\nBar\r\n"));
    assertTrue(channel.writeInbound(buf));

    ArrayRedisMessage msg = channel.readInbound();

    List<RedisMessage> children = msg.children();
    ByteBuf childBuf = ((FullBulkStringRedisMessage) children.get(0)).content();
    ReferenceCountUtil.release(msg);
    ReferenceCountUtil.release(childBuf);
}
 

@Test
public void testArrayAfterRelease() {
    ByteBuf buf = releasedBuffer();
    if (buf.hasArray()) {
        try {
            buf.array();
            fail();
        } catch (IllegalReferenceCountException e) {
            // expected
        }
    }
}
 

@Override
public ByteBuf content() {
    if (data.refCnt() <= 0) {
        throw new IllegalReferenceCountException(data.refCnt());
    }
    return data;
}
 

@Override
public ByteBuf content() {
    final ByteBuf data = (ByteBuf) super.payload();
    if (data.refCnt() <= 0) {
        throw new IllegalReferenceCountException(data.refCnt());
    }
    return data;
}
 

@Override
public ByteBuf content() {
    if (content.refCnt() <= 0) {
        throw new IllegalReferenceCountException(content.refCnt());
    }
    return content;
}
 

@Override
public ByteBuf content() {
    int count = refCnt();
    if (count <= 0) {
        throw new IllegalReferenceCountException(count);
    }

    return content;
}
 

@Override
public ByteBuf content() {
    int count = refCnt();
    if (count <= 0) {
        throw new IllegalReferenceCountException(count);
    }

    return content;
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testWriteBytesAfterRelease() {
    ByteBuf buffer = buffer(8);
    try {
        releasedBuffer().writeBytes(buffer);
    } finally {
        buffer.release();
    }
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testRetainOverflow() {
    AbstractReferenceCountedByteBuf referenceCounted = newReferenceCounted();
    referenceCounted.setRefCnt(Integer.MAX_VALUE);
    assertEquals(Integer.MAX_VALUE, referenceCounted.refCnt());
    referenceCounted.retain();
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testRetainResurrect() {
    AbstractReferenceCountedByteBuf referenceCounted = newReferenceCounted();
    assertTrue(referenceCounted.release());
    assertEquals(0, referenceCounted.refCnt());
    referenceCounted.retain();
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testRetainResurrect2() {
    AbstractReferenceCountedByteBuf referenceCounted = newReferenceCounted();
    assertTrue(referenceCounted.release());
    assertEquals(0, referenceCounted.refCnt());
    referenceCounted.retain(2);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testReadBytesAfterRelease3() {
    ByteBuf buffer = buffer(8);
    try {
        releasedBuffer().readBytes(buffer);
    } finally {
        buffer.release();
    }
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testGetBytesAfterRelease2() {
    ByteBuf buffer = buffer();
    try {
        releasedBuffer().getBytes(0, buffer, 1);
    } finally {
        buffer.release();
    }
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testWriteBytesAfterRelease3() {
    ByteBuf buffer = buffer(8);
    try {
        releasedBuffer().writeBytes(buffer, 0, 1);
    } finally {
        buffer.release();
    }
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testSetBytesAfterRelease3() {
    ByteBuf buffer = buffer();
    try {
        releasedBuffer().setBytes(0, buffer, 0, 1);
    } finally {
        buffer.release();
    }
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testForEachByteDescAfterRelease1() {
    releasedBuffer().forEachByteDesc(0, 1, new TestByteProcessor());
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testReadUnsignedMediumLEAfterRelease() {
    releasedBuffer().readUnsignedMediumLE();
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testWriteIntLEAfterRelease() {
    releasedBuffer().writeIntLE(1);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testReadFloatLEAfterRelease() {
    releasedBuffer().readFloatLE();
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testWriteIso88591CharSequenceAfterRelease() {
    testWriteCharSequenceAfterRelease0(CharsetUtil.ISO_8859_1);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testReadDoubleLEAfterRelease() {
    releasedBuffer().readDoubleLE();
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testNioBuffersAfterRelease2() {
    releasedBuffer().nioBuffers(0, 1);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testWriteCharAfterRelease() {
    releasedBuffer().writeChar(1);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testRetainOverflow2() {
    AbstractReferenceCountedByteBuf referenceCounted = newReferenceCounted();
    assertEquals(1, referenceCounted.refCnt());
    referenceCounted.retain(Integer.MAX_VALUE);
}
 

@Test(expected = IllegalReferenceCountException.class)
public void testReadBytesAfterRelease6() {
    releasedBuffer().readBytes(new byte[8], 0, 1);
}