// Binary names can conflict.
	// E.g. template.test from the {html,text}/template packages.
	binName := filepath.Base(os.Args[1])
	deviceGotmp := fmt.Sprintf(deviceRoot+"/%s-%d", binName, os.Getpid())
	deviceGopath := deviceGotmp + "/gopath"
	defer adb("exec-out", "rm", "-rf", deviceGotmp) // Clean up.

	// Determine the package by examining the current working
	// directory, which will look something like

        private Lifecycle wrap(org.apache.maven.lifecycle.Lifecycle lifecycle) {
            return new Lifecycle() {
                @Override
                public String id() {
                    return lifecycle.getId();
                }

                @Override
                public Collection<Phase> phases() {
                    List<String> names = lifecycle.getPhases();

        when(fh.acquire()).thenReturn(fh);
        lenient().when(fh.isValid()).thenReturn(true);
        lenient().when(fh.getTree()).thenReturn(tree);
        when(fh.getFid()).thenReturn(99);

        // Mock send to just echo the provided response instance
        when(tree.send(any(TransTransactNamedPipe.class), any(TransTransactNamedPipeResponse.class), eq(RequestParam.NO_RETRY)))

                } catch (final Exception e) {
                    request.abort();
                    logger.warn("Failed to authenticate with form-based authentication: scheme={}, url={}", scheme, request.getURI(), e);
                } finally {
                    EntityUtils.consumeQuietly(httpEntity);
                }
            });
        });

        httpClient = closeableHttpClient;

            final HttpSession session = r.getSession(false);
            if (session != null) {
                return session.getId();
            }
            final String preference = r.getParameter("preference");
            if (preference != null) {
                return Integer.toString(preference.hashCode());
            }

  handle_->Ref();
}
TapeTensor::TapeTensor(const TapeTensor& other) {
  handle_ = other.handle_;
  handle_->Ref();
}
TapeTensor::~TapeTensor() { handle_->Unref(); }

int64_t TapeTensor::GetID() const { return ToId(handle_); }

tensorflow::DataType TapeTensor::GetDType() const {
  return handle_->DataType();
}
AbstractTensorHandle* TapeTensor::GetHandle() const { return handle_; }

      assertEquivalent(stats.mean(), streamStats.getAverage());
      assertEquivalent(stats.sum(), streamStats.getSum());
      assertEquivalent(stats.max(), streamStats.getMax());
      assertEquivalent(stats.min(), streamStats.getMin());
    }
  }

  private static void assertEquivalent(double actual, double expected) {
    if (expected == POSITIVE_INFINITY) {
      assertThat(actual).isPositiveInfinity();

                for (final SearchHit hit : hits) {
                    final UpdateRequestBuilder requestBuilder =
                            builder.apply(client.prepareUpdate().setIndex(index).setId(hit.getId()), hit);
                    if (requestBuilder != null) {
                        bulkRequest.add(requestBuilder);
                    }
                    count++;
                }

        when(fh.acquire()).thenReturn(fh);
        when(fh.isValid()).thenReturn(true);
        when(fh.getTree()).thenReturn(tree);
        when(fh.getFileId()).thenReturn(new byte[16]);
        when(fh.getFid()).thenReturn(1);

        // build via package-private constructor to control unshared flag
        return new SmbRandomAccessFile(file, mode, SmbConstants.DEFAULT_SHARING, unshared);
    }

    @Test

        } finally {
            Response curResp = response;
            Request curReq = request;
            while (curResp != null) {
                this.response_map.remove(curResp.getMid());
                final Request next = curReq.getNext();
                if (next == null) {
                    break;
                }
                curReq = next;