this.data = new byte[len];
            System.arraycopy(buffer, bufferIndex, this.data, 0, len);

            return len;
        }

        public byte[] getData() {
            return data;
        }

        public int getDecodeCallCount() {
            return decodeCallCount;
        }

        public void setThrowOnDecode(boolean throwOnDecode) {
            this.throwOnDecode = throwOnDecode;

            return xpathAPICache.get(Thread.currentThread().getName());
        } catch (final ExecutionException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to retrieval a cache.", e);
            }
            return new XPathAPI();
        }
    }

    /**
     * Creates and configures a DOM parser with the specified features and properties.
     *

    return classInfo(cls, cls.getClassLoader());
  }

  private static ClassInfo classInfo(Class<?> cls, ClassLoader classLoader) {
    String resource = cls.getName().replace('.', '/') + ".class";
    return new ClassInfo(FILE, resource, classLoader);
  }

  private static Manifest manifestClasspath(String classpath) throws IOException {
    return manifest("Class-Path: " + classpath + "\n");
  }

     *
     * @return an {@link Optional} containing the list of goals, or empty if not specified
     */
    @Nonnull
    Optional<List<String>> goals();

    /**
     * Returns the target POM model version for upgrades.
     * Supported values include "4.0.0" and "4.1.0".
     *
     * @return an {@link Optional} containing the model version, or empty if not specified
     */

     * the current count of the element in the multiset, depending on the implementation. Note that
     * in the former case, this method can never return zero, while in the latter, it will return
     * zero if all occurrences of the element were since removed from the multiset.
     *
     * @return the count of the element; never negative
     */
    int getCount();

    /**
     * {@inheritDoc}
     *

                    """
                        package com.example;

                        public abstract class Task {
                            public String getSourceCompatibility() {
                                return "";
                            }
                            public void setSourceCompatibility(String value) {
                            }
                        }
                    """
                )

                    }
                    return true;
                }
                return false;
            }
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Thumbnail generator is not found: {}", docMap != null ? docMap.get("url") : docMap);
        }
        return false;
    }

    /**

          private int rep;

          @Override
          public @Nullable Integer computeNext() {
            switch (rep++) {
              case 0:
                return 0;
              case 1:
                return 1;
              case 2:
                return endOfData();
              default:
                throw new AssertionError("Should not have been invoked again");
            }
          }
        };

                return await app(scope, receive, send)  # pragma: no cover

            async def call_next():
                return await app(scope, receive, send)

            websocket = WebSocket(scope, receive=receive, send=send)
            return await middleware_func(websocket, call_next)

        return wrapped_app

    return middleware_constructor

        public long getTotalValidations() {
            return totalValidations;
        }

        public long getFailedValidations() {
            return failedValidations;
        }

        public long getBufferOverflowsPrevented() {
            return bufferOverflowsPrevented;
        }

        public long getIntegerOverflowsPrevented() {
            return integerOverflowsPrevented;
        }