sb.append(groupId);
            sb.append(" -DartifactId=");
            sb.append(artifactId);
            sb.append(" -Dversion=");
            sb.append(version);

            // insert classifier only if it was used in the artifact
            if (classifier != null && !classifier.isEmpty()) {
                sb.append(" -Dclassifier=");
                sb.append(classifier);
            }

                20);
        assertEquals(3, itemList1.size());

        final KuromojiItem kuromojiItem1 = new KuromojiItem(0, "token4",
                "seg4", "reading4", "pos4");
        kuromojiFile.insert(kuromojiItem1);
        final PagingList<KuromojiItem> itemList2 = kuromojiFile.selectList(0,
                20);
        assertEquals(4, itemList2.size());
        assertEquals("token4", itemList2.get(3).getToken());

    //                                                                              ======
    public void insert(WebAuthentication entity) {
        doInsert(entity, null);
    }

    public void insert(WebAuthentication entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
        entity.asDocMeta().indexOption(opLambda);
        doInsert(entity, null);
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal

import assertk.assertThat
import assertk.assertions.isEqualTo
import kotlin.test.Test

class HostnamesTest {
  @Test
  fun canonicalizeInetAddressNotMapped() {
    val addressA = decodeIpv6("::1")!!

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isNotEqualTo
import java.util.Arrays
import javax.net.ssl.SSLPeerUnverifiedException
import kotlin.test.assertFailsWith
import okhttp3.CertificatePinner.Companion.pin

        return getCharMappingFile(dictId).map(file -> file.get(id).get());
    }

    /**
     * Stores a character mapping item in the specified dictionary.
     * <p>
     * This method performs either an insert operation (for new items with ID 0)
     * or an update operation (for existing items with non-zero ID) depending on
     * the item's current state.
     * </p>
     *

    /**
     * Default constructor.
     */
    public LdapChain() {
        // do nothing
    }

    @Override
    public void update(final User user) {
        ComponentUtil.getLdapManager().insert(user);
    }

    @Override
    public void delete(final User user) {
        ComponentUtil.getLdapManager().delete(user);
    }

    @Override

    public static Test suite() {
      TestSuite suite = new TestSuite();

      suite.addTest(
          NavigableSetTestSuiteBuilder.using(new ContiguousSetGenerator())
              .named("Range.asSet")
              .withFeatures(
                  CollectionSize.ANY,
                  KNOWN_ORDER,
                  ALLOWS_NULL_QUERIES,
                  NON_STANDARD_TOSTRING,

    Set<String> expected = Collections.singleton("a");
    assertEquals(expected, Optional.of("a").asSet());
  }

  public void testAsSet_absent() {
    assertTrue("Returned set should be empty", Optional.absent().asSet().isEmpty());
  }

  public void testAsSet_presentIsImmutable() {
    Set<String> presentAsSet = Optional.of("a").asSet();
    assertThrows(UnsupportedOperationException.class, () -> presentAsSet.add("b"));
  }

  id("okhttp.quality-conventions")
  id("okhttp.testing-conventions")
}

dependencies {
  api(libs.square.okio)
  api(projects.mockwebserver3)
  "friendsApi"(projects.okhttp)
  api(projects.okhttpTls)
  api(libs.assertk)
  api(libs.bouncycastle.bcprov)
  implementation(libs.bouncycastle.bcpkix)
  implementation(libs.bouncycastle.bctls)
  api(libs.conscrypt.openjdk)
  api(libs.openjsse)

  api(libs.junit.jupiter.engine)