reflectValue = reflect.ValueOf(&user)
	)

	// test valuer
	values := map[string]interface{}{
		"name":       user.Name,
		"id":         user.ID,
		"created_at": user.CreatedAt,
		"updated_at": user.UpdatedAt,
		"deleted_at": user.DeletedAt,
		"age":        user.Age,
		"birthday":   user.Birthday,
		"active":     true,
	}
	checkField(t, userSchema, reflectValue, values)

	var f *bool
	// test setter

						field.ReflectValueOf(ctx, value).Set(reflectV)
					} else if reflectV.Kind() == reflect.Ptr {
						return field.Set(ctx, value, reflectV.Elem().Interface())
					} else {
						if valuer, ok := v.(driver.Valuer); ok {
							v, _ = valuer.Value()
						}

						err = field.ReflectValueOf(ctx, value).Addr().Interface().(sql.Scanner).Scan(v)
					}
					return
				}
			} else {

        assertTrue(viewHelper.isUseSession());

        viewHelper.addInitFacetParam("key1", "value1");
        assertEquals("key1", viewHelper.getInitFacetParamMap().get("value1"));

        viewHelper.addInitGeoParam("key2", "value2");
        assertEquals("key2", viewHelper.getInitGeoParamMap().get("value2"));

        FacetQueryView facetQueryView = new FacetQueryView();
        facetQueryView.setTitle("test");

		{"error not equal", errors.New("1"), errors.New("2"), false},
		{"driver.Valuer equal", ModifyAt{Time: now, Valid: true}, ModifyAt{Time: now, Valid: true}, true},
		{"driver.Valuer not equal", ModifyAt{Time: now, Valid: true}, ModifyAt{Time: now.Add(time.Second), Valid: true}, false},
		{"driver.Valuer equal (ptr to nil ptr)", (*ModifyAt)(nil), &ModifyAt{}, false},
	}
	for _, test := range assertEqualTests {

      Key key1 = new Key(1);
      String value1 = key1.toString();
      Key key2 = new Key(2);
      String value2 = key2.toString();
      assertSame(value1, cache.getUnchecked(key1));
      assertSame(value2, cache.getUnchecked(key2));
      assertEquals(ImmutableSet.of(key1, key2), cache.asMap().keySet());
      assertThat(cache.asMap().values()).containsExactly(value1, value2);
      assertEquals(

	switch value := dbValue.(type) {
	case []byte:
		*es = EncryptedString(bytes.TrimPrefix(value, []byte("hello")))
	case string:
		*es = EncryptedString(strings.TrimPrefix(value, "hello"))
	default:
		return fmt.Errorf("unsupported data %#v", dbValue)
	}
	return nil
}

          DeferredCloser closer,
          @ParametricNullness V1 value1,
          @ParametricNullness V2 value2,
          @ParametricNullness V3 value3,
          @ParametricNullness V4 value4,
          @ParametricNullness V5 value5)
          throws Exception;
    }

    /**
     * A function that returns a {@link ClosingFuture} when applied to the values of the five

        queryContext = new QueryContext("test", false);
        QueryBuilder initialQuery = QueryBuilders.termQuery("field1", "value1");
        queryContext.setQueryBuilder(initialQuery);

        queryContext.addQuery(boolQuery -> {
            boolQuery.must(QueryBuilders.termQuery("field2", "value2"));
        });

        QueryBuilder result = queryContext.getQueryBuilder();
        assertNotNull(result);

	for idx, field := range fields {
		if field != nil {
			values[idx] = field.NewValuePool.Get()
		} else if len(fields) == 1 {
			if reflectValue.CanAddr() {
				values[idx] = reflectValue.Addr().Interface()
			} else {
				values[idx] = reflectValue.Interface()
			}
		}
	}

	db.RowsAffected++
	db.AddError(rows.Scan(values...))

        value = " value1 , value2 , value3 ";
        result = KuromojiCSVUtil.parse(value);
        assertEquals(3, result.length);
        assertEquals(" value1 ", result[0]);
        assertEquals(" value2 ", result[1]);
        assertEquals(" value3 ", result[2]);

        // Spaces in quoted values
        value = "\" spaced value \",\"  another  \"";
        result = KuromojiCSVUtil.parse(value);