assertThat(recordedRequest.handshakeServerNames).isEmpty()
  }

  /** No SNI for literal IPv4 addresses. */
  @Test
  fun ipv4() {
    val recordedRequest = requestToHostnameViaProxy("76.223.91.57")
    assertThat(recordedRequest.url.host).isEqualTo("76.223.91.57")
    assertThat(recordedRequest.handshakeServerNames).isEmpty()
  }

  @Test
  fun regularHostname() {

                    .setMessage("Unknown packaging: " + packaging)
                    .setLocation(model.getLocation("packaging")));
        } else if (!defaultPlugins.isEmpty()) {
            Model lifecycleModel = new Model();
            lifecycleModel.setBuild(new Build());
            lifecycleModel.getBuild().getPlugins().addAll(defaultPlugins);

        if (Objects.requireNonNull(groupId, "groupId cannot be null").isEmpty()) {
            throw new IllegalArgumentException("groupId cannot be empty");
        }
        if (Objects.requireNonNull(artifactId, "artifactId cannot be null").isEmpty()) {
            throw new IllegalArgumentException("artifactId cannot be empty");
        }

        if (model != null) {

        // Apply default behavior when no specific options are provided
        if (defaultWhenNoOptionsSpecified
                && options.infer().isEmpty()
                && options.model().isEmpty()
                && options.plugins().isEmpty()
                && options.model().isEmpty()) {
            return true;
        }

        return false;
    }

    /**
     * Gets a description of what this strategy does.

        if (artifact.getGroupId().isEmpty()
                || artifact.getArtifactId().isEmpty()
                || artifact.getBaseVersion().toString().isEmpty()) {
            artifact = session.createProducedArtifact(
                    artifact.getGroupId().isEmpty() ? project.getGroupId() : artifact.getGroupId(),
                    artifact.getArtifactId().isEmpty() ? project.getArtifactId() : artifact.getArtifactId(),

    assertFalse(c3.isClosed());

    closer.close();

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());
    assertTrue(c3.isClosed());

    assertTrue(suppressor.suppressions.isEmpty());
  }

  public void testExceptionThrown_fromTryBlock() throws IOException {
    Closer closer = new Closer(suppressor);

    TestCloseable c1 = closer.register(TestCloseable.normal());

     * @param inData
     *            The data to encode
     * @return The encoded data, or an empty string if the input is null or empty
     */
    public static String encode(final byte[] inData) {
        if (ArrayUtil.isEmpty(inData)) {
            return "";
        }
        return Base64.getEncoder().encodeToString(inData);
    }

    /**
     * Decodes data encoded in Base64.
     * <p>

            throws MetadataGraphTransformationException {
        try {
            if (dirtyGraph == null || dirtyGraph.isEmpty()) {
                return null;
            }

            MetadataGraph cleanGraph = conflictResolver.resolveConflicts(dirtyGraph, scope);

            if (cleanGraph == null || cleanGraph.isEmpty()) {
                return null;
            }

            ClasspathContainer cpc = new ClasspathContainer(scope);

        descriptor.setVersion("0.1");
        List<String> errors = new ArrayList<>();
        mavenPluginValidator.validate(plugin, descriptor, errors);
        assertTrue(
                errors.isEmpty(), "Expected collection to be empty but had " + errors.size() + " elements: " + errors);
    }

    @Test
    void testInvalidGroupId() {
        Artifact plugin = new DefaultArtifact(

        assertEquals(boost, elevateWord.getBoost(), 0.001f);
        assertTrue(elevateWord.getReadings().isEmpty());
        assertTrue(elevateWord.getFields().isEmpty());
        assertTrue(elevateWord.getTags().isEmpty());
        assertTrue(elevateWord.getRoles().isEmpty());
    }

    @Test
    public void testConstructorWithNullWord() {
        // Test constructor with null word