return CollectCollectors.toImmutableList();
  }

  /**
   * Returns the empty immutable list. This list behaves and performs comparably to {@link
   * Collections#emptyList}, and is preferable mainly for consistency and maintainability of your
   * code.
   *
   * <p><b>Performance note:</b> the instance returned is a singleton.
   */

                    queryList.add(termQuery);
                    return queryList;
                }
            }
        }
        return Collections.emptyList();
    }

    /**
     * Creates a bulk line for OpenSearch indexing from the given parameters.
     *
     * @param index the name of the OpenSearch index

        }
      }
    }

    @Throws(IOException::class)
    private fun readCertificateList(source: BufferedSource): List<Certificate> {
      val length = readInt(source)
      if (length == -1) return emptyList() // OkHttp v1.2 used -1 to indicate null.

      try {
        val certificateFactory = CertificateFactory.getInstance("X.509")
        val result = ArrayList<Certificate>(length)
        for (i in 0 until length) {

                        .map(o -> new Artifact((String) o.get("name"), (String) o.get("version"), (String) o.get("url")))
                        .collect(Collectors.toList());
            }
            return Collections.emptyList();
        } catch (final Exception e) {
            throw new PluginException("Failed to access " + url, e);
        }
    }

    /**

    return list;
  }

  /**
   * Creates an empty {@code CopyOnWriteArrayList} instance.
   *
   * <p><b>Note:</b> if you need an immutable empty {@link List}, use {@link Collections#emptyList}
   * instead.
   *
   * @return a new, empty {@code CopyOnWriteArrayList}
   * @since 12.0
   */
  @J2ktIncompatible
  @GwtIncompatible // CopyOnWriteArrayList
  @InlineMe(

        if (list == null) {
            final String value = getSystemProperty(Constants.DEFAULT_SORT_VALUE_PROPERTY);
            if (StringUtil.isBlank(value)) {
                list = Collections.emptyList();
            } else {
                final Set<String> keySet = new HashSet<>();
                list = split(value, "\n").get(stream -> stream.filter(StringUtil::isNotBlank).map(s -> {

                    if (attrValue != null) {
                        attrList.add(attrValue);
                    }
                }
                return attrList;
            }
            return Collections.emptyList();
        } catch (final NamingException e) {
            throw new LdapOperationException("Failed to parse attribute values for " + name, e);
        }
    }

    /**

   * | `http://host/?a=apple&b`          | `["apple"]`                 | `[null]`                    |
   */
  fun queryParameterValues(name: String): List<String?> {
    if (queryNamesAndValues == null) return emptyList()
    val result = ArrayList<String?>(4)
    for (i in 0 until queryNamesAndValues.size step 2) {
      if (name == queryNamesAndValues[i]) {
        result.add(queryNamesAndValues[i + 1])
      }
    }

        url: HttpUrl,
        cookies: List<Cookie>,
      ) {}

      override fun loadForRequest(url: HttpUrl): List<Cookie> {
        callReference.get().cancel()
        return emptyList()
      }
    }
    client =
      client
        .newBuilder()
        .cookieJar(DisconnectingCookieJar())
        .build()
    val call = client.newCall(newRequest("/"))

    EXPECT_EQ(0,
              memcmp(tensor_data[i], TF_TensorData(v), TF_TensorByteSize(v)));
    TF_DeleteTensor(v);
  }
}

TEST_F(CApiAttributesTest, EmptyList) {
  auto desc = init("list(int)");
  TF_SetAttrIntList(desc, "v", nullptr, 0);
  auto oper = TF_FinishOperation(desc, s_);
  ASSERT_EQ(TF_OK, TF_GetCode(s_)) << TF_Message(s_);