assertThat(newArray.length, is(2));
        assertThat(newArray[0], is("111"));
        assertThat(newArray[1], is("222"));

        final String[] emptyArray = new String[0];
        assertThat(ArrayUtil.addAll((Object[]) null, (Object[]) null), is(nullValue()));
        assertThat(ArrayUtil.addAll(null, emptyArray).length, is(0));
        assertThat(ArrayUtil.addAll(emptyArray, null), is(sameInstance(emptyArray)));

        assertThat(entry.getValue(), is(sameClass(Integer.class)));
        entry = it.next();
        assertThat(entry.getKey().getName(), is("T2"));
        assertThat(entry.getValue(), is(sameClass(Long.class)));
        entry = it.next();
        assertThat(entry.getKey().getName(), is("T1"));
        assertThat(entry.getValue(), is(sameClass(String.class)));
        entry = it.next();

            when (origin) {
                is ObjectOrigin.ReceiverOrigin -> replaceInReceiver(origin)
                is ObjectOrigin.FunctionOrigin -> replaceInFunction(origin)

                is ObjectOrigin.CustomConfigureAccessor -> origin.copy(receiver = replace(origin.receiver))
                is ObjectOrigin.FromLocalValue -> origin.copy(assigned = replace(origin.assigned))

            ErrorReason.UnusedConfigureLambda,
            is ErrorReason.UnresolvedFunctionCallArguments,
            is ErrorReason.UnresolvedFunctionCallReceiver,
            is ErrorReason.UnresolvedFunctionCallSignature,
            is ErrorReason.DuplicateLocalValue,
            is ErrorReason.ValReassignment,
            is ErrorReason.AmbiguousFunctions,
            is ErrorReason.AmbiguousImport,

        final Map<String, Object> map = BeanUtil.copyBeanToNewMap(hoge);
        assertThat(map.size(), is(4));
        assertThat(map.get("aaa"), is((Object) "1"));
        assertThat(map.get("search_bbb"), is((Object) "2"));
        assertThat(map.get("search_ccc.ddd"), is((Object) "3"));
        assertThat(map.get("employee.name"), is(nullValue()));
    }

    /**
     * @throws Exception
     */
    @Test

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Integer.class)));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Number.class)));

        assertThat(it.hasNext(), is(true));
        assertThat(it.next(), is(sameClass(Object.class)));

        assertThat(it.hasNext(), is(not(true)));
    }

    /**
     * @throws Exception

     * 1. If the previous mean is finite and the new value is non-finite then the new mean is that
     *    value (whether it is NaN or infinity).
     * 2. If the new value is finite and the previous mean is non-finite then the mean is unchanged
     *    (whether it is NaN or infinity).
     * 3. If both the previous mean and the new value are non-finite and...
     * 3a. ...either or both is NaN (so mean != value) then the new mean is NaN.

   * is also performed for calls to {@link Object#equals}, {@link Object#hashCode}, and {@link
   * Object#toString}.
   *
   * <p>If the target method call finishes before the limit is reached, the return value or
   * exception is propagated to the caller exactly as-is. If, on the other hand, the time limit is

                        else -> error("unexpected origin type")
                    }
                }
                is FunctionSemantics.Builder -> error("can't appear here")
            }
        }

        is ObjectOrigin.PropertyReference,
        is ObjectOrigin.FromLocalValue -> error("value origin needed")

            }
        }
        is FirExpression -> fir.resolvedType.asKtType()
        is FirNamedReference -> fir.getCorrespondingTypeIfPossible()?.asKtType()
        is FirStatement -> with(analysisSession) { builtinTypes.unit }
        is FirTypeRef, is FirImport, is FirPackageDirective, is FirLabel, is FirTypeParameterRef -> null

        // `listOf<_>(1)` where `expression` is `_`
        is FirPlaceholderProjection -> null