return Integer.valueOf(3);
        }

        /**
         * @return BigDecimal
         */
        public BigDecimal getGgg() {
            return ggg_;
        }

        /**
         * @param ggg
         */
        public void setGgg(final BigDecimal ggg) {
            ggg_ = ggg;
        }

        /**
         * @return Timestamp
         */

            this.closed = false;
        }

        boolean isAlive() {
            return resourceRef.get() != null && !closed;
        }

        long getAge() {
            return System.currentTimeMillis() - creationTime;
        }
    }

    private ResourceManager() {
        ThreadFactory threadFactory = r -> {

            RequirementMatcher matcher = provides.get(key);

            if (matcher == null) {
                getLog().debug("Toolchain {} is missing required property: {}", this, key);
                return false;
            }
            if (!matcher.matches(requirement.getValue())) {
                getLog().debug("Toolchain {} doesn't match required property: {}", this, key);
                return false;
            }
        }

 *   INSTANCE;
 *   public void funnel(Person person, PrimitiveSink into) {
 *     into.putUnencodedChars(person.getFirstName())
 *         .putUnencodedChars(person.getLastName())
 *         .putInt(person.getAge());
 *   }
 * }
 * }
 *
 * @author Dimitris Andreou
 * @since 11.0
 */
@Beta
@DoNotMock("Implement with a lambda")
public interface Funnel<T extends @Nullable Object> extends Serializable {

  /**

     * Creates a new instance of JclLoggerAdapter.
     *
     * @param name the logger name
     */
    public JclLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = LogFactory.getLog(clazz);
    }

    @Override
    public boolean isFatalEnabled() {
        return logger.isFatalEnabled();
    }

    @Override
    public void fatal(final String message) {
        logger.fatal(message);

    }

    @Test
    void testGetLogger() {
        ToolchainModel model = new ToolchainModel();
        DefaultToolchain toolchain = newDefaultToolchain(model);
        assertEquals(logger, toolchain.getLog());
    }

    @Test
    void testMissingRequirementProperty() {
        ToolchainModel model = new ToolchainModel();
        model.setType("TYPE");
        DefaultToolchain toolchain = newDefaultToolchain(model);

            return b.toString();
        }).collect(Collectors.joining(",")));
        buf.append("},");
        final GarbageCollectors gc = jvmStats.getGc();
        buf.append("\"gc\":{");
        buf.append(Arrays.stream(gc.getCollectors()).map(c -> {
            final StringBuilder b = new StringBuilder();

            jvmPoolObj.capacity = p.getTotalCapacity().getBytes();
            return jvmPoolObj;
        }).toArray(n -> new JvmPoolObj[n]);
        final GarbageCollectors gc = jvmStats.getGc();
        jvmObj.gc = Arrays.stream(gc.getCollectors()).map(c -> {
            final JvmGcObj jvmGcObj = new JvmGcObj();
            jvmGcObj.key = c.getName();
            jvmGcObj.count = c.getCollectionCount();