*
 */
@Deprecated
public class LocalRepositoryNotAccessibleException extends IOException {

    public LocalRepositoryNotAccessibleException(String message, Throwable cause) {
        super(message);
        initCause(cause);
    }

    public LocalRepositoryNotAccessibleException(String message) {
        super(message);
    }

/**
 * Occurs when a download checksum fails.
 *
 */
@Deprecated
public class ChecksumFailedException extends TransferFailedException {
    public ChecksumFailedException(String s) {
        super(s);
    }

    public ChecksumFailedException(String message, Throwable cause) {
        super(message, cause);
    }

==============================================================================*/

#include "tensorflow/c/eager/abstract_tensor_handle.h"

namespace tensorflow {

std::string AbstractTensorHandle::DebugString() const {
  PartialTensorShape shape;
  absl::Status s = Shape(&shape);
  std::string shape_string;
  if (!s.ok()) {
    shape_string = "<error computing shape>";
  } else {
    shape_string = shape.DebugString();
  }

        final String fileConfigId = fileConfig.getId();

        fileConfigBhv.delete(fileConfig, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

        fileAuthenticationBhv.queryDelete(cb -> {
            cb.query().setFileConfigId_Equal(fileConfigId);
        });
    }

    public OptionalEntity<FileConfig> getFileConfig(final String id) {

        return new VersionsMetadata(artifact, path, timestamp);
    }

    @Override
    public String getGroupId() {
        return artifact.getGroupId();
    }

    @Override
    public String getArtifactId() {
        return artifact.getArtifactId();
    }

    @Override
    public String getVersion() {
        return "";
    }

    @Override
    public Nature getNature() {

      }

      final String string = paramString(CharMatcher.class, generateInt());

      @Override
      public String toString() {
        return string;
      }
    };
  }

  @Generates
  Ticker generateTicker() {
    return new Ticker() {
      @Override
      public long read() {
        return 0;
      }

      final String string = paramString(Ticker.class, generateInt());

    val call = client.newCall(request)
    val response1 = call.execute()
    val cloned = call.clone()
    val response2 = cloned.execute()
    assertThat("abc").isEqualTo(response1.body.string())
    assertThat("def").isEqualTo(response2.body.string())
  }

  @Test
  fun legalToExecuteTwiceCloning_Async() {
    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))

@Experimental
@Immutable
public interface Repository {

    /**
     * The reserved id for Maven Central
     */
    String CENTRAL_ID = "central";

    /**
     * Gets the identifier of this repository.
     *
     * @return the (case-sensitive) identifier, never {@code null}
     */
    @Nonnull
    String getId();

    /**
     * Gets the type of the repository, for example "default".
     *

 */
@Experimental
@Consumer
@Named
public interface ModelParser extends SpiService {

    /**
     * Option that can be specified in the options map.  The value should be a Boolean.
     */
    String STRICT = "strict";

    /**
     * Locates the pom in the given directory.
     *
     * @param dir the directory to locate the pom for, never {@code null}

		// (not implemented on that platform, cgo not enabled, etc).
		if u, ok := userMap.Load(h.Uid); ok {
			h.Uname = u.(string)
		} else if u, err := user.LookupId(strconv.Itoa(h.Uid)); err == nil {
			h.Uname = u.Username
			userMap.Store(h.Uid, h.Uname)
		}
		if g, ok := groupMap.Load(h.Gid); ok {
			h.Gname = g.(string)
		} else if g, err := user.LookupGroupId(strconv.Itoa(h.Gid)); err == nil {
			h.Gname = g.Name