private static final long serialVersionUID = 1L;

    private long totalHits;

    private long tookInMillis;

    public void setTotalHits(final long totalHits) {
        this.totalHits = totalHits;
    }

    public long getTotalHits() {
        return totalHits;
    }

    public void setTookInMillis(final long tookInMillis) {
        this.tookInMillis = tookInMillis;

    this.entriesByLowerBound = entriesByLowerBound;
  }

  private static final class RangeMapEntry<K extends Comparable, V>
      extends AbstractMapEntry<Range<K>, V> {
    private final Range<K> range;
    private final V value;

    RangeMapEntry(Cut<K> lowerBound, Cut<K> upperBound, V value) {
      this(Range.create(lowerBound, upperBound), value);
    }

                .readAttributes();
        assertThat(attributes.permissions())
            .containsExactly(OWNER_READ, OWNER_WRITE, OWNER_EXECUTE);
      }
    } finally {
      assertThat(temp.delete()).isTrue();
    }
  }

  public void testBogusSystemPropertiesUsername() {
    if (isAndroid()) {
      /*

import jcifs.SmbResource;


abstract class FileEntryAdapterIterator implements CloseableIterator<SmbResource> {

    private static final Logger log = LoggerFactory.getLogger(FileEntryAdapterIterator.class);

    private final CloseableIterator<FileEntry> delegate;
    private final ResourceFilter filter;
    private final SmbResource parent;
    private SmbResource next;


    /**
     * @param parent
     * @param delegate

     * @param arguments
     *            型引数を表す{@link ParameterizedClassDesc}の配列
     */
    public ParameterizedClassDescImpl(final Class<?> rawClass, final ParameterizedClassDesc[] arguments) {
        assertArgumentNotNull("rawClass", rawClass);

        this.rawClass = rawClass;
        this.arguments = arguments;
    }

    @Override
    public boolean isParameterizedClass() {
        return arguments != null;

 */
public class QuantilesAlgorithmTest extends TestCase {

  private static final Random RNG = new Random(82674067L);
  private static final int DATASET_SIZE = 1000;
  private static final double ALLOWED_ERROR = 1.0e-10;
  private static final QuantilesAlgorithm REFERENCE_ALGORITHM = QuantilesAlgorithm.SORTING;
  private static final Set<QuantilesAlgorithm> NON_REFERENCE_ALGORITHMS =
      Sets.difference(

            }
        }
    }

    protected void addSubLink(final Queue<String> queue, final String html, final HttpUriRequest request) {
        String schema = request.getURI().getScheme();
        String host = request.getURI().getHost();
        String originUri = request.getURI().toString();

        String h = html;
        final String tag = "<a href=\"";
        int linkPos;

import spock.lang.Specification
import gradlebuild.docs.dsl.source.model.TypeMetaData

class TypeNameResolverTest extends Specification {
    final ClassMetaDataRepository<ClassMetaData> metaDataRepository = Mock()
    final ClassMetaData classMetaData = Mock()
    final TypeNameResolver typeNameResolver = new TypeNameResolver(metaDataRepository)

    def resolvesFullyQualifiedClassName() {
        when:

    private void assertFoundDeadJavadocLinks(File file, String... paths) {
        assertFoundDeadLinks(paths.collect { DeadLink.forJavadoc(file, it) })
    }

    private static final class DeadLink {
        private final File file
        private final String message

        DeadLink(File file, String message) {
            this.file = file
            this.message = message
        }

    /**
     * インスタンスを構築します。
     *
     * @param pattern
     *            日付のパターン
     */
    public DateConverter(final String pattern) {
        assertArgumentNotEmpty("pattern", pattern);
        this.pattern = pattern;
    }

    @Override
    public Object getAsObject(final String value) {
        if (isEmpty(value)) {
            return null;
        }
        return DateConversionUtil.toDate(value, pattern);