assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);

        VersionRange version = VersionRange.createFromVersion("1.0");
        assertSame(version, VersionRange.createFromVersion("1.0")); // same instance from version cache
        restrictions = version.getRestrictions();
        assertEquals(0, restrictions.size(), CHECK_NUM_RESTRICTIONS);

        assertFalse(

    color:#353833;
}
pre {
    font-size:1.3em;
}
h1 {
    font-size:1.8em;
}
h2 {
    font-size:1.5em;
}
h3 {
    font-size:1.4em;
}
h4 {
    font-size:1.3em;
}
h5 {
    font-size:1.2em;
}
h6 {
    font-size:1.1em;
}
ul {
    list-style-type:disc;
}
code, tt {
    font-size:1.2em;
}
dt code {
    font-size:1.2em;
}
table tr td dt code {

        assertEquals(0, crawlingConfigHelper.getExcludedUrlList("123").size());
        systemProperties.setProperty(Constants.FAILURE_COUNT_THRESHOLD_PROPERTY, "0");
        assertEquals(0, crawlingConfigHelper.getExcludedUrlList("123").size());
        errorCount.set(5);
        assertEquals(5, crawlingConfigHelper.getExcludedUrlList("123").size());

  @Param({"10", "100", "1000", "10000"})
  int size;

  @Param Impl impl;

  private static final Object[][] tables = new Object[TEST_CASES][];

  @BeforeExperiment
  public void setUp() {
    int tableSize = ImmutableSet.chooseTableSize(size);
    int mask = tableSize - 1;
    for (int i = 0; i < TEST_CASES; i++) {
      tables[i] = new Object[tableSize];
      for (int j = 0; j < size; j++) {
        Object o = new Object();

    @Test
    fun `promotion project has expected build types for master branch`() {
        val model = setupModelFor("master")

        assertEquals("Promotion", model.name)
        assertEquals(10, model.buildTypes.size)
        assertEquals(

        d1.setGroupId("myGroupId");
        assertNotNull(dm.getDependencies());
        assertEquals(0, dm.getDependencies().size());
        dm.addDependency(d1);
        assertNotNull(dm.getDependencies());
        assertEquals(1, dm.getDependencies().size());
        dm.getDependencies().get(0).setArtifactId("myArtifactId");
        assertEquals("myArtifactId", dm.getDependencies().get(0).getArtifactId());

import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.Size;

/**
 * @author codelibs
 * @author jflute
 */
public class CreateForm {

    @ValidateTypeFailure
    public Integer crudMode;

    @Required
    @Size(max = 100)
    public String term;

    @Required
    @CustomSize(maxKey = "form.admin.max.input.size")
    public String query;

    @Required
    @Min(value = 0)

                            systemHelper.getCurrentTimeAsLong() - execTime, MemoryUtil.byteCountToDisplaySize(docList.getContentSize()),
                            MemoryUtil.getMemoryUsageLog());
                } else {
                    logger.info("Sent {}  docs (Doc:{send {}ms}, {})", docList.size(), systemHelper.getCurrentTimeAsLong() - execTime,

      newDelegate.addAll(delegate);
      this.table = newDelegate;
      return;
    }
    int size = this.size;
    if (size < requireEntries().length) {
      resizeEntries(size);
    }
    int minimumTableSize = CompactHashing.tableSize(size);
    int mask = hashTableMask();
    if (minimumTableSize < mask) { // smaller table size will always be less than current mask

  std::vector<int64_t> input_ids(inputs.size());
  std::vector<tensorflow::DataType> input_dtypes(inputs.size());
  for (int i = 0; i < inputs.size(); i++) {
    input_ids[i] = ToId(inputs[i]);
    input_dtypes[i] = inputs[i]->DataType();
  }
  std::vector<TapeTensor> tape_tensors;
  tape_tensors.reserve(outputs.size());
  for (auto t : outputs) {
    tape_tensors.push_back(TapeTensor(t));
  }