From 9d759d2530a32d879f5d165901cf8c70214fb439 Mon Sep 17 00:00:00 2001 From: Norman Maurer Date: Mon, 5 Dec 2016 08:10:17 +0100 Subject: [PATCH] Ensure leak aware buffers correctly close the ResourceLeakTracker Motivation: We should assert that the leak aware buffers correctly close the ResourceLeakTracker in the unit tests. Modifications: - Keep track of NoopResourceLeakTrackers and check if these were closed once the test completes - Fix bugs in tests so the buffers are all released. Result: Better tests for leak aware buffers --- .../buffer/AdvancedLeakAwareByteBufTest.java | 6 ++- ...AdvancedLeakAwareCompositeByteBufTest.java | 6 ++- .../buffer/SimpleLeakAwareByteBufTest.java | 47 +++++++++++++++++-- .../SimpleLeakAwareCompositeByteBufTest.java | 46 ++++++++++++++++-- 4 files changed, 93 insertions(+), 12 deletions(-) diff --git a/buffer/src/test/java/io/netty/buffer/AdvancedLeakAwareByteBufTest.java b/buffer/src/test/java/io/netty/buffer/AdvancedLeakAwareByteBufTest.java index bec7694609..4e7747b3b6 100644 --- a/buffer/src/test/java/io/netty/buffer/AdvancedLeakAwareByteBufTest.java +++ b/buffer/src/test/java/io/netty/buffer/AdvancedLeakAwareByteBufTest.java @@ -15,6 +15,8 @@ */ package io.netty.buffer; +import io.netty.util.ResourceLeakTracker; + public class AdvancedLeakAwareByteBufTest extends SimpleLeakAwareByteBufTest { @Override @@ -23,7 +25,7 @@ public class AdvancedLeakAwareByteBufTest extends SimpleLeakAwareByteBufTest { } @Override - protected ByteBuf wrap(ByteBuf buffer) { - return new AdvancedLeakAwareByteBuf(buffer, new NoopResourceLeakTracker()); + protected SimpleLeakAwareByteBuf wrap(ByteBuf buffer, ResourceLeakTracker tracker) { + return new AdvancedLeakAwareByteBuf(buffer, tracker); } } diff --git a/buffer/src/test/java/io/netty/buffer/AdvancedLeakAwareCompositeByteBufTest.java b/buffer/src/test/java/io/netty/buffer/AdvancedLeakAwareCompositeByteBufTest.java index 045fd354c9..fd56e72332 100644 --- a/buffer/src/test/java/io/netty/buffer/AdvancedLeakAwareCompositeByteBufTest.java +++ b/buffer/src/test/java/io/netty/buffer/AdvancedLeakAwareCompositeByteBufTest.java @@ -15,11 +15,13 @@ */ package io.netty.buffer; +import io.netty.util.ResourceLeakTracker; + public class AdvancedLeakAwareCompositeByteBufTest extends SimpleLeakAwareCompositeByteBufTest { @Override - protected WrappedCompositeByteBuf wrap(CompositeByteBuf buffer) { - return new AdvancedLeakAwareCompositeByteBuf(buffer, new NoopResourceLeakTracker()); + protected SimpleLeakAwareCompositeByteBuf wrap(CompositeByteBuf buffer, ResourceLeakTracker tracker) { + return new AdvancedLeakAwareCompositeByteBuf(buffer, tracker); } @Override diff --git a/buffer/src/test/java/io/netty/buffer/SimpleLeakAwareByteBufTest.java b/buffer/src/test/java/io/netty/buffer/SimpleLeakAwareByteBufTest.java index a4b480d784..b74e8a25cd 100644 --- a/buffer/src/test/java/io/netty/buffer/SimpleLeakAwareByteBufTest.java +++ b/buffer/src/test/java/io/netty/buffer/SimpleLeakAwareByteBufTest.java @@ -15,19 +15,57 @@ */ package io.netty.buffer; -import org.junit.Assert; +import io.netty.util.ResourceLeakTracker; +import org.junit.After; +import org.junit.Before; import org.junit.Test; +import java.util.ArrayDeque; +import java.util.Queue; + +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; + public class SimpleLeakAwareByteBufTest extends BigEndianHeapByteBufTest { private final Class clazz = leakClass(); + private final Queue> trackers = new ArrayDeque>(); @Override protected final ByteBuf newBuffer(int capacity) { return wrap(super.newBuffer(capacity)); } - protected ByteBuf wrap(ByteBuf buffer) { - return new SimpleLeakAwareByteBuf(buffer, new NoopResourceLeakTracker()); + private ByteBuf wrap(ByteBuf buffer) { + NoopResourceLeakTracker tracker = new NoopResourceLeakTracker(); + ByteBuf leakAwareBuf = wrap(buffer, tracker); + trackers.add(tracker); + return leakAwareBuf; + } + + protected SimpleLeakAwareByteBuf wrap(ByteBuf buffer, ResourceLeakTracker tracker) { + return new SimpleLeakAwareByteBuf(buffer, tracker); + } + + @Before + @Override + public void init() { + super.init(); + trackers.clear(); + } + + @After + @Override + public void dispose() { + super.dispose(); + + for (;;) { + NoopResourceLeakTracker tracker = trackers.poll(); + + if (tracker == null) { + break; + } + assertTrue(tracker.get()); + } } protected Class leakClass() { @@ -48,6 +86,7 @@ public class SimpleLeakAwareByteBufTest extends BigEndianHeapByteBufTest { public void testWrapReadSlice() { assertWrapped(newBuffer(8).readSlice(1)); } + @Test public void testWrapDuplicate() { assertWrapped(newBuffer(8).duplicate()); @@ -55,7 +94,7 @@ public class SimpleLeakAwareByteBufTest extends BigEndianHeapByteBufTest { protected final void assertWrapped(ByteBuf buf) { try { - Assert.assertSame(clazz, buf.getClass()); + assertSame(clazz, buf.getClass()); } finally { buf.release(); } diff --git a/buffer/src/test/java/io/netty/buffer/SimpleLeakAwareCompositeByteBufTest.java b/buffer/src/test/java/io/netty/buffer/SimpleLeakAwareCompositeByteBufTest.java index e4953cbd51..9d1a9e6ed1 100644 --- a/buffer/src/test/java/io/netty/buffer/SimpleLeakAwareCompositeByteBufTest.java +++ b/buffer/src/test/java/io/netty/buffer/SimpleLeakAwareCompositeByteBufTest.java @@ -15,16 +15,54 @@ */ package io.netty.buffer; -import org.junit.Assert; +import io.netty.util.ResourceLeakTracker; +import org.junit.After; +import org.junit.Before; import org.junit.Test; +import java.util.ArrayDeque; +import java.util.Queue; + +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; + public class SimpleLeakAwareCompositeByteBufTest extends WrappedCompositeByteBufTest { private final Class clazz = leakClass(); + private final Queue> trackers = new ArrayDeque>(); @Override - protected WrappedCompositeByteBuf wrap(CompositeByteBuf buffer) { - return new SimpleLeakAwareCompositeByteBuf(buffer, new NoopResourceLeakTracker()); + protected final WrappedCompositeByteBuf wrap(CompositeByteBuf buffer) { + NoopResourceLeakTracker tracker = new NoopResourceLeakTracker(); + WrappedCompositeByteBuf leakAwareBuf = wrap(buffer, tracker); + trackers.add(tracker); + return leakAwareBuf; + } + + protected SimpleLeakAwareCompositeByteBuf wrap(CompositeByteBuf buffer, ResourceLeakTracker tracker) { + return new SimpleLeakAwareCompositeByteBuf(buffer, tracker); + } + + @Before + @Override + public void init() { + super.init(); + trackers.clear(); + } + + @After + @Override + public void dispose() { + super.dispose(); + + for (;;) { + NoopResourceLeakTracker tracker = trackers.poll(); + + if (tracker == null) { + break; + } + assertTrue(tracker.get()); + } } protected Class leakClass() { @@ -53,7 +91,7 @@ public class SimpleLeakAwareCompositeByteBufTest extends WrappedCompositeByteBuf protected final void assertWrapped(ByteBuf buf) { try { - Assert.assertSame(clazz, buf.getClass()); + assertSame(clazz, buf.getClass()); } finally { buf.release(); }