default:
                    throw new UnknownHostException(hostname);
                }
                final UniAddress[] addrs = new UniAddress[1];
                addrs[0] = new UniAddress(addr);
                return addrs; // Success
            } catch (final IOException ioe) {
                // Failure
            }
        }
        throw new UnknownHostException(hostname);
    }

    /**

        // Arrange
        String server = "testServer";
        int access = 123;

        doThrow(new IOException("Network error")).when(mockDcerpcHandle).sendrecv(any(MsrpcLsarOpenPolicy2.class));

        // Act & Assert
        IOException thrown = assertThrows(IOException.class, () -> {
            new LsaPolicyHandle(mockDcerpcHandle, server, access);
        });

  private static final ImmutableLongArray EMPTY = new ImmutableLongArray(new long[0]);

  /** Returns the empty array. */
  public static ImmutableLongArray of() {
    return EMPTY;
  }

  /** Returns an immutable array containing a single value. */
  public static ImmutableLongArray of(long e0) {
    return new ImmutableLongArray(new long[] {e0});
  }

  private static final ImmutableIntArray EMPTY = new ImmutableIntArray(new int[0]);

  /** Returns the empty array. */
  public static ImmutableIntArray of() {
    return EMPTY;
  }

  /** Returns an immutable array containing a single value. */
  public static ImmutableIntArray of(int e0) {
    return new ImmutableIntArray(new int[] {e0});
  }

            try (Reader reader = IOUtils.getDecodingReader(new FileInputStream(suffixWordsFile), StandardCharsets.UTF_8)) {
                suffixWords = WordlistLoader.getWordSet(reader);
            } catch (final IOException e) {
                throw new IllegalArgumentException("Could not load " + suffixWordsFile.getAbsolutePath(), e);
            }
        } else {
            suffixWords = new CharArraySet(0, false);
        }
    }

    /**
     *
     */
    private static final long serialVersionUID = -4591854684249021395L;

    /**
     * Constructs a new SpnegoException with no detail message
     */
    public SpnegoException() {
    }

    /**
     * Constructs a new SpnegoException with the specified detail message and cause
     * @param message the detail message
     * @param cause the cause of this exception
     */

    /**
     *
     */
    private static final long serialVersionUID = -8825922797594232534L;

    /**
     * Constructs a new RequestTimeoutException with no detail message.
     */
    public RequestTimeoutException() {
    }

    /**
     * Constructs a new RequestTimeoutException with the specified detail message and cause.
     *
     * @param msg the detail message

            _specification = new HpSpecification();
        }
        return _specification;
    }

    protected void assertQueryPurpose() {
    }

    protected void assertAggregationPurpose() {
    }

    protected void assertSpecifyPurpose() {
    }

    public static class HpSpecification {
        protected List<String> columnList = new ArrayList<>();

    }

    public void setConfiguration(XmlNode configuration) {
        this.configuration = configuration != null ? new org.codehaus.plexus.util.xml.Xpp3Dom(configuration) : null;
    }

    public String identify() {
        StringBuilder sb = new StringBuilder(256);

        sb.append(executionId);
        sb.append(configuration.toString());

        return sb.toString();
    }

	// Only one rule is allowed on AWS S3
	if len(config.Rules) != 1 {
		return nil, errors.New("only one server-side encryption rule is allowed at a time")
	}

	for _, rule := range config.Rules {
		switch rule.DefaultEncryptionAction.Algorithm {
		case AES256:
			if rule.DefaultEncryptionAction.MasterKeyID != "" {
				return nil, errors.New("MasterKeyID is allowed with aws:kms only")
			}
		case AWSKms: