assertTrue(indexExportJob.createFormatter("HTML") instanceof HtmlIndexExportFormatter);
        assertTrue(indexExportJob.createFormatter("Json") instanceof JsonIndexExportFormatter);
        assertTrue(indexExportJob.createFormatter("JSON") instanceof JsonIndexExportFormatter);
    }

    @Test
    public void test_createFormatter_unsupported() {
        try {
            indexExportJob.createFormatter("xml");

        return result;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }

        if (other instanceof Restriction restriction) {
            if (lowerBound != null) {
                if (!lowerBound.equals(restriction.lowerBound)) {
                    return false;
                }

            skipNode.set("skip", skipChild);
        }
    }


    @Override
    public void transformTest(ObjectNode parent) {
        if (testName.isBlank() == false) {
            assert parent.get(testName) instanceof ArrayNode;
            addSkip((ArrayNode) parent.get(testName));
        }
    }

    @Override
    public String getKeyToFind() {
        return testName;
    }

    @Input

  public int hashCode() {
    return -forwardOrder.hashCode();
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ReverseOrdering) {
      ReverseOrdering<?> that = (ReverseOrdering<?>) object;
      return this.forwardOrder.equals(that.forwardOrder);
    }
    return false;
  }

  @Override

        SmbAuthException ex = new SmbAuthException(errCode);

        // Assert: type, message derived from code, status mapping, and no cause
        assertNotNull(ex);
        assertTrue(ex instanceof SmbException);
        assertEquals(SmbException.getMessageByCode(errCode), ex.getMessage(), "message should reflect error code mapping");
        assertEquals(expectedStatus, ex.getNtStatus(), "status should map based on code");

        this.typeRegistry = requireNonNull(typeRegistry, "null typeRegistry");
        this.allHandlers = new ConcurrentHashMap<>();
    }

    @Override
    public void onEvent(Object event) {
        if (event instanceof ExecutionEvent executionEvent) {
            if (executionEvent.getType() == ExecutionEvent.Type.SessionEnded) {
                allHandlers.clear();
            }
        }
    }

    @Override

    public void deleteSearchLog(final Object e) {
        if (e instanceof final ClickLog clickLog) {
            clickLogBhv.delete(clickLog);
        } else if (e instanceof final FavoriteLog favoriteLog) {
            favoriteLogBhv.delete(favoriteLog);
        } else if (e instanceof final UserInfo userInfo) {
            userInfoBhv.delete(userInfo);
        } else if (e instanceof final SearchLog searchLog) {

     * we always return a new instance with a null valueComparator, as we already do if the input is
     * empty or a partial view?
     *
     * Related: Should methods that do accept a comparator (like fromMapEntries, or like this one if
     * we were to choose to *preserve* an input comparator) return not the generic empty of()
     * instance but instead an empty ImmutableSetMultimap instance with the requested

    return delegate.get(key);
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ImmutableEnumMap) {
      object = ((ImmutableEnumMap<?, ?>) object).delegate;
    }
    return delegate.equals(object);
  }

  @Override
  UnmodifiableIterator<Entry<K, V>> entryIterator() {

            } catch (final SmbAuthException sae) {
                throw sae;
            } catch (final SmbException se) {
                fp = 0L;
            }
        }
        if (file instanceof SmbNamedPipe && file.unc.startsWith("\\pipe\\")) {
            file.unc = file.unc.substring(5);
            file.send(new TransWaitNamedPipe("\\pipe" + file.unc), new TransWaitNamedPipeResponse());
        }