)

    return certificates.single() as X509Certificate
  } catch (nsee: NoSuchElementException) {
    throw IllegalArgumentException("failed to decode certificate", nsee)
  } catch (iae: IllegalArgumentException) {
    throw IllegalArgumentException("failed to decode certificate", iae)
  } catch (e: GeneralSecurityException) {
    throw IllegalArgumentException("failed to decode certificate", e)
  }
}

#!/usr/bin/env bash

echo "Running $0"

if [ -n "$TEST_DEBUG" ]; then
	set -x
fi

trap 'catch $LINENO' ERR

# shellcheck disable=SC2120
catch() {
	if [ $# -ne 0 ]; then
		echo "error on line $1"
		echo "dc1 server logs ========="
		cat /tmp/dc1.log
		echo "dc2 server logs ========="
		cat /tmp/dc2.log
	fi

	echo "Cleaning up instances of MinIO"
	set +e
	pkill minio
	pkill mc
	rm -rf /tmp/xl/

            });
            return null;
        });
        try {
            badWordService.store(entity);
            suggestHelper.addBadWord(entity.getSuggestWord(), false);
        } catch (final Exception e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
        }

            circuitBreaker.call(() -> {
                try {
                    doConnectInternal();
                    return null;
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
        } catch (SimpleCircuitBreaker.CircuitBreakerOpenException e) {
            // Log circuit breaker rejection

        } catch (final Exception e) {
            throw new CrawlingAccessException("Could not extract data.", e);
        }

        final ResultData resultData = new ResultData();
        resultData.setTransformerName(getName());
        try {
            resultData.setData(content.getBytes(charsetName));
        } catch (final UnsupportedEncodingException e) {

  }

  @MapFeature.Require(value = SUPPORTS_REMOVE, absent = ALLOWS_NULL_KEY_QUERIES)
  public void testRemove_nullKeyQueriesUnsupported() {
    try {
      assertFalse(getMap().remove(null, v3()));
    } catch (NullPointerException tolerated) {
      // since the operation would be a no-op, the exception is not required
    }
    expectUnchanged();
  }

                    return item;
                } catch (final IOException e) {
                    throw new DictionaryException("Failed to write: " + item, e);
                }
            }
            return null;
        }

        @Override
        public void close() {
            try {
                writer.flush();
            } catch (final IOException e) {
                // ignore

            this.rpcHandle.bind();
            this.connected = true;

            log.debug("Connected to witness service at {}", serverAddress.getHostAddress());
        } catch (Exception e) {
            throw new IOException("Failed to connect to witness service", e);
        }
    }

    /**
     * Builds the RPC URL for the witness service.
     *

                    } catch (Exception e) {
                        logger.warn("Failed to set originalOutStream.", e);
                    }
                }
                if (originalErrStream != null) {
                    try {
                        System.setErr(originalErrStream);
                    } catch (Exception e) {

        try {
            return constructor.newInstance(args);
        } catch (final InstantiationException e) {
            throw new InstantiationRuntimeException(constructor.getDeclaringClass(), e);
        } catch (final IllegalAccessException e) {
            throw new IllegalAccessRuntimeException(constructor.getDeclaringClass(), e);
        } catch (final InvocationTargetException e) {