* the configuration properties of the original map. During deserialization, if the original map had
 * used weak references, the entries are reconstructed as they were, but it's not unlikely they'll
 * be quickly garbage-collected before they are ever accessed.
 *
 * <p>{@code new MapMaker().weakKeys().makeMap()} is a recommended replacement for {@link
 * java.util.WeakHashMap}, but note that it compares keys using object identity whereas {@code

                            throw new UnknownHostException(name.name);
                        }
                        if (response.received && response.resultCode == 0) {

                            /* Before we return, in anticipation of this address being cached we must
                             * augment the addresses name's hashCode to distinguish those resolved by

     * creation call keeps "emitSettingsWarnings" false. If there are fatal issues, it will anyway "die" at that
     * spot before warnings would be emitted.
     * <p>
     * The method returns a "cleaner" runnable, as during extension loading the context needs to be "cleaned", restored
     * to previous state (as it was before extension loading).
     */

      }
    }.test();
  }

  public void testPartition_view() {
    List<Integer> list = asList(1, 2);
    Iterator<List<Integer>> partitions = Iterators.partition(list.iterator(), 1);

    // Changes before the partition is retrieved are reflected
    list.set(0, 3);
    List<Integer> first = partitions.next();

    // Changes after are not
    list.set(0, 4);

    assertEquals(ImmutableList.of(3), first);

                    final List<String> list = new ArrayList<>();
                    final String permissions = stream(entity.getPermissions()).get(stream -> stream.map(s -> permissionHelper.decode(s))
                            .filter(StringUtil::isNotBlank)
                            .distinct()
                            .collect(Collectors.joining(",")));

        excludedPackages.add("org.gradle.tooling.**");
        excludedPackages.add("org.gradle.testfixtures.**");

        // Tweak the imports due to some inconsistencies introduced before we automated the default-imports generation
        excludedPackages.add("org.gradle.plugins.ide.eclipse.model");
        excludedPackages.add("org.gradle.plugins.ide.idea.model");

        return false;
      }

      Entry<?, ?> entry = (Entry<?, ?>) object;
      inverse.delegate.remove(entry.getValue());
      /*
       * Remove the mapping in inverse before removing from esDelegate because
       * if entry is part of esDelegate, entry might be invalidated after the
       * mapping is removed from esDelegate.
       */
      esDelegate.remove(entry);
      return true;

                msgBuf = new NdrBuffer(receiveMoreFragments(msg, inB), 0);
            } else {
                msgBuf = new NdrBuffer(inB, 0);
            }
            msg.decode(msgBuf);
        } finally {
            this.transportContext.getBufferCache().releaseBuffer(inB);
            this.transportContext.getBufferCache().releaseBuffer(out);
        }

            this.async = false;
            this.nextResponse = null;
        }

        // CommonServerMessageBlock interface methods
        @Override
        public int decode(byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
            // Mock implementation
            return 0;
        }

        @Override
        public int encode(byte[] dst, int dstIndex) {

            assertThrows(SmbUnsupportedOperationException.class, () -> transport.calculatePreauthHash(new byte[] { 1 }, 0, 1, null));
        }

        @Test
        @DisplayName("calculatePreauthHash rejects dialects before SMB 3.1.1")
        void preauthHash_rejectsOldDialect() {
            setField(transport, "smb2", true);
            Smb2NegotiateResponse nego = new Smb2NegotiateResponse(cfg);
            // selectedDialect: SMB300