this.isArray = field.getType().isArray();
            }

            @Override
            void doInterpolate(Object target, InterpolateObjectAction ctx) throws IllegalAccessException {
                Object value = field.get(target);
                if (value != null) {
                    if (isArray) {
                        evaluateArray(value, ctx);
                    } else {

    /**
     *
     */
    @Test
    public void testIsArray() {
        assertFalse(ArrayUtil.isArray(null));
        assertFalse(ArrayUtil.isArray("hoge"));
        assertTrue(ArrayUtil.isArray(new Object[] {}));
        assertTrue(ArrayUtil.isArray(new Object[] { "" }));
        assertTrue(ArrayUtil.isArray(new Object[] { "aaa" }));
    }

    /**
     *
     */
    @Test

        String expression = param.getExpression();

        if (param.isEditable()) {
            boolean isArray = param.getType().endsWith("[]");
            boolean isCollection = false;
            boolean isMap = false;
            boolean isProperties = false;
            if (!isArray) {
                try {
                    // assuming Type is available in current ClassLoader

        private void traverseObjectWithParents(Class<?> cls, Object target) throws ModelInterpolationException {
            if (cls == null) {
                return;
            }

            if (cls.isArray()) {
                evaluateArray(target);
            } else if (isQualifiedForInterpolation(cls)) {
                Field[] fields = FIELDS_BY_CLASS.computeIfAbsent(cls, k -> cls.getDeclaredFields());

    assertTrue(TypeToken.of(Object[].class).isArray());
    assertTrue(TypeToken.of(Object[][].class).isArray());
    assertTrue(TypeToken.of(char[].class).isArray());
    assertTrue(TypeToken.of(char[][].class).isArray());
    assertTrue(TypeToken.of(byte[].class).isArray());
    assertTrue(TypeToken.of(short[].class).isArray());
    assertTrue(TypeToken.of(int[].class).isArray());
    assertTrue(TypeToken.of(long[].class).isArray());

        _ * method.ownerClass >> ownerClass
        _ * ownerClass.className >> className
        return method
    }

    def type(String name, boolean isArray = false) {
        TypeMetaData type = new TypeMetaData(name)
        if (isArray) {
            type.arrayDimensions = 1
        }
        return type
    }

     *            the object
     * @return {@literal true} if the object is an array; {@literal false} if the object is {@literal null}
     */
    public static boolean isArray(final Object object) {
        return object != null && object.getClass().isArray();
    }

    /**
     * Returns {@literal true} if the object is not an array. Returns {@literal true} if the object is {@literal null}.
     *
     * @param object

     * @return The string representation, never <code>null</code>.
     */
    private String toString(Object obj) {
        String str;
        if (obj != null && obj.getClass().isArray()) {
            int n = Array.getLength(obj);
            StringBuilder buf = new StringBuilder(256);
            buf.append('[');
            for (int i = 0; i < n; i++) {
                if (i > 0) {

      }
      Class<?> returnType = method.getReturnType();
      assertTrue(
          rootLocaleFormat("%s.%s() must return an array.", annotationClass, propertyName),
          returnType.isArray());
      assertWithMessage(
              rootLocaleFormat(
                  "%s.%s() must return an array of %s.",
                  annotationClass, propertyName, annotationClass.getDeclaringClass()))

        }

        final String className = serialClass.getName();

        // Allow primitive types and their wrappers
        if (serialClass.isPrimitive() || serialClass.isArray()) {
            return ObjectInputFilter.Status.ALLOWED;
        }

        // Check against allowed patterns
        for (String allowedPattern : DEFAULT_ALLOWED_PATTERNS) {