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(ArrayUtil.addAll(emptyArray, null), is(sameInstance(emptyArray)));

    final Ordering<T> ordering;
    final List<T> strictlyOrderedList;
    final T[] emptyArray;

    Scenario(Ordering<T> ordering, List<T> strictlyOrderedList, T[] emptyArray) {
      this.ordering = ordering;
      this.strictlyOrderedList = strictlyOrderedList;
      this.emptyArray = emptyArray;
    }

    void testCompareTo() {
      Helpers.testComparator(ordering, strictlyOrderedList);
    }

        Class<?> componentType = value.getClass().getComponentType();
        int length = Array.getLength(value);
        if (length == 0) {
            return visitor.emptyArray(componentType);
        }
        if (componentType.isPrimitive()) {
            return visitor.primitiveArray(value);
        }

        override fun isValid(): Boolean = ktFile.isValid

        override fun getParent(): VirtualFile {
            error("Not yet implemented")
        }

        override fun getChildren(): Array<VirtualFile> = emptyArray()

        override fun getInputStream(): InputStream {
            error("Not yet implemented")
        }

            return new JavaSerializedValueSnapshot(classLoaderHasher.getClassLoaderHash(value.getClass().getClassLoader()), serializedValue);
        }

        @Override
        public ValueSnapshot emptyArray(Class<?> arrayType) {
            return ArrayValueSnapshot.EMPTY;
        }

        @Override
        public ValueSnapshot array(ImmutableList<ValueSnapshot> elements, Class<?> arrayType) {

        private HashCode classLoaderHashOf(Object value) {
            return classLoaderHasher.getClassLoaderHash(value.getClass().getClassLoader());
        }

        @Override
        public Isolatable<?> emptyArray(Class<?> arrayType) {
            return IsolatedArray.empty(arrayType);
        }

        @Override
        public Isolatable<?> array(ImmutableList<Isolatable<?>> elements, Class<?> arrayType) {

            arrayOf("--${ConfigurationCacheProblemsOption.LONG_OPTION}=warn", "-D${ConfigurationCacheMaxProblemsOption.PROPERTY_NAME}=2")
        else
            emptyArray()


        build("classes", *extraParameters).apply {
            assertThat(
                output,
                allOf(

        }
        assertThat(builderResult, sameInstance(expectedBuilderResult))

        verify(delegate).invokeMethod(eq("nest"), any())
        verify(nestedDelegate).invokeMethod("nestedInvocation", emptyArray<Any>())
    }

    interface NonGroovyObject {
        val existingProperty: String
        fun withKeywordArguments(args: Map<String, Any?>): Any?
    }

    @Test

    private
    fun hasTooManyProblems(summary: Summary) =
        summary.nonSuppressedProblemCount > startParameter.maxProblems

    private
    fun log(msg: String, vararg args: Any = emptyArray()) {
        logger.warn(msg, *args)
    }

    private
    val logger = Logging.getLogger(ConfigurationCacheProblems::class.java)

    private

        throw KeyStoreException("unable to support unencodable private key")
      }

      val keyManager = newKeyManager(null, heldCertificate, *(intermediates ?: emptyArray()))
      val trustManager = newTrustManager(null, trustedCertificates, immutableInsecureHosts)
      return HandshakeCertificates(keyManager, trustManager)
    }
  }