try {
                crawlingInfoService.delete(entity);
                saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToDeleteCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
        }).orElse(() -> {

                    // ensure connected
                    trans.ensureConnected();
                    refServerName = trans.getRemoteHostName();
                } catch (final IOException e) {
                    log.warn("Failed to connect to domain controller", e);
                }
                dr = getReferral(tf, trans, domain, domain, refServerName, root, null);
            }
        }

        if (log.isTraceEnabled()) {

        try (SamrPolicyHandle handle = new SamrPolicyHandle(mockHandle, server, access)) {
            assertNotNull(handle);
            // Verify that sendrecv was called with MsrpcSamrConnect4
            verify(mockHandle, times(1)).sendrecv(any(MsrpcSamrConnect4.class));
            verify(mockHandle, never()).sendrecv(any(MsrpcSamrConnect2.class));
        }
    }

    @Test

     * <p>
     * This instant serves as the base time from which all subsequent {@link #instant()}
     * calls are calculated by adding the elapsed monotonic duration. This ensures
     * consistency between the monotonic measurements and wall clock time.
     *
     * @return the initial wall clock instant when this clock was created
     * @see #instant()
     */

            try {
                pathMappingService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),
                        this::asEditHtml);
            }

import okhttp3.internal.deleteIfExists
import okhttp3.internal.isCivilized
import okhttp3.internal.okHttpName
import okhttp3.internal.platform.Platform
import okhttp3.internal.platform.Platform.Companion.WARN
import okio.BufferedSink
import okio.FileNotFoundException
import okio.FileSystem
import okio.ForwardingFileSystem
import okio.ForwardingSource
import okio.Path
import okio.Sink
import okio.Source

        request = new Smb2QueryInfoRequest(mockConfig);
        byte testFileInfoClass = (byte) 0x10;

        request.setFileInfoClass(testFileInfoClass);

        // Verify file info class was set and info type was set to SMB2_0_INFO_FILE
        try {
            Field fileInfoClassField = Smb2QueryInfoRequest.class.getDeclaredField("fileInfoClass");
            fileInfoClassField.setAccessible(true);

  public val bodySize: Long,
  /**
   * The sizes of the chunks of this request's body, or null if the request's body was not encoded
   * with chunked encoding.
   */
  public val chunkSizes: List<Int>?,
  /**
   * The failure MockWebServer recorded when attempting to decode this request. If, for example,
   * the inbound request was truncated, this exception will be non-null.
   */
  public val failure: IOException? = null,
) {

            if (state.compareAndSet(State.HALF_OPEN, State.OPEN)) {
                stateChangeTime.set(System.currentTimeMillis());
                consecutiveFailures.set(1);
                log.warn("Circuit breaker {} reopened due to failure in HALF_OPEN state", name);
            }
        } else if (current == State.CLOSED) {
            int failures = consecutiveFailures.incrementAndGet();

                try {
                    list.add(new LabelTypePattern(labelType.getValue(), includedPaths, excludedPaths));
                } catch (final Exception e) {
                    logger.warn("Failed to create a matching pattern of a label: {}, includedPaths:{}, excludedPaths:{}",
                            labelType.getValue(), includedPaths, excludedPaths, e);
                }
            }
        }