}
  }

  public void testPut_populated() {
    for (LoadingCache<Object, Object> cache : caches()) {
      // don't let the entries get GCed
      List<Entry<Object, Object>> warmed = warmUp(cache);
      for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) {
        Entry<Object, Object> entry = warmed.get(i - WARMUP_MIN);
        Object newValue = new Object();

        hoge.setB(true);
        hoge.setC(3);
        final Map<String, Object> map = newHashMap();
        BeanUtil.copyBeanToMap(hoge, map);
        assertThat(map, is(notNullValue()));
        assertThat(map.get("a"), is((Object) "A"));
        assertThat(map.get("b"), is((Object) true));
        assertThat(map.get("c"), is((Object) 3));
    }

    /**
     * @throws Exception
     */
    @Test

Modern best practices when developing a Gradle plugin are to use lazy types (ConfigurableFileCollection, Provider API, domain object containers) when defining configurable parts of a plugin (tasks, extensions, domain objects).  The Provider API provides a consistent way to set conventions, wire related configuration together (extension <- domain object <- task) and avoid evaluation ordering problems.

          "x-minio-internal-transitioned-object": "ZDIvN2MvZDI3Y2MwYWMtZGIzNC00ZGM1LWIxNDUtYjI5MGNjZjU1MjY5"
        },
```

    for (LoadingCache<Object, Object> cache : caches()) {
      Set<Entry<Object, Object>> entries = cache.asMap().entrySet();
      assertThrows(
          NullPointerException.class, () -> entries.toArray((Entry<Object, Object>[]) null));
      checkEmpty(cache);
    }
  }

  public void testEntrySet_addNotSupported() {
    for (LoadingCache<Object, Object> cache : caches()) {
      assertThrows(

    for (LoadingCache<Object, Object> cache : caches()) {
      Set<Entry<Object, Object>> entries = cache.asMap().entrySet();
      assertThrows(
          NullPointerException.class, () -> entries.toArray((Entry<Object, Object>[]) null));
      checkEmpty(cache);
    }
  }

  public void testEntrySet_addNotSupported() {
    for (LoadingCache<Object, Object> cache : caches()) {
      assertThrows(

			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{
				Exprs: []clause.Expression{clause.Or(clause.Neq{Column: "name", Value: "jinzhu"}), clause.Eq{Column: clause.PrimaryColumn, Value: "1"}, clause.Gt{Column: "age", Value: 18}},
			}},
			"SELECT * FROM `users` WHERE `users`.`id` = ? OR `name` <> ? AND `age` > ?",
			[]interface{}{"1", "jinzhu", 18},
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Where{

  public void testAsMap() {
    CacheBuilder<Object, Object> builder = createCacheBuilder();
    LocalLoadingCache<Object, Object> cache = makeCache(builder, identityLoader());
    assertThat(cache.stats()).isEqualTo(EMPTY_STATS);

    Object one = new Object();
    Object two = new Object();
    Object three = new Object();

    ConcurrentMap<Object, Object> map = cache.asMap();
    assertThat(map.put(one, two)).isNull();

            "components": {
                "schemas": {
                    "UserOut": {
                        "title": "UserOut",
                        "required": ["username", "email"],
                        "type": "object",
                        "properties": {
                            "username": {"title": "Username", "type": "string"},
                            "email": {
                                "title": "Email",

    protected void mergeModel(Model target, Model source, boolean sourceDominant, Map<Object, Object> context) {
        context.put(ARTIFACT_ID, target.getArtifactId());

        super.mergeModel(target, source, sourceDominant, context);
    }

    @Override
    protected void mergeModel_Name(Model target, Model source, boolean sourceDominant, Map<Object, Object> context) {
        String src = source.getName();
        if (src != null) {