* ACE and <i>all</i> of the bits in the desired access bits match bits in
 * the access mask of the ACE, the access check is successful. Otherwise,
 * more ACEs are evaluated until all desired access bits (combined)
 * are "allowed". If all of the desired access bits are not "allowed"
 * the then same process is repeated for inherited ACEs.
 * <p>
 * For example, if user <code>WNET\alice</code> tries to open a file

                0x00000020, // FILE_ATTRIBUTE_ARCHIVE
                0x00000080, // FILE_ATTRIBUTE_NORMAL
                0x00000100, // FILE_ATTRIBUTE_TEMPORARY
                0x00000037 // Combined attributes
        };

        for (int attr : attributes) {
            FileBasicInfo info = new FileBasicInfo(0L, 0L, 0L, 0L, attr);
            assertEquals(attr, info.getAttributes());

        void shouldSupportBitwiseOperations() {
            // Test combining read and write permissions
            int readWrite = ACE.FILE_READ_DATA | ACE.FILE_WRITE_DATA;
            assertEquals(0x00000003, readWrite, "Combined read/write should be 0x00000003");

            // Test checking individual bits
            assertTrue((readWrite & ACE.FILE_READ_DATA) != 0, "Should contain FILE_READ_DATA bit");

      .newBuilder()
      .body(RealResponseBody(contentType, contentLength, cacheWritingSource.buffer()))
      .build()
  }

  companion object {
    /** Combines cached headers with a network headers as defined by RFC 7234, 4.3.4. */
    private fun combine(
      cachedHeaders: Headers,
      networkHeaders: Headers,
    ): Headers {
      val result = Headers.Builder()

    ImmutableBiMap.Builder<String, Integer> zat =
        ImmutableBiMap.<String, Integer>builder().put("two", 2).put("three", 3);
    ImmutableBiMap<String, Integer> biMap = zis.combine(zat).build();
    assertMapEquals(biMap, "one", 1, "two", 2, "three", 3);
  }

  // TODO(b/172823566): Use mainline testToImmutableBiMap once CollectorTester is usable to java7.

      for (Entry<? extends K, ? extends V> entry : entries) {
        put(entry);
      }
      return this;
    }

    @CanIgnoreReturnValue
    Builder<K, V> combine(Builder<K, V> other) {
      super.combine(other);
      return this;
    }

    @Override
    public Builder<K, V> orderEntriesByValue(Comparator<? super V> valueComparator) {

 * ACE and <i>all</i> of the bits in the desired access bits match bits in
 * the access mask of the ACE, the access check is successful. Otherwise,
 * more ACEs are evaluated until all desired access bits (combined)
 * are "allowed". If all of the desired access bits are not "allowed"
 * the then same process is repeated for inherited ACEs.
 * <p>
 * For example, if user <code>WNET\alice</code> tries to open a file

        when(logonInfo.getUserFlags()).thenReturn(PacConstants.LOGON_RESOURCE_GROUPS);
        assertEquals(PacConstants.LOGON_RESOURCE_GROUPS, logonInfo.getUserFlags());

        // Test with combined flags
        int combinedFlags = PacConstants.LOGON_EXTRA_SIDS | PacConstants.LOGON_RESOURCE_GROUPS;
        when(logonInfo.getUserFlags()).thenReturn(combinedFlags);

 * ACE and <i>all</i> of the bits in the desired access bits match bits in
 * the access mask of the ACE, the access check is successful. Otherwise,
 * more ACEs are evaluated until all desired access bits (combined)
 * are "allowed". If all of the desired access bits are not "allowed"
 * the then same process is repeated for inherited ACEs.
 * <p>
 * For example, if user <code>WNET\alice</code> tries to open a file

        // Why? The second half of condition2 requires that nodeV equals other.nodeU.
        // We already know that nodeU equals other.nodeU. Combined with the earlier statement,
        // and the transitive property of equality, this implies that nodeU equals nodeV.
        // If nodeU equals nodeV, condition1 == condition2, so checking condition1 is sufficient.