Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- Testing/Support/SupportHelpers.h -----------------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_TESTING_SUPPORT_SUPPORTHELPERS_H

#define LLVM_TESTING_SUPPORT_SUPPORTHELPERS_H

#include "llvm/ADT/SmallString.h"

#include "llvm/Support/Error.h"

#include "llvm/Support/FileSystem.h"

#include "llvm/Support/Path.h"

#include "llvm/Support/raw_os_ostream.h"

#include "gmock/gmock-matchers.h"

#include "gtest/gtest-printers.h"

#include <optional>

#include <string>

namespace llvm {

namespace detail {

struct ErrorHolder {

  std::vector<std::shared_ptr<ErrorInfoBase>> Infos;

  bool Success() const { return Infos.empty(); }

};

template <typename T> struct ExpectedHolder : public ErrorHolder {

  ExpectedHolder(ErrorHolder Err, Expected<T> &Exp)

      : ErrorHolder(std::move(Err)), Exp(Exp) {}

  Expected<T> &Exp;

};

inline void PrintTo(const ErrorHolder &Err, std::ostream *Out) {

  raw_os_ostream OS(*Out);

  OS << (Err.Success() ? "succeeded" : "failed");

  if (!Err.Success()) {

    const char *Delim = "  (";

    for (const auto &Info : Err.Infos) {

      OS << Delim;

      Delim = "; ";

      Info->log(OS);

    }

    OS << ")";

  }

}

template <typename T>

void PrintTo(const ExpectedHolder<T> &Item, std::ostream *Out) {

  if (Item.Success()) {

    *Out << "succeeded with value " << ::testing::PrintToString(*Item.Exp);

  } else {

    PrintTo(static_cast<const ErrorHolder &>(Item), Out);

  }

}

template <class InnerMatcher> class ValueIsMatcher {

public:

  explicit ValueIsMatcher(InnerMatcher ValueMatcher)

      : ValueMatcher(ValueMatcher) {}

  template <class T>

  operator ::testing::Matcher<const std::optional<T> &>() const {

    return ::testing::MakeMatcher(

        new Impl<T>(::testing::SafeMatcherCast<T>(ValueMatcher)));

  }

  template <class T, class O = std::optional<T>>

  class Impl : public ::testing::MatcherInterface<const O &> {

  public:

    explicit Impl(const ::testing::Matcher<T> &ValueMatcher)

        : ValueMatcher(ValueMatcher) {}

    bool MatchAndExplain(const O &Input,

                         testing::MatchResultListener *L) const override {

      return Input && ValueMatcher.MatchAndExplain(*Input, L);

    }

    void DescribeTo(std::ostream *OS) const override {

      *OS << "has a value that ";

      ValueMatcher.DescribeTo(OS);

    }

    void DescribeNegationTo(std::ostream *OS) const override {

      *OS << "does not have a value that ";

      ValueMatcher.DescribeTo(OS);

    }

  private:

    testing::Matcher<T> ValueMatcher;

  };

private:

  InnerMatcher ValueMatcher;

};

} // namespace detail

/// Matches an std::optional<T> with a value that conforms to an inner matcher.

/// To match std::nullopt you could use Eq(std::nullopt).

template <class InnerMatcher>

detail::ValueIsMatcher<InnerMatcher> ValueIs(const InnerMatcher &ValueMatcher) {

  return detail::ValueIsMatcher<InnerMatcher>(ValueMatcher);

}

namespace unittest {

SmallString<128> getInputFileDirectory(const char *Argv0);

/// A RAII object that creates a temporary directory upon initialization and

/// removes it upon destruction.

class TempDir {

  SmallString<128> Path;

public:

  /// Creates a managed temporary directory.

  ///

  /// @param Name The name of the directory to create.

  /// @param Unique If true, the directory will be created using

  ///               llvm::sys::fs::createUniqueDirectory.

  explicit TempDir(StringRef Name, bool Unique = false) {

    std::error_code EC;

    if (Unique) {

      EC = llvm::sys::fs::createUniqueDirectory(Name, Path);

      if (!EC) {

        // Resolve any symlinks in the new directory.

        std::string UnresolvedPath(Path.str());

        EC = llvm::sys::fs::real_path(UnresolvedPath, Path);

      }

    } else {

      Path = Name;

      EC = llvm::sys::fs::create_directory(Path);

    }

    if (EC)

      Path.clear();

    EXPECT_FALSE(EC) << EC.message();

  }

  ~TempDir() {

    if (!Path.empty()) {

      EXPECT_FALSE(llvm::sys::fs::remove_directories(Path.str()));

    }

  }

  TempDir(const TempDir &) = delete;

  TempDir &operator=(const TempDir &) = delete;

  TempDir(TempDir &&) = default;

  TempDir &operator=(TempDir &&) = default;

  /// The path to the temporary directory.

  StringRef path() const { return Path; }

  /// The null-terminated C string pointing to the path.

  const char *c_str() { return Path.c_str(); }

  /// Creates a new path by appending the argument to the path of the managed

  /// directory using the native path separator.

  SmallString<128> path(StringRef component) const {

    SmallString<128> Result(Path);

    SmallString<128> ComponentToAppend(component);

    llvm::sys::path::native(ComponentToAppend);

    llvm::sys::path::append(Result, Twine(ComponentToAppend));

    return Result;

  }

};

/// A RAII object that creates a link upon initialization and

/// removes it upon destruction.

///

/// The link may be a soft or a hard link, depending on the platform.

class TempLink {

  SmallString<128> Path;

public:

  /// Creates a managed link at path Link pointing to Target.

  TempLink(StringRef Target, StringRef Link) {

    Path = Link;

    std::error_code EC = sys::fs::create_link(Target, Link);

    if (EC)

      Path.clear();

    EXPECT_FALSE(EC);

  }

  ~TempLink() {

    if (!Path.empty()) {

      EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));

    }

  }

  TempLink(const TempLink &) = delete;

  TempLink &operator=(const TempLink &) = delete;

  TempLink(TempLink &&) = default;

  TempLink &operator=(TempLink &&) = default;

  /// The path to the link.

  StringRef path() const { return Path; }

};

/// A RAII object that creates a file upon initialization and

/// removes it upon destruction.

class TempFile {

  SmallString<128> Path;

public:

  /// Creates a managed file.

  ///

  /// @param Name The name of the file to create.

  /// @param Contents The string to write to the file.

  /// @param Unique If true, the file will be created using

  ///               llvm::sys::fs::createTemporaryFile.

  TempFile(StringRef Name, StringRef Suffix = "", StringRef Contents = "",

           bool Unique = false) {

    std::error_code EC;

    int fd;

    if (Unique) {

      EC = llvm::sys::fs::createTemporaryFile(Name, Suffix, fd, Path);

    } else {

      Path = Name;

      if (!Suffix.empty()) {

        Path.append(".");

        Path.append(Suffix);

      }

      EC = llvm::sys::fs::openFileForWrite(Path, fd);

    }

    EXPECT_FALSE(EC);

    raw_fd_ostream OS(fd, /*shouldClose*/ true);

    OS << Contents;

    OS.flush();

    EXPECT_FALSE(OS.error());

    if (EC || OS.error())

      Path.clear();

  }

  ~TempFile() {

    if (!Path.empty()) {

      EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));

    }

  }

  TempFile(const TempFile &) = delete;

  TempFile &operator=(const TempFile &) = delete;

  TempFile(TempFile &&) = default;

  TempFile &operator=(TempFile &&) = default;

  /// The path to the file.

  StringRef path() const { return Path; }

};

} // namespace unittest

} // namespace llvm

#endif