}
    }

  companion object {
    /**
     * The "mixed" subtype of "multipart" is intended for use when the body parts are independent
     * and need to be bundled in a particular order. Any "multipart" subtypes that an implementation
     * does not recognize must be treated as being of subtype "mixed".
     */
    @JvmField
    val MIXED = "multipart/mixed".toMediaType()

    /**

        .addPart("Hello, World!".toRequestBody(null))
        .build()
    assertThat(body.boundary).isEqualTo("123")
    assertThat(body.type).isEqualTo(MultipartBody.MIXED)
    assertThat(body.contentType().toString())
      .isEqualTo("multipart/mixed; boundary=123")
    assertThat(body.parts.size).isEqualTo(1)
    assertThat(body.contentLength()).isEqualTo(33L)
    val buffer = Buffer()
    body.writeTo(buffer)

		{[]string{"d1", "http://localhost/d2", "d3", "d4"}, fmt.Errorf("mixed style endpoints are not supported")},
		{[]string{"http://example.org/d1", "https://example.com/d1", "http://example.net/d1", "https://example.edut/d1"}, fmt.Errorf("mixed scheme is not supported")},

   *     lower-case characters
   */
  public abstract BaseEncoding lowerCase();

  /**
   * Returns an encoding that behaves equivalently to this encoding, but decodes letters without
   * regard to case.
   *
   * @throws IllegalStateException if the alphabet used by this encoding contains mixed upper- and
   *     lower-case characters

        assertNotNull(result);
        assertNotNull(result.getContent());
        assertFalse(result.getContent().isEmpty());
    }

    /**
     * Test that ZipExtractor handles mixed valid and invalid entries gracefully.
     * Should continue processing valid entries even when some fail.
     */
    public void test_ZipExtractor_mixedEntries_continuesProcessing() throws IOException {

        @ParameterizedTest
        @DisplayName("getBytes should handle various string inputs")
        @NullAndEmptySource
        @ValueSource(strings = { "Simple ASCII", "Special chars: !@#$%^&*()", "Unicode: ñöt ascii ℃", "Mixed: ASCII + 中文 + Русский",
                "Emojis: 🎉🌟💻", "Very long string with multiple words and various characters 1234567890" })
        void testGetBytesWithVariousInputs(String input) {
            // When

        Kerb5Authenticator b = new Kerb5Authenticator((Subject) null);

        // Both null subjects -> equal
        assertEquals(a, b);
        assertEquals(a.hashCode(), b.hashCode());

        // Mixed null/non-null -> not equal
        Kerb5Authenticator c = new Kerb5Authenticator(new Subject());
        assertNotEquals(a, c);

        // Same subject instance -> equal
        Subject shared = new Subject();

            assertEquals(1, SMBUtil.readInt2(buffer, 2));
        }

        @Test
        @DisplayName("Should handle mixed lock operations")
        void testMixedLockOperations() {
            // Simulate a complex scenario with mixed lock operations
            Smb2Lock[] locks = new Smb2Lock[] { new Smb2Lock(0L, 512L, Smb2Lock.SMB2_LOCKFLAG_EXCLUSIVE_LOCK),

        assertNotNull(results);
        // Should use Japanese analyzer and transliterator
    }

    @Test
    public void testConvertWithMixedLanguageText() throws IOException {
        // Test convert with mixed language text
        String text = "test テスト";
        String field = "content";

        List<String> results = converter.convert(text, field, "en", "ja");

        assertNotNull(results);
    }

        assertNotNull(str);
        assertTrue(str.contains("test"));
        assertTrue(str.contains("CLOSED"));
        assertTrue(str.contains("100.00%"));
    }

    @Test
    @DisplayName("Test mixed success and failure pattern")
    void testMixedPattern() throws Exception {
        // Success
        circuitBreaker.call(() -> "success");

        // Two failures (not enough to open)