import java.io.Serializable;
import java.util.Arrays;

import jcifs.internal.smb2.lease.Smb2LeaseKey;

/**
 * Information about a durable or persistent SMB handle.
 * This class holds all the necessary information to reconnect
 * a handle after network failures or server reboots.
 */
public class HandleInfo implements Serializable {

    private static final long serialVersionUID = 1L;

    /**

      pull-requests: read
    # Set job outputs to values from filter step
    outputs:
      src: ${{ steps.filter.outputs.src }}
    steps:
    - uses: actions/checkout@v6
    # For pull requests it's not necessary to checkout the code but for the main branch it is
    - uses: dorny/paths-filter@v4
      id: filter
      with:
        filters: |
          src:
            - .github/workflows/test.yml
            - docs_src/**

import java.io.OutputStream;
import java.nio.file.Files;
import java.util.HashSet;
import java.util.Set;

/**
 * A custom archive task that assembles a tar archive that preserves symbolic links.
 *
 * This task is necessary because the built-in task {@link org.gradle.api.tasks.bundling.Tar} does not preserve symbolic links.
 */
public class SymbolicLinkPreservingTar extends Tar {

    @Override
    protected CopyAction createCopyAction() {

import java.util.StringTokenizer;

import jcifs.smb1.netbios.Lmhosts;
import jcifs.smb1.netbios.NbtAddress;
import jcifs.smb1.util.LogStream;

/**
 * <p>Under normal conditions it is not necessary to use
 * this class to use jCIFS properly. Name resolusion is
 * handled internally to the <code>jcifs.smb1.smb1</code> package.
 * <p>
 * This class is a wrapper for both {@link jcifs.smb1.netbios.NbtAddress}

// The Header.Size determines how many bytes can be written for the next file.
// If the current file is not fully written, then this returns an error.
// This implicitly flushes any padding necessary before writing the header.
func (tw *Writer) WriteHeader(hdr *Header) error {
	if err := tw.Flush(); err != nil {
		return err
	}
	tw.hdr = *hdr // Shallow copy of Header

                model,
                performanceTests,
            )
        performanceTests.forEach { performanceTestTrigger ->
            // The space removal is necessary - otherwise it doesn't show
            val artifactDirName = performanceTestTrigger.name.replace(" ", "")
            performancePartialTrigger.dependencies {
                artifacts(performanceTestTrigger) {

   * to perform more efficiently.
   *
   * <p>An escaper is expected to be able to deal with any {@code char} value, so this method should
   * not throw any exceptions.
   *
   * @param c the character to escape if necessary
   * @return the replacement characters, or {@code null} if no escaping was needed
   */
  protected abstract char @Nullable [] escape(char c);

  /**

# it. TFCI Mac VMs only have one Python version installed so we need to install
# the other versions manually.
if [[ "${TFCI_MACOS_PYENV_INSTALL_ENABLE}" == 1 ]]; then
  # Install the necessary Python, unless it's already present
  pyenv install -s "$TFCI_PYTHON_VERSION"
  pyenv local "$TFCI_PYTHON_VERSION"
  # Do a sanity check to make sure that we using the correct Python version
  python --version
fi

    }

  val isSourceComplete: Boolean
    get() = withLock { source.finished && source.readBuffer.exhausted() }

  /**
   * Removes and returns the stream's received response headers, blocking if necessary until headers
   * have been received. If the returned list contains multiple blocks of headers the blocks will be
   * delimited by 'null'.
   *

    // Optimization - use signed division if dividend < 2^63
    if (dividend >= 0) {
      return dividend / divisor;
    }

    /*
     * Otherwise, approximate the quotient, check, and correct if necessary. Our approximation is
     * guaranteed to be either exact or one less than the correct value. This follows from fact that
     * floor(floor(x)/i) == floor(x/i) for any real x and integer i != 0. The proof is not quite