pkg syscall (freebsd-386-cgo), func ParseSocketControlMessage([]uint8) ([]SocketControlMessage, error)
pkg syscall (freebsd-386-cgo), func ParseUnixRights(*SocketControlMessage) ([]int, error)
pkg syscall (freebsd-386-cgo), func Pathconf(string, int) (int, error)
pkg syscall (freebsd-386-cgo), func Pipe([]int) error
pkg syscall (freebsd-386-cgo), func Pread(int, []uint8, int64) (int, error)

        ArtifactRepository localRepository = localRepository();

        Artifact a = createArtifact("a", "0.0.1-SNAPSHOT");
        File file = new File(localRepository.getBasedir(), localRepository.pathOf(a));
        file.delete();
        a.setFile(file);

        File touchFile = updateCheckManager.getTouchfile(a);
        touchFile.delete();

        String path = remoteRepo.pathOf(artifact);

        File file = new File(remoteRepo.getBasedir(), path);

        assertFalse(file.exists(), "Remote artifact " + file + " should not be present.");
    }

    protected void assertLocalArtifactNotPresent(Artifact artifact) throws Exception {
        ArtifactRepository localRepo = localRepository();

        String path = localRepo.pathOf(artifact);

        return localRepository.pathOfLocalRepositoryMetadata(metadata, repository);
    }

    @Override
    public String pathOf(Artifact artifact) {
        return localRepository.pathOf(artifact);
    }

    @Override
    public boolean hasLocalMetadata() {
        return true;
    }

        Set<Path> sourceFolders = pathsOf(existing(getSourceDirs()));
        Set<Path> generatedSourceFolders = pathsOf(existing(getGeneratedSourceDirs()));
        Set<Path> testSourceFolders = pathsOf(existing(getTestSources().getFiles()));
        Set<Path> resourceFolders = pathsOf(existing(getResourceDirs()));
        Set<Path> testResourceFolders = pathsOf(existing(getTestResources().getFiles()));

#include "tensorflow/c/experimental/ops/gen/cpp/renderers/cpp_file_renderer.h"
#include "tensorflow/core/lib/io/path.h"

namespace tensorflow {
namespace generator {

CppGenerator::CppGenerator(cpp::CppConfig cpp_config, PathConfig path_config)
    : controller_(path_config),
      cpp_config_(cpp_config),
      path_config_(path_config) {}

SourceCode CppGenerator::GenerateOneFile(
    cpp::RendererContext::Mode mode) const {

        if (realLocalRepo) {
            return delegate.pathOf(RepositoryUtils.toArtifact(artifact.setVersion(artifact.getBaseVersion())));
        }
        return delegate.pathOf(RepositoryUtils.toArtifact(artifact));
    }

    public String getPathForRemoteArtifact(Artifact artifact, RemoteRepository repository, String context) {
        return delegate.pathOf(RepositoryUtils.toArtifact(artifact));
    }

namespace {

TEST(Renderer, typical_usage) {
  class TestRenderer : Renderer {
   public:
    explicit TestRenderer(SourceCode& code)
        : Renderer(
              {RendererContext::kSource, code, CppConfig(), PathConfig()}) {}

    void Render() {
      CommentLine("File level comment.");
      CodeLine("#include \"header.h\"");
      BlankLine();
      BlockOpen("void TestFunction()");
      {
        Statement("int i = 1");

                    ArtifactRepositoryPolicy.CHECKSUM_POLICY_IGNORE);
        }

        this.releases = releases;
    }

    public String pathOf(Artifact artifact) {
        return layout.pathOf(artifact);
    }

    public String pathOfRemoteRepositoryMetadata(ArtifactMetadata artifactMetadata) {
        return layout.pathOfRemoteRepositoryMetadata(artifactMetadata);
    }

namespace tensorflow {
namespace generator {
namespace cpp {

struct RendererContext {
  enum Mode { kHeader = 0, kSource };

  Mode mode;
  SourceCode &code;
  CppConfig cpp_config;
  PathConfig path_config;
};

}  // namespace cpp
}  // namespace generator
}  // namespace tensorflow