return sourceMap;
    }

    @Override
    protected void addFieldToSource(final Map<String, Object> sourceMap, final String field, final Object value) {
        if (value instanceof final LocalDateTime ldt) {
            final ZonedDateTime zdt = ZonedDateTime.of(ldt, ZoneId.systemDefault());
            super.addFieldToSource(sourceMap, field, DateTimeFormatter.ISO_INSTANT.format(zdt));
        } else {

   * #equals(Object)} to forward to this implementation.
   *
   * @since 7.0
   */
  protected boolean standardEquals(@Nullable Object object) {
    if (object instanceof Entry) {
      Entry<?, ?> that = (Entry<?, ?>) object;
      return Objects.equals(this.getKey(), that.getKey())
          && Objects.equals(this.getValue(), that.getValue());
    }
    return false;
  }

            return false;
        }

        PreauthIntegrityNegotiateContext rpc = null;
        for (final NegotiateContextRequest rnc : req.getNegotiateContexts()) {
            if (rnc instanceof PreauthIntegrityNegotiateContext) {
                rpc = (PreauthIntegrityNegotiateContext) rnc;
            }
        }
        if (rpc == null) {
            return false;
        }

    MyInt(int i) {
      this.i = i;
    }

    @Override
    public int hashCode() {
      return i;
    }

    @Override
    public boolean equals(Object o) {
      return o instanceof MyInt && ((MyInt) o).i == i;
    }
  }

  public void testAsFunction_simplistic() {
    String canonical = "a";
    String not = new String("a");

    Function<String, String> internerFunction =

    final int hash;

    Element(int hash) {
      this.hash = hash;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      return this == obj || (obj instanceof Element && ((Element) obj).hash == hash);
    }

    @Override
    public int hashCode() {
      return hash;
    }

    @Override
    public int compareTo(Element that) {

            fail("Should throw exception when no channels available");
        } catch (Exception e) {
            // Expected - no channels available
            assertTrue(e instanceof ChannelLoadBalancer.NoAvailableChannelException);
        }
    }

    @Test
    void testRemoveChannel() throws UnknownHostException {
        InetAddress addr = InetAddress.getByName("192.168.1.100");

    final int value;

    Collider(int value) {
      this.value = value;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      return obj instanceof Collider && ((Collider) obj).value == value;
    }

    @Override
    public int hashCode() {
      return 1; // evil!
    }
  }

    }

    return derivedSuites;
  }

  @Override
  protected SetTestSuiteBuilder<K> createDerivedKeySetSuite(TestSetGenerator<K> keySetGenerator) {
    return keySetGenerator instanceof TestSortedSetGenerator
        ? SortedSetTestSuiteBuilder.using((TestSortedSetGenerator<K>) keySetGenerator)
        : SetTestSuiteBuilder.using(keySetGenerator);
  }

  /**

                final StringBuilder headingText = new StringBuilder();
                Node child = heading.getFirstChild();
                while (child != null) {
                    if (child instanceof Text) {
                        headingText.append(((Text) child).getLiteral());
                    }
                    child = child.getNext();
                }
                if (headingText.length() > 0) {

            return new PathSource(path.resolve(relative));
        }

        @Override
        public boolean equals(Object o) {
            return o == this || o instanceof PathSource that && Objects.equals(path, that.path);
        }

        @Override
        public int hashCode() {
            return Objects.hash(path);
        }

        @Override