}

    public void test_boolean() {
        Map<String, Object> doc = new HashMap<>();

        boolean expected8 = true;
        doc.put("key8", expected8);
        assertEquals(expected8, DocumentUtil.getValue(doc, "key8", Boolean.class).booleanValue());
    }

    private final String id;
    boolean ran = false;

    ThrowingTearDown(String id) {
      this.id = id;
    }

    @Override
    public void tearDown() throws Exception {
      ran = true;
      throw new RuntimeException(id);
    }
  }

  private static final class SimpleTearDown implements TearDown {

    boolean ran = false;
    @Nullable Callback callback = null;

    static final String MAVEN_METADATA_XML = "maven-metadata.xml";

    protected Metadata metadata;

    private final Path path;

    protected final Date timestamp;

    private boolean merged;

    @Deprecated
    protected MavenMetadata(Metadata metadata, File file, Date timestamp) {
        this(metadata, file != null ? file.toPath() : null, timestamp);
    }

      name = method.getName();
      parameterTypes = asList(method.getParameterTypes());
      typeSignature = new TypeSignature(method.getTypeParameters());
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof MethodSignature) {
        MethodSignature other = (MethodSignature) obj;
        return name.equals(other.name)

      name = method.getName();
      parameterTypes = asList(method.getParameterTypes());
      typeSignature = new TypeSignature(method.getTypeParameters());
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof MethodSignature) {
        MethodSignature other = (MethodSignature) obj;
        return name.equals(other.name)

   *
   * <p>This method returns {@code true} if and only if {@code Arrays.equals(bytes, new
   * String(bytes, UTF_8).getBytes(UTF_8))} does, but is more efficient in both time and space.
   */
  public static boolean isWellFormed(byte[] bytes) {
    return isWellFormed(bytes, 0, bytes.length);
  }

  /**
   * Returns whether the given byte array slice is a well-formed UTF-8 byte sequence, as defined by

          }
        };

    /** Per-thread dispatch state, used to avoid reentrant event dispatching. */
    private final ThreadLocal<Boolean> dispatching =
        new ThreadLocal<Boolean>() {
          @Override
          protected Boolean initialValue() {
            return false;
          }
        };

    @Override
    void dispatch(Object event, Iterator<Subscriber> subscribers) {

    /**
     * 
     */
    private static final long serialVersionUID = -2832037191318016836L;

    private byte[] ansiHash;
    private byte[] unicodeHash;
    private boolean hashesExternal = false;
    private CIFSContext context;


    /**
     * 
     */
    private NtlmPasswordAuthentication () {}


    /**
     * Construct anonymous credentials
     * 

            } else if (data instanceof Plugin) {
                plugin = (Plugin) data;
            }
            trace = trace.getParent();
        }

        Path trackingDir;
        boolean missing = event.getFile() == null;
        if (missing) {
            // missing artifact - let's track the path anyway
            File dir = event.getSession().getLocalRepository().getBasedir();
            dir = new File(

                        itemList.add(map);
                        break;
                    }
                }
            }
        }

        return itemList;
    }

    protected boolean matchLocale(final Locale requestLocale, final Locale targetLocale) {
        if (targetLocale.equals(requestLocale) || targetLocale.equals(Locale.ROOT)) {
            return true;
        }