} else {
      assertNull(multimap().asMap().get(key));
    }

    assertEquals(values.size(), multimap().get(key).size());
    assertEquals(values.size() > 0, multimap().containsKey(key));
    assertEquals(values.size() > 0, multimap().keySet().contains(key));
    assertEquals(values.size() > 0, multimap().keys().contains(key));
  }

  public Multimap<K, V> unfiltered() {
    return unfiltered;
  }

  @Override
  public Predicate<? super Entry<K, V>> entryPredicate() {
    return predicate;
  }

  @Override
  public int size() {
    return entries().size();
  }

  private boolean satisfies(@ParametricNullness K key, @ParametricNullness V value) {
    return predicate.apply(immutableEntry(key, value));
  }

    public Integer crudMode;

    /**
     * The search term that triggers the key match.
     */
    @Required
    @Size(max = 100)
    public String term;

    /**
     * The query to execute when the term matches.
     */
    @Required
    @CustomSize(maxKey = "form.admin.max.input.size")
    public String query;

    /**
     * The maximum number of results to return.
     */
    @Required

        Map map = project1.getArtifactMap();

        assertNotNull(map, "No artifacts");
        assertFalse(map.isEmpty(), "No Artifacts");
        assertTrue(map.size() == 2, "Set size should be 2, is " + map.size());

        assertTrue(map.containsKey("maven-test:t09-a"), "maven-test:t09-a is not in the project");
        assertTrue(map.containsKey("maven-test:t09-b"), "maven-test:t09-b is not in the project");

  @Throws(IOException::class)
  fun deflate(buffer: Buffer) {
    require(deflatedBytes.size == 0L)

    if (noContextTakeover) {
      deflater.reset()
    }

    deflaterSink.write(buffer, buffer.size)
    deflaterSink.flush()

    if (deflatedBytes.endsWith(EMPTY_DEFLATE_BLOCK)) {
      val newSize = deflatedBytes.size - LAST_OCTETS_COUNT_TO_REMOVE_AFTER_DEFLATION
      deflatedBytes.readAndWriteUnsafe().use { cursor ->

    public Integer crudMode;

    /**
     * The regular expression pattern to match request paths.
     */
    @Required
    @Size(max = 1000)
    public String regex;

    /**
     * The replacement pattern for matched paths.
     */
    @Size(max = 1000)
    public String replacement;

    /**
     * The processing type for path mapping.
     */
    @Required
    public String processType;

        assertEquals(5, itemList1.size());
        assertEquals(5, itemList1.getAllRecordCount());
        assertEquals(1, itemList1.getCurrentPageNumber());
        assertEquals(20, itemList1.getPageSize());

        final PagingList<SynonymItem> itemList2 = synonymFile.selectList(4, 2);
        assertEquals(1, itemList2.size());
        assertEquals(5, itemList2.getAllRecordCount());

        ToolchainsBuildingResult result = toolchainBuilder.build(request);
        assertNotNull(result.getEffectiveToolchains());
        assertNotNull(result.getProblems());
        assertEquals(0, result.getProblems().size());
    }

    @Test
    void testBuildRequestWithUserToolchains() throws Exception {
        Properties props = new Properties();
        props.put("key", "user_value");

		if err != nil {
			return nil, ObjectInfo{}, err
		}
		if size > len(b) {
			size = len(b)
		}

		// Calculate the object real size if encrypted
		if _, ok := crypto.IsEncrypted(gr.ObjInfo.UserDefined); ok {
			objSize, err = gr.ObjInfo.DecryptedSize()
			if err != nil {
				return nil, ObjectInfo{}, err
			}
		} else {
			objSize = gr.ObjInfo.Size
		}

    assertEquals(0, Invokable.from(constructor).getParameters().size());
  }

  public void testNestedInnerClassDefaultConstructor() {
    Constructor<?> constructor =
        InnerWithDefaultConstructor.NestedInner.class.getDeclaredConstructors()[0];
    assertEquals(0, Invokable.from(constructor).getParameters().size());
  }

  @SuppressWarnings("ClassCanBeStatic") // We want to test an inner class.