// internal Sync object, so this is safe since the shadowed locks are never
    // exposed or used.
    private final CycleDetectingReentrantReadLock readLock;
    private final CycleDetectingReentrantWriteLock writeLock;

    private final LockGraphNode lockGraphNode;

    private CycleDetectingReentrantReadWriteLock(LockGraphNode lockGraphNode, boolean fair) {
      super(fair);

     */
    public CurlException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new CurlException with the specified detail message.
     *
     * @param message the detail message (which is saved for later retrieval by the {@link #getMessage()} method).
     */
    public CurlException(final String message) {
        super(message);
    }

 */
public class AvTargetName extends AvPair {

    /**
     *
     */
    private static final Charset UTF16LE = StandardCharsets.UTF_16LE;

    /**
     * Constructs an AvTargetName from raw byte data
     *
     * @param raw the raw byte data for the target name AV pair
     */
    public AvTargetName(final byte[] raw) {
        super(AvPair.MsvAvTargetName, raw);
    }

    /**

  private static final class EnumSerializedForm<K extends Enum<K>, V> implements Serializable {
    final EnumMap<K, V> delegate;

    EnumSerializedForm(EnumMap<K, V> delegate) {
      this.delegate = delegate;
    }

    Object readResolve() {
      return new ImmutableEnumMap<>(delegate);
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

@ExtendWith(MockitoExtension.class)
class HMACT64Test {

    private static final byte[] TEST_KEY = "testkey".getBytes();
    private static final byte[] LONG_TEST_KEY = "thisisalongtestkeythatislongerthan64bytesandshouldbetruncated".getBytes();
    private static final byte[] SHORT_TEST_KEY = "short".getBytes();
    private static final byte[] TEST_DATA = "testdata".getBytes();
    private static final byte[] EMPTY_DATA = new byte[0];

    @Mock

public final class okhttp3/zstd/Zstd : okhttp3/CompressionInterceptor$DecompressionAlgorithm {
	public static final field INSTANCE Lokhttp3/zstd/Zstd;
	public fun decompress (Lokio/BufferedSource;)Lokio/Source;
	public fun getEncoding ()Ljava/lang/String;

     *
     * @param wildcard the wildcard pattern for matching file names (e.g., "*.txt")
     * @param attributes the DOS file attributes to match (e.g., ATTR_DIRECTORY)
     */
    public DosFileFilter(final String wildcard, final int attributes) {
        this.wildcard = wildcard;
        this.attributes = attributes;
    }

    /**
     * This returns true if the file's attributes contain any of the attributes

    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;

        // Read total allocation units.
        this.alloc = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

 */
public abstract class TypeParameter<T> extends TypeCapture<T> {

  final TypeVariable<?> typeVariable;

  protected TypeParameter() {
    Type type = capture();
    checkArgument(type instanceof TypeVariable, "%s should be a type variable.", type);
    this.typeVariable = (TypeVariable<?>) type;
  }

  @Override
  public final int hashCode() {
    return typeVariable.hashCode();
  }

  @Override

/**
 */
public class LifecycleTaskSegmentCalculatorStub extends DefaultLifecycleTaskSegmentCalculator {
    public static final String CLEAN = "clean";

    public static final String AGGR = "aggr";

    public static final String INSTALL = "install";

    public LifecycleTaskSegmentCalculatorStub() {
        super(null, null);
    }

    @Override