new XlaHostSendDeviceContext(stream.get(), &gpu_dst, shape, done_event);
  TF_ASSERT_OK(device_context->CopyCPUTensorToDeviceSync(
      &origin_cpu_tensor, device_.get(), &device_tensor));

  // Copy the GPU tensor back to CPU to check that copy worked.
  TF_ASSERT_OK(stream->Memcpy(dest_cpu_tensor.data(), gpu_dst, gpu_dst.size()));
  TF_ASSERT_OK(stream->BlockHostUntilDone());

import static com.tngtech.archunit.lang.conditions.ArchPredicates.are;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.partitioningBy;
import static java.util.stream.Collectors.toSet;
import static org.gradle.architecture.test.ArchUnitFixture.freeze;
import static org.gradle.architecture.test.ArchUnitFixture.gradlePublicApi;

    public int getJavaMajorVersion() {
        return javaMajorVersion;
    }

    @Override
    public Stream<File> getClasspath() {
        return StreamSupport.stream(classpath.spliterator(), false);
    }

    @Override
    public Stream<File> getModulePath() {
        return StreamSupport.stream(modulePath.spliterator(), false);
    }

    @Override
    public List<String> getJvmArgs() {
        return jvmArgs;

 * correlated by stream ID.
 *
 *  * [onRequest]
 *  * [onHeaders] (unless canceled)
 *  * [onData] (optional sequence of data frames)
 *
 * As a stream ID is scoped to a single HTTP/2 connection, implementations which target multiple
 * connections should expect repetition of stream IDs.
 *
 * Return true to request cancellation of a pushed stream.  Note that this does not guarantee

        return stream(getPermissions()).get(stream -> stream.filter(s -> s.startsWith(fessConfig.getRoleSearchRolePrefix()))
                .map(s -> s.substring(1)).toArray(n -> new String[n]));
    }

    @Override
    public String[] getGroupNames() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

	}

	streamChan := make(chan httpstream.Stream)
	replySentChan := make(chan (<-chan struct{}))
	spdyConn, err := NewServerConnection(conn, func(stream httpstream.Stream, replySent <-chan struct{}) error {
		streamChan <- stream
		replySentChan <- replySent
		return nil
	})
	if err != nil {
		t.Errorf("server: error creating spdy connection: %v", err)
		return
	}

	stream := <-streamChan
	replySent := <-replySentChan

 * Provides a way to encode structured data to a backing byte stream. Implementations may buffer outgoing encoded bytes prior
 * to writing to the backing byte stream.
 */
public interface Encoder {
    /**
     * Returns an {@link OutputStream} that can be used to write raw bytes to the stream.
     */
    OutputStream getOutputStream();

    /**
     * Writes a raw byte value to the stream.
     */

    protected void writeThrowable(Throwable t, PrintStream stream) {
        if (t == null) {
            return;
        }
        MessageBuilder builder = builder().failure(t.getClass().getName());
        if (t.getMessage() != null) {
            builder.a(": ").failure(t.getMessage());
        }
        stream.println(builder);

        printStackTrace(t, stream, "");
    }

 * limitations under the License.
 */

package org.gradle.internal.enterprise.test.impl;

import org.gradle.internal.enterprise.test.InputFileProperty;

import java.io.File;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

class DefaultInputFileProperty implements InputFileProperty {

    private final String propertyName;
    private final Iterable<File> files;

        final String[] geoFields = fessConfig.getQueryGeoFieldsAsArray();
        final Map<String, List<QueryBuilder>> geoMap = new HashMap<>();

        StreamUtil.stream(request.getParameterMap())
                .of(stream -> stream.filter(e -> e.getKey().startsWith("geo.") && e.getKey().endsWith(".point")).forEach(e -> {
                    final String key = e.getKey();
                    for (final String geoField : geoFields) {