* @param access the desired access rights
     * @param rid the relative identifier of the alias
     * @param aliasHandle the alias handle to be populated
     */
    public MsrpcSamrOpenAlias(final SamrDomainHandle handle, final int access, final int rid, final SamrAliasHandle aliasHandle) {
        super(handle, access, rid, aliasHandle);
        this.ptype = 0;
        this.flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

 *
 * @author Nicholaus Shupe
 */
@NullUnmarked
class CollectionBenchmarkSampleData {
  private final boolean isUserTypeFast;
  private final SpecialRandom random;
  private final double hitRate;
  private final int size;

  private final Set<Element> valuesInSet;
  private final Element[] queries;

  CollectionBenchmarkSampleData(int size) {
    this(true, new SpecialRandom(), 1.0, size);
  }

	tw := tar.NewWriter(&buf)
	var files = []struct {
		Name, Body string
	}{
		{"readme.txt", "This archive contains some text files."},
		{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
		{"todo.txt", "Get animal handling license."},
	}
	for _, file := range files {
		hdr := &tar.Header{
			Name: file.Name,
			Mode: 0600,
			Size: int64(len(file.Body)),
		}
		if err := tw.WriteHeader(hdr); err != nil {

@NullUnmarked
final class TestUtil {
  static final String ERROR_ELEMENT_NOT_IN_GRAPH = "not an element of this graph";
  static final String ERROR_NODE_NOT_IN_GRAPH =
      "Should not be allowed to pass a node that is not an element of the graph.";
  static final String ERROR_ELEMENT_REMOVED = "used to generate this set";
  private static final String NODE_STRING = "Node";

     */
    private final byte[] fileId;

    /**
     * The type of handle (DURABLE_V1, DURABLE_V2, or PERSISTENT)
     */
    private final HandleType type;

    /**
     * The timeout in milliseconds for durable handles (not applicable for persistent handles)
     */
    private final long timeout;

    /**
     * The timestamp when this handle was created
     */
    private final long createTime;

    /**

 *
 * @author Nicholaus Shupe
 */
@NullUnmarked
public final class SpecialRandom extends Random {
  public static SpecialRandom valueOf(String s) {
    return (s.length() == 0) ? new SpecialRandom() : new SpecialRandom(Long.parseLong(s));
  }

  private final boolean hasSeed;
  private final long seed;

  public SpecialRandom() {
    this.hasSeed = false;
    this.seed = 0;
  }

     */
    public static BigInteger toBigInteger(final Object o) {
        return toBigInteger(o, null);
    }

    /**
     * Converts to {@link BigInteger}.
     *
     * @param o
     *            The object to convert
     * @param pattern
     *            The pattern string
     * @return The converted {@link BigInteger}
     */
    public static BigInteger toBigInteger(final Object o, final String pattern) {

     * @param filter
     */
    public DirFileEntryAdapterIterator(final SmbResource parent, final CloseableIterator<FileEntry> delegate, final ResourceFilter filter) {
        super(parent, delegate, filter);
    }

    /**
     * @param fe
     * @return
     * @throws MalformedURLException
     */
    @Override
    protected SmbResource adapt(final FileEntry e) throws MalformedURLException {

 * @author Louis Wasserman
 */
@GwtCompatible
class FilteredEntryMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMultimap<K, V> implements FilteredMultimap<K, V> {
  final Multimap<K, V> unfiltered;
  final Predicate<? super Entry<K, V>> predicate;

  FilteredEntryMultimap(Multimap<K, V> unfiltered, Predicate<? super Entry<K, V>> predicate) {
    this.unfiltered = checkNotNull(unfiltered);

 */
public class ChannelInfo {

    private final String channelId;
    private volatile SmbTransport transport;
    private final NetworkInterfaceInfo localInterface;
    private final NetworkInterfaceInfo remoteInterface;
    private volatile ChannelState state;
    private final long establishedTime;
    private volatile long lastActivityTime;

    // Performance metrics
    private final AtomicLong bytesSent;