Tests to verify proper life-cycle of RecyclerPool implementations, from databind perspective

src/test/java/com/fasterxml/jackson/databind/util/BufferRecyclersDatabindTest.java

@@ -1,6 +1,10 @@
 package com.fasterxml.jackson.databind.util;
 
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
 import java.nio.charset.StandardCharsets;
+import java.util.function.Predicate;
 
 import com.fasterxml.jackson.annotation.JsonPropertyOrder;
 
@@ -54,6 +58,10 @@ public void testParserWithBoundedPool() throws Exception {
         _testParser(JsonRecyclerPools.sharedBoundedPool());
     }
 
+    public void testParserWithHybridPool() throws Exception {
+        _testParser(new HybridTestPool());
+    }
+
     private void _testParser(RecyclerPool<BufferRecycler> pool) throws Exception
     {
         ObjectMapper mapper = JsonMapper.builder(
@@ -100,6 +108,10 @@ public void testGeneratorWithBoundedPool() throws Exception {
         _testGenerator(JsonRecyclerPools.sharedBoundedPool());
     }
 
+    public void testGeneratorWithHybridPool() throws Exception {
+        _testGenerator(new HybridTestPool());
+    }
+
     private void _testGenerator(RecyclerPool<BufferRecycler> pool) throws Exception
     {
         ObjectMapper mapper = JsonMapper.builder(
@@ -115,4 +127,65 @@ private void _testGenerator(RecyclerPool<BufferRecycler> pool) throws Exception
         assertEquals(EXP, new String(mapper.writeValueAsBytes(new Pojo4321(-42, "bogus")),
                 StandardCharsets.UTF_8));
     }
+
+    static class HybridTestPool implements RecyclerPool<BufferRecycler>
+    {
+        private static final long serialVersionUID = 1L;
+
+        private static final Predicate<Thread> isVirtual = VirtualPredicate.findIsVirtualPredicate();
+
+        private final RecyclerPool<BufferRecycler> nativePool = JsonRecyclerPools.threadLocalPool();
+        private final RecyclerPool<BufferRecycler> virtualPool = JsonRecyclerPools.newLockFreePool();
+
+        @Override
+        public BufferRecycler acquirePooled() {
+            return isVirtual.test(Thread.currentThread()) ?
+                    virtualPool.acquirePooled() :
+                    nativePool.acquirePooled();
+        }
+
+        @Override
+        public void releasePooled(BufferRecycler pooled) {
+            if (isVirtual.test(Thread.currentThread())) {
+                virtualPool.releasePooled(pooled);
+            } else {
+                nativePool.releasePooled(pooled);
+            }
+        }
+
+        static class VirtualPredicate {
+            static final MethodHandle virtualMh = findVirtualMH();
+
+            static MethodHandle findVirtualMH() {
+                try {
+                    return MethodHandles.publicLookup().findVirtual(Thread.class, "isVirtual",
+                            MethodType.methodType(boolean.class));
+                } catch (Exception e) {
+                    return null;
+                }
+            }
+
+            static Predicate<Thread> findIsVirtualPredicate() {
+                if (virtualMh != null) {
+                    return new Predicate<Thread>() {
+                        @Override
+                        public boolean test(Thread thread) {
+                            try {
+                                return (boolean) virtualMh.invokeExact(thread);
+                            } catch (Throwable e) {
+                                throw new RuntimeException(e);
+                            }
+                        }
+                    };
+                }
+
+                return new Predicate<Thread>() {
+                    @Override
+                    public boolean test(Thread thread) {
+                        return false;
+                    }
+                };
+            }
+        }
+    }
 }