return builder.toString();
          }

        } else {
          return TO_BYTE_ARRAY_NEW_STRING.read(byteSource, cs);
        }
      }
    };

    abstract String read(ByteSource byteSource, Charset cs) throws IOException;
  }

  @Param({"UTF-8"})
  String charsetName;

  @Param ReadStrategy strategy;

  @Param({"10", "1024", "1048576"})
  int size;

     *
     * @version $Revision$ $Date$
     */
    public abstract static class StringFormatter {

        // -----------/
        // - Methods -/
        // -----------/

        /**
         * Method toString.
         *
         * @param location
         * @return String
         */
        public abstract String toString(InputLocation location);
    }

    @Override

    assertThat(e.getSource()).isEqualTo(Tester.class.getAnnotation(Require.class));
  }

  public void testBuildTesterRequirements_classClassConflict_inherited() {
    @Require(FOO)
    abstract class BaseTester {}
    @Require(absent = FOO)
    class Tester extends BaseTester {}

    ConflictingRequirementsException e =
        assertThrows(

                continue outerLoop;
              }
            }
            return true;
          }
        }
        return false;
      }
    };

    abstract boolean hashFloodingDetected(Object[] array);
  }

  @Benchmark
  public int detect(int reps) {
    int count = 0;
    for (int i = 0; i < reps; i++) {
      if (impl.hashFloodingDetected(tables[i & 0xFF])) {

import jcifs.internal.CommonServerMessageBlockResponse;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.smb.NtStatus;


/**
 * @author mbechler
 *
 */
public abstract class ServerMessageBlock2Response extends ServerMessageBlock2 implements CommonServerMessageBlockResponse {

    private boolean received;
    private boolean error;
    private Long expiration;

import jcifs.context.CIFSContextWrapper;
import jcifs.smb.NtlmPasswordAuthenticator;
import jcifs.smb.SmbFile;


/**
 * @author mbechler
 *
 */
@SuppressWarnings ( "javadoc" )
public abstract class BaseCIFSTest {

    private Map<String, String> properties;
    private CIFSContext context;
    private Random rand = new Random();
    private String name;

package cmd

import (
	"context"
	"time"

	"github.com/minio/minio/internal/dsync"
	"github.com/minio/minio/internal/grid"
	"github.com/minio/minio/internal/logger"
)

// To abstract a node over network.
type lockRESTServer struct {
	ll *localLocker
}

// RefreshHandler - refresh the current lock
func (l *lockRESTServer) RefreshHandler(args *dsync.LockArgs) (*dsync.LockResp, *grid.RemoteErr) {

 * non-null bound if possible, let's require a non-null bound here.
 *
 * TODO(cpovirk): Elaborate on "wouldn't behave as users might expect."
 */
public abstract class TypeParameter<T> extends TypeCapture<T> {

  final TypeVariable<?> typeVariable;

  protected TypeParameter() {
    Type type = capture();

 * your own escapers extend this class and implement the {@link #escape(int)} method.
 *
 * @author David Beaumont
 * @since 15.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class UnicodeEscaper extends Escaper {
  /** The amount of padding (chars) to use when growing the escape buffer. */
  private static final int DEST_PAD = 32;

  /** Constructor for use by subclasses. */

        return (T) invoke(method, null, args);
    }

    /**
     * <code>abstract</code>かどうかを返します。
     *
     * @param method
     *            メソッド。{@literal null}であってはいけません
     * @return <code>abstract</code>かどうか
     */
    public static boolean isAbstract(final Method method) {
        return Modifier.isAbstract(method.getModifiers());
    }

    /**
     * <code>public</code>かどうかを返します。
     *