// contain non-decimal characters.
    int length = end - start;
    if (length <= 0 || length > 3) {
      throw new NumberFormatException();
    }
    // Disallow leading zeroes, because no clear standard exists on
    // whether these should be interpreted as decimal or octal.
    if (length > 1 && ipString.charAt(start) == '0') {
      throw new NumberFormatException();
    }

    frame.writeInt(expectedStreamId and 0x7fffffff)
    frame.writeAll(headerBlock)

    // Check writer sends the same bytes.
    assertThat(sendHeaderFrames(false, sentHeaders)).isEqualTo(frame)

    // Reading the above frames should result in a concatenated headerBlock.
    reader.nextFrame(
      requireSettings = false,
      object : BaseTestHandler() {
        override fun headers(
          inFinished: Boolean,

  private ExceptionTypePolicy policy = ExceptionTypePolicy.NPE_OR_UOE;

  /*
   * Requiring desugaring for guava-*testlib* is likely safe, at least for the reflection-based
   * NullPointerTester. But if you are a user who is reading this because this change caused you
   * trouble, please let us know: https://github.com/google/guava/issues/new
   */
  @IgnoreJRERequirement
  public NullPointerTester() {
    try {
      /*

package jcifs.config;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Properties;

import jcifs.CIFSException;
import jcifs.Configuration;

/**
 * Configuration implementation reading the classic jcifs settings from properties
 *
 * @author mbechler
 */
public final class PropertyConfiguration extends BaseConfiguration implements Configuration {

import org.apache.logging.log4j.Logger;
import org.codelibs.core.lang.StringUtil;

/**
 * Utility class for text normalization and processing.
 *
 * This class provides methods to normalize text by reading characters from a provided Reader
 * and processing them according to specific rules. The main functionality is encapsulated
 * within the nested {@link TextNormalizeContext} class.
 *

    /*
     * We overload this because we want readAndXWireFormat to
     * read the parameter words and bytes. This is so when
     * commands are batched together we can recursivly call
     * readAndXWireFormat without reading the non-existent header.
     */

    @Override
    int decode(final byte[] buffer, int bufferIndex) {
        final int start = headerStart = bufferIndex;

 * including navigation controls and search/filter parameters.
 *
 * <p>Duplicate hosts allow administrators to define hostname patterns that should
 * be treated as equivalent during crawling, helping to avoid duplicate content
 * from the same logical site accessed via different hostnames.</p>
 */
public class DuplicateHostPager implements Serializable {

    private static final long serialVersionUID = 1L;

import org.codelibs.fess.dict.DictionaryFile;
import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.optional.OptionalEntity;

/**
 * Manages a dictionary file for stemmer overrides.
 * This class handles reading, parsing, and updating files that contain
 * stemmer override rules, where each rule maps an input word to an
 * output stem. The file format is expected to be `input => output`.
 *

        assertEquals("\\server\\share", normalizedPath);

        // To properly test UNC rejection, we would need to fix the normalization logic
        // to preserve the leading double backslash for UNC paths
    }

    @Test
    public void testInvalidUncPath() throws Exception {
        // Due to normalization removing duplicate backslashes, true UNC validation doesn't work

So, you can use it with:

{* ../../docs_src/path_params/tutorial004_py39.py hl[6] *}

/// tip

You might need the parameter to contain `/home/johndoe/myfile.txt`, with a leading slash (`/`).

In that case, the URL would be: `/files//home/johndoe/myfile.txt`, with a double slash (`//`) between `files` and `home`.

///

## Recap { #recap }