}
                  throw new NoSuchFieldError("the Unsafe");
                });
      } catch (PrivilegedActionException e) {
        throw new RuntimeException("Could not initialize intrinsics", e.getCause());
      }
    }

    static {
      theUnsafe = getUnsafe();
      BYTE_ARRAY_BASE_OFFSET = theUnsafe.arrayBaseOffset(byte[].class);

      // sanity check - this should never fail

     */
    public static SmbOperationException forRetry(SmbOperationException original, int attemptNumber) {
        SmbOperationException retry = new SmbOperationException(original.errorCode, original.originalMessage, original.getCause(),
                original.retryPolicy, original.context);
        retry.setAttemptNumber(attemptNumber);
        return retry;
    }

    private void setAttemptNumber(int attemptNumber) {

        CIFSException ex = assertThrows(CIFSException.class, () -> trace.connectWrapException(loc));
        assertTrue(ex.getMessage() != null && ex.getMessage().contains("Failed to connect to server"));
        assertSame(thrown, ex.getCause());
    }

    @Test
    @DisplayName("connectWrapException: rethrows SmbException unchanged")
    void connectWrapException_rethrowsSmbException() throws Exception {
        // Arrange

  private Object invokeGeneratorMethod(Method generator, Object... args) {
    try {
      return generator.invoke(this, args);
    } catch (InvocationTargetException e) {
      throwIfUnchecked(e.getCause());
      throw new RuntimeException(e.getCause());
    } catch (Exception e) {
      throwIfUnchecked(e);
      throw new RuntimeException(e);
    }
  }

            }
        }

        return (List<ArtifactRepository>) repositories;
    }

    private ProjectBuildingException transformError(ProjectBuildingException e) {
        if (e.getCause() instanceof ModelBuildingException) {
            return new InvalidProjectModelException(e.getProjectId(), e.getMessage(), e.getPomFile());
        }

        return e;
    }

    @Override

            }
            return consumer.test(configId, url);
        } catch (final ThumbnailGenerationException e) {
            if (e.getCause() == null) {
                logger.debug(e.getMessage());
            } else {
                logger.warn("Failed to process {}", id, e);
            }
        } catch (final Exception e) {

      // mayInterruptIfRunning is irrelevant.
      cancel(false);
      return;
    } catch (ExecutionException e) {
      // Set the cause of the exception as this future's exception.
      setException(e.getCause());
      return;
    } catch (Exception e) { // sneaky checked exception
      // Bug in inputFuture.get(). Propagate to the output Future so that its consumers don't hang.
      setException(e);
      return;

     */
    protected String detailedMessage(final Throwable t) {
        if (t == null) {
            return "Unknown";
        }
        Throwable target = t;
        if (target.getCause() == null) {
            return target.getClass().getSimpleName() + "[" + target.getMessage() + "]";
        }
        final StringBuilder sb = new StringBuilder();
        while (target != null) {

            SerializableTester.reserialize(instance);
          } catch (Exception e) { // sneaky checked exception
            throw new AssertionError(
                "Serialization failed on return value of " + factory, e.getCause());
          }
        }
      }
      return this;
    }

    /**
     * Runs equals and serialization test on the return values.
     *

    assertThat(expected).hasCauseThat().hasMessageThat().isEqualTo("kaboom!");
    assertTrue(service.shutDownCalled);
    assertEquals(Service.State.FAILED, service.state());
    assertThat(expected.getCause().getSuppressed()[0]).hasMessageThat().isEqualTo("double kaboom!");
  }

  private class ThrowOnRunService extends AbstractExecutionThreadService {
    private boolean shutDownCalled = false;