* limitations under the License.
 */
package okhttp3.internal.idn

import okio.Buffer
import okio.ByteString.Companion.encodeUtf8

/**
 * An [RFC 3492] punycode decoder for converting ASCII to Unicode domain name labels. This is
 * intended for use in Internationalized Domain Names (IDNs).
 *
 * This class contains a Kotlin implementation of the pseudocode specified by RFC 3492. It includes

    )
    assertNull(
      Punycode.encode(a1000MaxCodePoint.repeat(2)),
    )
  }

  @Test fun invalidPunycode() {
    assertNull(Punycode.decode("xn--ls8h="))
  }

  private fun testEncodeDecode(
    unicode: String,
    punycode: String,
  ) {
    assertEquals(unicode, Punycode.decode(punycode))
    assertEquals(punycode, Punycode.encode(unicode))
  }

  private fun testDecodeOnly(

    "output": "x..xn--zca"
  },
  {
    "comment": "Invalid Punycode",
    "input": "xn--a",
    "output": null
  },
  {
    "input": "xn--a.xn--zca",
    "output": null
  },
  {
    "input": "xn--a.ß",
    "output": null
  },
  {
    "input": "xn--ls8h=",
    "output": null
  },
  {
    "comment": "Invalid Punycode (contains non-ASCII character)",
    "input": "xn--tešla",
    "output": null

      // OkHttp does not reject invalid Punycode.
      "xn--a",
      "xn--a.ß",
      "xn--a.xn--zca",
      "xn--a-yoc",
      // OkHttp doesn't reject U+FFFD encoded in Punycode.
      "xn--zn7c.com",
      // OkHttp doesn't reject a U+200D. https://www.rfc-editor.org/rfc/rfc5892.html#appendix-A.2
      "xn--1ug.example",

   * ```
   *
   * @param domain A canonicalized domain. An International Domain Name (IDN) should be punycode
   *     encoded.
   */
  fun getEffectiveTldPlusOne(domain: String): String? {
    // We use UTF-8 in the list so we need to convert to Unicode.
    val unicodeDomain = IDN.toUnicode(domain)
    val domainLabels = splitDomain(unicodeDomain)

    val rule = findMatchingRule(domainLabels)

pkg unicode, const Version = "17.0.0" #77266
pkg unicode, var Beria_Erfe *RangeTable #77266
pkg unicode, var Garay *RangeTable #77266
pkg unicode, var Gurung_Khema *RangeTable #77266
pkg unicode, var IDS_Unary_Operator *RangeTable #77266
pkg unicode, var ID_Compat_Math_Continue *RangeTable #77266
pkg unicode, var ID_Compat_Math_Start *RangeTable #77266
pkg unicode, var Kirat_Rai *RangeTable #77266
pkg unicode, var Modifier_Combining_Mark *RangeTable #77266

        // Test Unicode configuration is enabled by default
        assertTrue(cfg.isUseUnicode(), "Unicode should be enabled by default");
    }

    @Test
    public void testAsciiConfiguration() throws Exception {
        Configuration asciiCfg = new OffUnicodeConfig();
        assertFalse(asciiCfg.isUseUnicode(), "Unicode should be disabled in ASCII config");
    }

    @Test

        assertTrue(treeConnectCreate >= 0, "TreeConnectAndX.CreateDirectory batch limit should be non-negative");
    }

    /**
     * Test that batch limit respects Unicode settings
     */
    @Test
    @DisplayName("Batch limit configuration with Unicode enabled")
    public void testBatchLimitWithUnicodeEnabled() throws CIFSException {
        Properties props = new Properties();

            // Result should be either Unicode or ASCII fallback depending on default charset
            String expectedUnicode = String.valueOf(icon.getUnicodeChar());
            String expectedAscii = icon.getAsciiFallback();
            assertTrue(
                    result.equals(expectedUnicode) || result.equals(expectedAscii),
                    "Result should be either Unicode or ASCII fallback for " + icon + ", got: " + result);

  }

  /**
   * Asserts that a Unicode escaper does not escape the given character.
   *
   * @param escaper the non-null escaper to test
   * @param cp the Unicode code point to test
   */
  public static void assertUnescaped(UnicodeEscaper escaper, int cp) {
    Assert.assertNull(computeReplacement(escaper, cp));
  }

  /**