return FileConfigDbm.getInstance();
    }

    @Override
    protected <RESULT extends FileConfig> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setAvailable(DfTypeUtil.toBoolean(source.get("available")));
            result.setBoost(DfTypeUtil.toFloat(source.get("boost")));

        // UTime is seconds since epoch, so divide by 1000
        long unixTime = time / 1000L;

        // Mocking date for timezone consistency
        TimeZone original = TimeZone.getDefault();
        try {
            TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
            ServerMessageBlock.writeUTime(unixTime * 1000L, buffer, 0);
            long readTime = ServerMessageBlock.readUTime(buffer, 0);

            throwValidationErrorApi(messages -> messages.addErrorsFailedToUploadProtwordsFile(GLOBAL));
            return null;
        });
        try (InputStream inputStream = form.synonymFile.getInputStream()) {
            file.update(inputStream);
        } catch (final IOException e) {
            logger.warn("Failed to process a request.", e);

        TestHttpServletRequest request = new TestHttpServletRequest();
        TestHttpServletResponse response = new TestHttpServletResponse();
        TestFilterChain chain = new TestFilterChain();

        try {
            manager.process(request, response, chain);
            fail("Expected ServletException");
        } catch (ServletException e) {
            assertEquals("Test error", e.getMessage());
        }
    }

        this.setProjectRequired(md.isProjectRequired());
        this.setSince(md.getSince());
        this.setThreadSafe(true);
        this.setImplementation(md.getImplementation());
        try {
            this.setParameters(md.getParameters().stream().map(Parameter::new).collect(Collectors.toList()));
        } catch (DuplicateParameterException e) {
            throw new IllegalArgumentException(e);
        }

      it is ConnectionAcquired ||
      it is ConnectionReleased ||
      it is Canceled ||
      it is RequestFailed ||
      it is ResponseFailed

  private fun sleep(delayMillis: Int) {
    try {
      Thread.sleep(delayMillis.toLong())
    } catch (e: InterruptedException) {
      Thread.currentThread().interrupt()
    }
  }

  private fun cancelLater(
    call: Call,
    delayMillis: Int,

  }

  @Override
  @CanIgnoreReturnValue
  public final Hasher putBytes(ByteBuffer readBuffer) {
    ByteOrder order = readBuffer.order();
    try {
      readBuffer.order(ByteOrder.LITTLE_ENDIAN);
      return putBytesInternal(readBuffer);
    } finally {
      readBuffer.order(order);
    }
  }

  @CanIgnoreReturnValue

            range1.isConnected(range2) && !range1.intersection(range2).isEmpty();
        ImmutableRangeMap.Builder<Integer, Integer> builder = ImmutableRangeMap.builder();
        builder.put(range1, 1).put(range2, 2);
        try {
          ImmutableRangeMap<Integer, Integer> unused = builder.build();
          assertFalse(expectRejection);
        } catch (IllegalArgumentException e) {
          assertTrue(expectRejection);
        }
      }

            SmbResource resource = createMockResource();

            // When/Then
            assertDoesNotThrow(() -> {
                try (SmbResource r = resource) {
                    // Resource will be automatically closed
                }
            }, "Should work in try-with-resources");
        }

        @Test
        @DisplayName("multiple operations should work together")

        if (ingestFactory == null) {
            return dataMap;
        }
        Map<String, Object> target = dataMap;
        for (final Ingester ingester : ingestFactory.getIngesters()) {
            try {
                target = ingester.process(target, paramMap);
            } catch (final Exception e) {
                logger.warn("[{}] Failed to process ingester", ingester.getClass().getSimpleName(), e);
            }