assertEscaping(xmlEscaper, "\uFFFD", '\uFFFF');

    assertWithMessage("0xFFFE is forbidden and should be replaced during escaping")
        .that(xmlEscaper.escape("[\ufffe]"))
        .isEqualTo("[\uFFFD]");
    assertWithMessage("0xFFFF is forbidden and should be replaced during escaping")
        .that(xmlEscaper.escape("[\uffff]"))
        .isEqualTo("[\uFFFD]");
  }

   */
  SipHashFunction(int c, int d, long k0, long k1) {
    checkArgument(
        c > 0, "The number of SipRound iterations (c=%s) during Compression must be positive.", c);
    checkArgument(
        d > 0, "The number of SipRound iterations (d=%s) during Finalization must be positive.", d);
    this.c = c;
    this.d = d;
    this.k0 = k0;
    this.k1 = k1;
  }

  @Override
  public int bits() {

import org.bouncycastle.asn1.ASN1ObjectIdentifier;

import jcifs.CIFSException;

/**
 * Security Support Provider (SSP) context.
 *
 * This interface provides context for security support provider
 * operations during SMB authentication.
 *
 * @author mbechler
 */
public interface SSPContext {

    /**
     * Gets the signing key for the session.
     * @return the signing key for the session

    latch.awaitSuccessfully(LONG_DELAY_MS);
    assertInterrupted();
  }

  public void testAwaitTimeoutMultiInterruptExpired() {
    /*
     * We don't "need" to schedule a countDown() call at all here, but by doing
     * so, we come the closest we can to testing that the wait time is
     * appropriately decreased on each progressive await() call.
     */
    TimedLatch latch = new TimedLatch(/* countdownInMillis= */ LONG_DELAY_MS);

        // sure interpolation of the directories below uses translated paths.
        // Afterward, we'll double back and translate any paths that weren't covered during interpolation via the
        // code below...
        translatedPrefixes.add("build.directory");
        translatedPrefixes.add("build.outputDirectory");
        translatedPrefixes.add("build.testOutputDirectory");

}

// exponentialMovingAverage calculates the exponential moving average
func exponentialMovingAverage(beta, previousAvg, incrementAvg float64) float64 {
	return (1-beta)*incrementAvg + beta*previousAvg
}

// getExpMovingAvgBytesPerSecond returns the exponential moving average for the bucket/target in bytes
func (m *rateMeasurement) getExpMovingAvgBytesPerSecond() float64 {
	m.lock.Lock()

    vcs.useAbsoluteVcs(VersionedSettingsBranch.fromDslContext().vcsRootId())

    features {
        freeDiskSpace {
            // Lower the limit such that the agent work directories aren't cleaned during the AMI baking process
            requiredSpace = "100mb"
        }
    }

    params {
        param("defaultBranchName", "master")
        param("env.JAVA_HOME", javaHome(BuildToolBuildJvm, Os.LINUX))
    }

                               "' has a reference type ", DataTypeString(dt))
             : absl::OkStatus();
}

// Converts `ninputs` and `inputs` into `inputs_tensors` and `input_nodes` and
// does various checks while doing so. `input_nodes` will contain the same
// information as input_tensors just in a different structure to make
// following processing easier. TODO(iga): Simplify this nested structure.
absl::Status ProcessInputs(

                try {
                    disconnect(true);
                } catch (Exception e) {
                    log.debug("Error during emergency transport disconnect", e);
                }
            }
        } catch (Exception e) {
            log.error("Error during transport finalization", e);
        } finally {
            super.finalize();
        }
    }

    /**

     * @param filter additional resource name filter to apply
     * @param searchAttributes the file attributes to search for
     * @throws CIFSException if an error occurs during initialization
     */
    public DirFileEntryEnumIterator2(final SmbTreeHandleImpl th, final SmbResource parent, final String wildcard,
            final ResourceNameFilter filter, final int searchAttributes) throws CIFSException {