text:
namespace {

using ::testing::StaticAssertTypeEq;

template <class T, class U>
struct simple_pair {
  T first;
  U second;
};

struct Dummy {};

struct ReturnType {};
struct ConvertibleToReturnType {
  operator ReturnType() const;  // NOLINT
};

// Unique types used as parameter types for testing the detection idiom.
struct StructA {};
struct StructB {};
struct StructC {};

struct TypeWithBarFunction {
  template <class T,
            absl::enable_if_t<std::is_same<T&&, StructA&>::value, int> = 0>
  ReturnType bar(T&&, const StructB&, StructC&&) &&;  // NOLINT
};

struct TypeWithBarFunctionAndConvertibleReturnType {
  template <class T,
            absl::enable_if_t<std::is_same<T&&, StructA&>::value, int> = 0>
  ConvertibleToReturnType bar(T&&, const StructB&, StructC&&) &&;  // NOLINT
};

template <class Class, class... Ts>
using BarIsCallableImpl =
    decltype(std::declval<Class>().bar(std::declval<Ts>()...));

template <class Class, class... T>
using BarIsCallable =
    absl::type_traits_internal::is_detected<BarIsCallableImpl, Class, T...>;

template <class Class, class... T>
using BarIsCallableConv = absl::type_traits_internal::is_detected_convertible<
    ReturnType, BarIsCallableImpl, Class, T...>;

// NOTE: Test of detail type_traits_internal::is_detected.
TEST(IsDetectedTest, BasicUsage) {
  EXPECT_TRUE((BarIsCallable<TypeWithBarFunction, StructA&, const StructB&,
                             StructC>::value));
  EXPECT_TRUE(
      (BarIsCallable<TypeWithBarFunction, StructA&, StructB&, StructC>::value));
  EXPECT_TRUE(
      (BarIsCallable<TypeWithBarFunction, StructA&, StructB, StructC>::value));

  EXPECT_FALSE((BarIsCallable<int, StructA&, const StructB&, StructC>::value));
  EXPECT_FALSE((BarIsCallable<TypeWithBarFunction&, StructA&, const StructB&,
                              StructC>::value));
  EXPECT_FALSE((BarIsCallable<TypeWithBarFunction, StructA, const StructB&,
                              StructC>::value));
}

// NOTE: Test of detail type_traits_internal::is_detected_convertible.
TEST(IsDetectedConvertibleTest, BasicUsage) {
  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunction, StructA&, const StructB&,
                                 StructC>::value));
  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunction, StructA&, StructB&,
                                 StructC>::value));
  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunction, StructA&, StructB,
                                 StructC>::value));
  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
                                 StructA&, const StructB&, StructC>::value));
  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
                                 StructA&, StructB&, StructC>::value));
  EXPECT_TRUE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
                                 StructA&, StructB, StructC>::value));

  EXPECT_FALSE(
      (BarIsCallableConv<int, StructA&, const StructB&, StructC>::value));
  EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunction&, StructA&,
                                  const StructB&, StructC>::value));
  EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunction, StructA, const StructB&,
                                  StructC>::value));
  EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType&,
                                  StructA&, const StructB&, StructC>::value));
  EXPECT_FALSE((BarIsCallableConv<TypeWithBarFunctionAndConvertibleReturnType,
                                  StructA, const StructB&, StructC>::value));
}

TEST(VoidTTest, BasicUsage) {
  StaticAssertTypeEq<void, absl::void_t<Dummy>>();
  StaticAssertTypeEq<void, absl::void_t<Dummy, Dummy, Dummy>>();
}

TEST(ConjunctionTest, BasicBooleanLogic) {
  EXPECT_TRUE(absl::conjunction<>::value);
  EXPECT_TRUE(absl::conjunction<std::true_type>::value);
  EXPECT_TRUE((absl::conjunction<std::true_type, std::true_type>::value));
  EXPECT_FALSE((absl::conjunction<std::true_type, std::false_type>::value));
  EXPECT_FALSE((absl::conjunction<std::false_type, std::true_type>::value));
  EXPECT_FALSE((absl::conjunction<std::false_type, std::false_type>::value));
}

struct MyTrueType {
  static constexpr bool value = true;
};

struct MyFalseType {
  static constexpr bool value = false;
};

TEST(ConjunctionTest, ShortCircuiting) {
  EXPECT_FALSE(
      (absl::conjunction<std::true_type, std::false_type, Dummy>::value));
  EXPECT_TRUE((std::is_base_of<MyFalseType,
                               absl::conjunction<std::true_type, MyFalseType,
                                                 std::false_type>>::value));
  EXPECT_TRUE(
      (std::is_base_of<MyTrueType,
                       absl::conjunction<std::true_type, MyTrueType>>::value));
}

TEST(DisjunctionTest, BasicBooleanLogic) {
  EXPECT_FALSE(absl::disjunction<>::value);
  EXPECT_FALSE(absl::disjunction<std::false_type>::value);
  EXPECT_TRUE((absl::disjunction<std::true_type, std::true_type>::value));
  EXPECT_TRUE((absl::disjunction<std::true_type, std::false_type>::value));
  EXPECT_TRUE((absl::disjunction<std::false_type, std::true_type>::value));
  EXPECT_FALSE((absl::disjunction<std::false_type, std::false_type>::value));
}

TEST(DisjunctionTest, ShortCircuiting) {
  EXPECT_TRUE(
      (absl::disjunction<std::false_type, std::true_type, Dummy>::value));
  EXPECT_TRUE((
      std::is_base_of<MyTrueType, absl::disjunction<std::false_type, MyTrueType,
                                                    std::true_type>>::value));
  EXPECT_TRUE((
      std::is_base_of<MyFalseType,
                      absl::disjunction<std::false_type, MyFalseType>>::value));
}

TEST(NegationTest, BasicBooleanLogic) {
  EXPECT_FALSE(absl::negation<std::true_type>::value);
  EXPECT_FALSE(absl::negation<MyTrueType>::value);
  EXPECT_TRUE(absl::negation<std::false_type>::value);
  EXPECT_TRUE(absl::negation<MyFalseType>::value);
}

// all member functions are trivial
class Trivial {
  int n_;
};

struct TrivialDestructor {
  ~TrivialDestructor() = default;
};

struct NontrivialDestructor {
  ~NontrivialDestructor() {}
};

struct DeletedDestructor {
  ~DeletedDestructor() = delete;
};

class TrivialDefaultCtor {
 public:
  TrivialDefaultCtor() = default;
  explicit TrivialDefaultCtor(int n) : n_(n) {}

 private:
  int n_;
};

class NontrivialDefaultCtor {
 public:
  NontrivialDefaultCtor() : n_(1) {}

 private:
  int n_;
};

class DeletedDefaultCtor {
 public:
  DeletedDefaultCtor() = delete;
  explicit DeletedDefaultCtor(int n) : n_(n) {}

 private:
  int n_;
};

class TrivialMoveCtor {
 public:
  explicit TrivialMoveCtor(int n) : n_(n) {}
  TrivialMoveCtor(TrivialMoveCtor&&) = default;
  TrivialMoveCtor& operator=(const TrivialMoveCtor& t) {
    n_ = t.n_;
    return *this;
  }

 private:
  int n_;
};

class NontrivialMoveCtor {
 public:
  explicit NontrivialMoveCtor(int n) : n_(n) {}
  NontrivialMoveCtor(NontrivialMoveCtor&& t) noexcept : n_(t.n_) {}
  NontrivialMoveCtor& operator=(const NontrivialMoveCtor&) = default;

 private:
  int n_;
};

class TrivialCopyCtor {
 public:
  explicit TrivialCopyCtor(int n) : n_(n) {}
  TrivialCopyCtor(const TrivialCopyCtor&) = default;
  TrivialCopyCtor& operator=(const TrivialCopyCtor& t) {
    n_ = t.n_;
    return *this;
  }

 private:
  int n_;
};

class NontrivialCopyCtor {
 public:
  explicit NontrivialCopyCtor(int n) : n_(n) {}
  NontrivialCopyCtor(const NontrivialCopyCtor& t) : n_(t.n_) {}
  NontrivialCopyCtor& operator=(const NontrivialCopyCtor&) = default;

 private:
  int n_;
};

class DeletedCopyCtor {
 public:
  explicit DeletedCopyCtor(int n) : n_(n) {}
  DeletedCopyCtor(const DeletedCopyCtor&) = delete;
  DeletedCopyCtor& operator=(const DeletedCopyCtor&) = default;

 private:
  int n_;
};

class TrivialMoveAssign {
 public:
  explicit TrivialMoveAssign(int n) : n_(n) {}
  TrivialMoveAssign(const TrivialMoveAssign& t) : n_(t.n_) {}
  TrivialMoveAssign& operator=(TrivialMoveAssign&&) = default;
  ~TrivialMoveAssign() {}  // can have nontrivial destructor
 private:
  int n_;
};

class NontrivialMoveAssign {
 public:
  explicit NontrivialMoveAssign(int n) : n_(n) {}
  NontrivialMoveAssign(const NontrivialMoveAssign&) = default;
  NontrivialMoveAssign& operator=(NontrivialMoveAssign&& t) noexcept {
    n_ = t.n_;
    return *this;
  }

 private:
  int n_;
};

class TrivialCopyAssign {
 public:
  explicit TrivialCopyAssign(int n) : n_(n) {}
  TrivialCopyAssign(const TrivialCopyAssign& t) : n_(t.n_) {}
  TrivialCopyAssign& operator=(const TrivialCopyAssign& t) = default;
  ~TrivialCopyAssign() {}  // can have nontrivial destructor
 private:
  int n_;
};

class NontrivialCopyAssign {
 public:
  explicit NontrivialCopyAssign(int n) : n_(n) {}
  NontrivialCopyAssign(const NontrivialCopyAssign&) = default;
  NontrivialCopyAssign& operator=(const NontrivialCopyAssign& t) {
    n_ = t.n_;
    return *this;
  }

 private:
  int n_;
};

class DeletedCopyAssign {
 public:
  explicit DeletedCopyAssign(int n) : n_(n) {}
  DeletedCopyAssign(const DeletedCopyAssign&) = default;
  DeletedCopyAssign& operator=(const DeletedCopyAssign&) = delete;

 private:
  int n_;
};

struct MovableNonCopyable {
  MovableNonCopyable() = default;
  MovableNonCopyable(const MovableNonCopyable&) = delete;
  MovableNonCopyable(MovableNonCopyable&&) = default;
  MovableNonCopyable& operator=(const MovableNonCopyable&) = delete;
  MovableNonCopyable& operator=(MovableNonCopyable&&) = default;
};

struct NonCopyableOrMovable {
  NonCopyableOrMovable() = default;
  NonCopyableOrMovable(const NonCopyableOrMovable&) = delete;
  NonCopyableOrMovable(NonCopyableOrMovable&&) = delete;
  NonCopyableOrMovable& operator=(const NonCopyableOrMovable&) = delete;
  NonCopyableOrMovable& operator=(NonCopyableOrMovable&&) = delete;
};

class Base {
 public:
  virtual ~Base() {}
};

// In GCC/Clang, std::is_trivially_constructible requires that the destructor is
// trivial. However, MSVC doesn't require that. This results in different
// behavior when checking is_trivially_constructible on any type with
// nontrivial destructor. Since absl::is_trivially_default_constructible and
// absl::is_trivially_copy_constructible both follows Clang/GCC's interpretation
// and check is_trivially_destructible, it results in inconsistency with
// std::is_trivially_xxx_constructible on MSVC. This macro is used to work
// around this issue in test. In practice, a trivially constructible type
// should also be trivially destructible.
// GCC bug 51452: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452
// LWG issue 2116: http://cplusplus.github.io/LWG/lwg-active.html#2116
#ifndef _MSC_VER
#define ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE 1
#endif

// Old versions of libc++, around Clang 3.5 to 3.6, consider deleted destructors
// as also being trivial. With the resolution of CWG 1928 and CWG 1734, this
// is no longer considered true and has thus been amended.
// Compiler Explorer: https://godbolt.org/g/zT59ZL
// CWG issue 1734: http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#1734
// CWG issue 1928: http://open-std.org/JTC1/SC22/WG21/docs/cwg_closed.html#1928
#if !defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 3700
#define ABSL_TRIVIALLY_DESTRUCTIBLE_CONSIDER_DELETED_DESTRUCTOR_NOT_TRIVIAL 1
#endif

// As of the moment, GCC versions >5.1 have a problem compiling for
// std::is_trivially_default_constructible<NontrivialDestructor[10]>, where
// NontrivialDestructor is a struct with a custom nontrivial destructor. Note
// that this problem only occurs for arrays of a known size, so something like
// std::is_trivially_default_constructible<NontrivialDestructor[]> does not
// have any problems.
// Compiler Explorer: https://godbolt.org/g/dXRbdK
// GCC bug 83689: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83689
#if defined(__clang__) || defined(_MSC_VER) || \
    (defined(__GNUC__) && __GNUC__ < 5)
#define ABSL_GCC_BUG_TRIVIALLY_CONSTRUCTIBLE_ON_ARRAY_OF_NONTRIVIAL 1
#endif

TEST(TypeTraitsTest, TestTrivialDestructor) {
  // Verify that arithmetic types and pointers have trivial destructors.
  EXPECT_TRUE(absl::is_trivially_destructible<bool>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<char>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<unsigned char>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<signed char>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<wchar_t>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<int>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<unsigned int>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<int16_t>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<uint16_t>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<int64_t>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<uint64_t>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<float>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<double>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<long double>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<std::string*>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<Trivial*>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<const std::string*>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<const Trivial*>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<std::string**>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<Trivial**>::value);

  // classes with destructors
  EXPECT_TRUE(absl::is_trivially_destructible<Trivial>::value);
  EXPECT_TRUE(absl::is_trivially_destructible<TrivialDestructor>::value);

  // Verify that types with a nontrivial or deleted destructor
  // are marked as such.
  EXPECT_FALSE(absl::is_trivially_destructible<NontrivialDestructor>::value);
#ifdef ABSL_TRIVIALLY_DESTRUCTIBLE_CONSIDER_DELETED_DESTRUCTOR_NOT_TRIVIAL
  EXPECT_FALSE(absl::is_trivially_destructible<DeletedDestructor>::value);
#endif

  // simple_pair of such types is trivial
  EXPECT_TRUE((absl::is_trivially_destructible<simple_pair<int, int>>::value));
  EXPECT_TRUE((absl::is_trivially_destructible<
               simple_pair<Trivial, TrivialDestructor>>::value));

  // Verify that types without trivial destructors are correctly marked as such.
  EXPECT_FALSE(absl::is_trivially_destructible<std::string>::value);
  EXPECT_FALSE(absl::is_trivially_destructible<std::vector<int>>::value);

  // Verify that simple_pairs of types without trivial destructors
  // are not marked as trivial.
  EXPECT_FALSE((absl::is_trivially_destructible<
                simple_pair<int, std::string>>::value));
  EXPECT_FALSE((absl::is_trivially_destructible<
                simple_pair<std::string, int>>::value));

  // array of such types is trivial
  using int10 = int[10];
  EXPECT_TRUE(absl::is_trivially_destructible<int10>::value);
  using Trivial10 = Trivial[10];
  EXPECT_TRUE(absl::is_trivially_destructible<Trivial10>::value);
  using TrivialDestructor10 = TrivialDestructor[10];
  EXPECT_TRUE(absl::is_trivially_destructible<TrivialDestructor10>::value);

  // Conversely, the opposite also holds.
  using NontrivialDestructor10 = NontrivialDestructor[10];
  EXPECT_FALSE(absl::is_trivially_destructible<NontrivialDestructor10>::value);
}

TEST(TypeTraitsTest, TestTrivialDefaultCtor) {
  // arithmetic types and pointers have trivial default constructors.
  EXPECT_TRUE(absl::is_trivially_default_constructible<bool>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<char>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<unsigned char>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<signed char>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<wchar_t>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<int>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<unsigned int>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<int16_t>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<uint16_t>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<int64_t>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<uint64_t>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<float>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<double>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<long double>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<std::string*>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial*>::value);
  EXPECT_TRUE(
      absl::is_trivially_default_constructible<const std::string*>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<const Trivial*>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<std::string**>::value);
  EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial**>::value);

  // types with compiler generated default ctors
  EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial>::value);
  EXPECT_TRUE(
      absl::is_trivially_default_constructible<TrivialDefaultCtor>::value);

  // Verify that types without them are not.
  EXPECT_FALSE(
      absl::is_trivially_default_constructible<NontrivialDefaultCtor>::value);
  EXPECT_FALSE(
      absl::is_trivially_default_constructible<DeletedDefaultCtor>::value);

#ifdef ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE
  // types with nontrivial destructor are nontrivial
  EXPECT_FALSE(
      absl::is_trivially_default_constructible<NontrivialDestructor>::value);
#endif

  // types with vtables
  EXPECT_FALSE(absl::is_trivially_default_constructible<Base>::value);

  // Verify that simple_pair has trivial constructors where applicable.
  EXPECT_TRUE((absl::is_trivially_default_constructible<
               simple_pair<int, char*>>::value));
  EXPECT_TRUE((absl::is_trivially_default_constructible<
               simple_pair<int, Trivial>>::value));
  EXPECT_TRUE((absl::is_trivially_default_constructible<
               simple_pair<int, TrivialDefaultCtor>>::value));

  // Verify that types without trivial constructors are
  // correctly marked as such.
  EXPECT_FALSE(absl::is_trivially_default_constructible<std::string>::value);
  EXPECT_FALSE(
      absl::is_trivially_default_constructible<std::vector<int>>::value);

  // Verify that simple_pairs of types without trivial constructors
  // are not marked as trivial.
  EXPECT_FALSE((absl::is_trivially_default_constructible<
                simple_pair<int, std::string>>::value));
  EXPECT_FALSE((absl::is_trivially_default_constructible<
                simple_pair<std::string, int>>::value));

  // Verify that arrays of such types are trivially default constructible
  using int10 = int[10];
  EXPECT_TRUE(absl::is_trivially_default_constructible<int10>::value);
  using Trivial10 = Trivial[10];
  EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial10>::value);
  using TrivialDefaultCtor10 = TrivialDefaultCtor[10];
  EXPECT_TRUE(
      absl::is_trivially_default_constructible<TrivialDefaultCtor10>::value);

  // Conversely, the opposite also holds.
#ifdef ABSL_GCC_BUG_TRIVIALLY_CONSTRUCTIBLE_ON_ARRAY_OF_NONTRIVIAL
  using NontrivialDefaultCtor10 = NontrivialDefaultCtor[10];
  EXPECT_FALSE(
      absl::is_trivially_default_constructible<NontrivialDefaultCtor10>::value);
#endif
}

TEST(TypeTraitsTest, TestTrivialMoveCtor) {
  // Verify that arithmetic types and pointers have trivial move
  // constructors.
  EXPECT_TRUE(absl::is_trivially_move_constructible<bool>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<char>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<unsigned char>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<signed char>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<wchar_t>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<int>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<unsigned int>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<int16_t>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<uint16_t>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<int64_t>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<uint64_t>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<float>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<double>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<long double>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<std::string*>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<Trivial*>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<const std::string*>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<const Trivial*>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<std::string**>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<Trivial**>::value);

  // Reference types
  EXPECT_TRUE(absl::is_trivially_move_constructible<int&>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<int&&>::value);

  // types with compiler generated move ctors
  EXPECT_TRUE(absl::is_trivially_move_constructible<Trivial>::value);
  EXPECT_TRUE(absl::is_trivially_move_constructible<TrivialMoveCtor>::value);

  // Verify that types without them (i.e. nontrivial or deleted) are not.
  EXPECT_FALSE(
      absl::is_trivially_move_constructible<NontrivialCopyCtor>::value);
  EXPECT_FALSE(absl::is_trivially_move_constructible<DeletedCopyCtor>::value);
  EXPECT_FALSE(
      absl::is_trivially_move_constructible<NonCopyableOrMovable>::value);

#ifdef ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE
  // type with nontrivial destructor are nontrivial move construbtible
  EXPECT_FALSE(
      absl::is_trivially_move_constructible<NontrivialDestructor>::value);
#endif

  // types with vtables
  EXPECT_FALSE(absl::is_trivially_move_constructible<Base>::value);

  // Verify that simple_pair of such types is trivially move constructible
  EXPECT_TRUE(
      (absl::is_trivially_move_constructible<simple_pair<int, char*>>::value));
  EXPECT_TRUE((
      absl::is_trivially_move_constructible<simple_pair<int, Trivial>>::value));
  EXPECT_TRUE((absl::is_trivially_move_constructible<
               simple_pair<int, TrivialMoveCtor>>::value));

  // Verify that types without trivial move constructors are
  // correctly marked as such.
  EXPECT_FALSE(absl::is_trivially_move_constructible<std::string>::value);
  EXPECT_FALSE(absl::is_trivially_move_constructible<std::vector<int>>::value);

  // Verify that simple_pairs of types without trivial move constructors
  // are not marked as trivial.
  EXPECT_FALSE((absl::is_trivially_move_constructible<
                simple_pair<int, std::string>>::value));
  EXPECT_FALSE((absl::is_trivially_move_constructible<
                simple_pair<std::string, int>>::value));

  // Verify that arrays are not
  using int10 = int[10];
  EXPECT_FALSE(absl::is_trivially_move_constructible<int10>::value);
}

TEST(TypeTraitsTest, TestTrivialCopyCtor) {
  // Verify that arithmetic types and pointers have trivial copy
  // constructors.
  EXPECT_TRUE(absl::is_trivially_copy_constructible<bool>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<char>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<unsigned char>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<signed char>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<wchar_t>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<int>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<unsigned int>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<int16_t>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<uint16_t>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<int64_t>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<uint64_t>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<float>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<double>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<long double>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<std::string*>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<Trivial*>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<const std::string*>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<const Trivial*>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<std::string**>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<Trivial**>::value);

  // Reference types
  EXPECT_TRUE(absl::is_trivially_copy_constructible<int&>::value);
  EXPECT_FALSE(absl::is_trivially_copy_constructible<int&&>::value);

  // types with compiler generated copy ctors
  EXPECT_TRUE(absl::is_trivially_copy_constructible<Trivial>::value);
  EXPECT_TRUE(absl::is_trivially_copy_constructible<TrivialCopyCtor>::value);

  // Verify that types without them (i.e. nontrivial or deleted) are not.
  EXPECT_FALSE(
      absl::is_trivially_copy_constructible<NontrivialCopyCtor>::value);
  EXPECT_FALSE(absl::is_trivially_copy_constructible<DeletedCopyCtor>::value);
  EXPECT_FALSE(
      absl::is_trivially_copy_constructible<MovableNonCopyable>::value);
  EXPECT_FALSE(
      absl::is_trivially_copy_constructible<NonCopyableOrMovable>::value);

#ifdef ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE
  // type with nontrivial destructor are nontrivial copy construbtible
  EXPECT_FALSE(
      absl::is_trivially_copy_constructible<NontrivialDestructor>::value);
#endif

  // types with vtables
  EXPECT_FALSE(absl::is_trivially_copy_constructible<Base>::value);

  // Verify that simple_pair of such types is trivially copy constructible
  EXPECT_TRUE(
      (absl::is_trivially_copy_constructible<simple_pair<int, char*>>::value));
  EXPECT_TRUE((
      absl::is_trivially_copy_constructible<simple_pair<int, Trivial>>::value));
  EXPECT_TRUE((absl::is_trivially_copy_constructible<
               simple_pair<int, TrivialCopyCtor>>::value));

  // Verify that types without trivial copy constructors are
  // correctly marked as such.
  EXPECT_FALSE(absl::is_trivially_copy_constructible<std::string>::value);
  EXPECT_FALSE(absl::is_trivially_copy_constructible<std::vector<int>>::value);

  // Verify that simple_pairs of types without trivial copy constructors
  // are not marked as trivial.
  EXPECT_FALSE((absl::is_trivially_copy_constructible<
                simple_pair<int, std::string>>::value));
  EXPECT_FALSE((absl::is_trivially_copy_constructible<
                simple_pair<std::string, int>>::value));

  // Verify that arrays are not
  using int10 = int[10];
  EXPECT_FALSE(absl::is_trivially_copy_constructible<int10>::value);
}

TEST(TypeTraitsTest, TestTrivialMoveAssign) {
  // Verify that arithmetic types and pointers have trivial move
  // assignment operators.
  EXPECT_TRUE(absl::is_trivially_move_assignable<bool>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<char>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<unsigned char>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<signed char>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<wchar_t>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<int>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<unsigned int>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<int16_t>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<uint16_t>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<int64_t>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<uint64_t>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<float>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<double>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<long double>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<std::string*>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<Trivial*>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<const std::string*>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<const Trivial*>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<std::string**>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<Trivial**>::value);

  // const qualified types are not assignable
  EXPECT_FALSE(absl::is_trivially_move_assignable<const int>::value);

  // types with compiler generated move assignment
  EXPECT_TRUE(absl::is_trivially_move_assignable<Trivial>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<TrivialMoveAssign>::value);

  // Verify that types without them (i.e. nontrivial or deleted) are not.
  EXPECT_FALSE(absl::is_trivially_move_assignable<NontrivialCopyAssign>::value);
  EXPECT_FALSE(absl::is_trivially_move_assignable<DeletedCopyAssign>::value);
  EXPECT_FALSE(absl::is_trivially_move_assignable<NonCopyableOrMovable>::value);

  // types with vtables
  EXPECT_FALSE(absl::is_trivially_move_assignable<Base>::value);

  // Verify that simple_pair is trivially assignable
  EXPECT_TRUE(
      (absl::is_trivially_move_assignable<simple_pair<int, char*>>::value));
  EXPECT_TRUE(
      (absl::is_trivially_move_assignable<simple_pair<int, Trivial>>::value));
  EXPECT_TRUE((absl::is_trivially_move_assignable<
               simple_pair<int, TrivialMoveAssign>>::value));

  // Verify that types not trivially move assignable are
  // correctly marked as such.
  EXPECT_FALSE(absl::is_trivially_move_assignable<std::string>::value);
  EXPECT_FALSE(absl::is_trivially_move_assignable<std::vector<int>>::value);

  // Verify that simple_pairs of types not trivially move assignable
  // are not marked as trivial.
  EXPECT_FALSE((absl::is_trivially_move_assignable<
                simple_pair<int, std::string>>::value));
  EXPECT_FALSE((absl::is_trivially_move_assignable<
                simple_pair<std::string, int>>::value));

  // Verify that arrays are not trivially move assignable
  using int10 = int[10];
  EXPECT_FALSE(absl::is_trivially_move_assignable<int10>::value);

  // Verify that references are handled correctly
  EXPECT_TRUE(absl::is_trivially_move_assignable<Trivial&&>::value);
  EXPECT_TRUE(absl::is_trivially_move_assignable<Trivial&>::value);
}

TEST(TypeTraitsTest, TestTrivialCopyAssign) {
  // Verify that arithmetic types and pointers have trivial copy
  // assignment operators.
  EXPECT_TRUE(absl::is_trivially_copy_assignable<bool>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<char>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<unsigned char>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<signed char>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<wchar_t>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<int>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<unsigned int>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<int16_t>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<uint16_t>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<int64_t>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<uint64_t>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<float>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<double>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<long double>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<std::string*>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial*>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<const std::string*>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<const Trivial*>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<std::string**>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial**>::value);

  // const qualified types are not assignable
  EXPECT_FALSE(absl::is_trivially_copy_assignable<const int>::value);

  // types with compiler generated copy assignment
  EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<TrivialCopyAssign>::value);

  // Verify that types without them (i.e. nontrivial or deleted) are not.
  EXPECT_FALSE(absl::is_trivially_copy_assignable<NontrivialCopyAssign>::value);
  EXPECT_FALSE(absl::is_trivially_copy_assignable<DeletedCopyAssign>::value);
  EXPECT_FALSE(absl::is_trivially_copy_assignable<MovableNonCopyable>::value);
  EXPECT_FALSE(absl::is_trivially_copy_assignable<NonCopyableOrMovable>::value);

  // types with vtables
  EXPECT_FALSE(absl::is_trivially_copy_assignable<Base>::value);

  // Verify that simple_pair is trivially assignable
  EXPECT_TRUE(
      (absl::is_trivially_copy_assignable<simple_pair<int, char*>>::value));
  EXPECT_TRUE(
      (absl::is_trivially_copy_assignable<simple_pair<int, Trivial>>::value));
  EXPECT_TRUE((absl::is_trivially_copy_assignable<
               simple_pair<int, TrivialCopyAssign>>::value));

  // Verify that types not trivially copy assignable are
  // correctly marked as such.
  EXPECT_FALSE(absl::is_trivially_copy_assignable<std::string>::value);
  EXPECT_FALSE(absl::is_trivially_copy_assignable<std::vector<int>>::value);

  // Verify that simple_pairs of types not trivially copy assignable
  // are not marked as trivial.
  EXPECT_FALSE((absl::is_trivially_copy_assignable<
                simple_pair<int, std::string>>::value));
  EXPECT_FALSE((absl::is_trivially_copy_assignable<
                simple_pair<std::string, int>>::value));

  // Verify that arrays are not trivially copy assignable
  using int10 = int[10];
  EXPECT_FALSE(absl::is_trivially_copy_assignable<int10>::value);

  // Verify that references are handled correctly
  EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial&&>::value);
  EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial&>::value);
}

TEST(TypeTraitsTest, TestTriviallyCopyable) {
  // Verify that arithmetic types and pointers are trivially copyable.
  EXPECT_TRUE(absl::type_traits_internal::is_trivially_copyable<bool>::value);
  EXPECT_TRUE(absl::type_traits_internal::is_trivially_copyable<char>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<unsigned char>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<signed char>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<wchar_t>::value);
  EXPECT_TRUE(absl::type_traits_internal::is_trivially_copyable<int>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<unsigned int>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<int16_t>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<uint16_t>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<int64_t>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<uint64_t>::value);
  EXPECT_TRUE(absl::type_traits_internal::is_trivially_copyable<float>::value);
  EXPECT_TRUE(absl::type_traits_internal::is_trivially_copyable<double>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<long double>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<std::string*>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<Trivial*>::value);
  EXPECT_TRUE(absl::type_traits_internal::is_trivially_copyable<
              const std::string*>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<const Trivial*>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<std::string**>::value);
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<Trivial**>::value);

  // const qualified types are not assignable but are constructible
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<const int>::value);

  // Trivial copy constructor/assignment and destructor.
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<Trivial>::value);
  // Trivial copy assignment, but non-trivial copy constructor/destructor.
  EXPECT_FALSE(absl::type_traits_internal::is_trivially_copyable<
               TrivialCopyAssign>::value);
  // Trivial copy constructor, but non-trivial assignment.
  EXPECT_FALSE(absl::type_traits_internal::is_trivially_copyable<
               TrivialCopyCtor>::value);

  // Types with a non-trivial copy constructor/assignment
  EXPECT_FALSE(absl::type_traits_internal::is_trivially_copyable<
               NontrivialCopyCtor>::value);
  EXPECT_FALSE(absl::type_traits_internal::is_trivially_copyable<
               NontrivialCopyAssign>::value);

  // Types without copy constructor/assignment, but with move
  // MSVC disagrees with other compilers about this:
  // EXPECT_TRUE(absl::type_traits_internal::is_trivially_copyable<
  //             MovableNonCopyable>::value);

  // Types without copy/move constructor/assignment
  EXPECT_FALSE(absl::type_traits_internal::is_trivially_copyable<
               NonCopyableOrMovable>::value);

  // No copy assign, but has trivial copy constructor.
  EXPECT_TRUE(absl::type_traits_internal::is_trivially_copyable<
              DeletedCopyAssign>::value);

  // types with vtables
  EXPECT_FALSE(absl::type_traits_internal::is_trivially_copyable<Base>::value);

  // Verify that simple_pair is trivially copyable if members are
  EXPECT_TRUE((absl::type_traits_internal::is_trivially_copyable<
               simple_pair<int, char*>>::value));
  EXPECT_TRUE((absl::type_traits_internal::is_trivially_copyable<
               simple_pair<int, Trivial>>::value));

  // Verify that types not trivially copyable are
  // correctly marked as such.
  EXPECT_FALSE(
      absl::type_traits_internal::is_trivially_copyable<std::string>::value);
  EXPECT_FALSE(absl::type_traits_internal::is_trivially_copyable<
               std::vector<int>>::value);

  // Verify that simple_pairs of types not trivially copyable
  // are not marked as trivial.
  EXPECT_FALSE((absl::type_traits_internal::is_trivially_copyable<
                simple_pair<int, std::string>>::value));
  EXPECT_FALSE((absl::type_traits_internal::is_trivially_copyable<
                simple_pair<std::string, int>>::value));
  EXPECT_FALSE((absl::type_traits_internal::is_trivially_copyable<
                simple_pair<int, TrivialCopyAssign>>::value));

  // Verify that arrays of trivially copyable types are trivially copyable
  using int10 = int[10];
  EXPECT_TRUE(absl::type_traits_internal::is_trivially_copyable<int10>::value);
  using int10x10 = int[10][10];
  EXPECT_TRUE(
      absl::type_traits_internal::is_trivially_copyable<int10x10>::value);

  // Verify that references are handled correctly
  EXPECT_FALSE(
      absl::type_traits_internal::is_trivially_copyable<Trivial&&>::value);
  EXPECT_FALSE(
      absl::type_traits_internal::is_trivially_copyable<Trivial&>::value);
}

#define ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(trait_name, ...)          \
  EXPECT_TRUE((std::is_same<typename std::trait_name<__VA_ARGS__>::type, \
                            absl::trait_name##_t<__VA_ARGS__>>::value))

TEST(TypeTraitsTest, TestRemoveCVAliases) {
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_cv, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_cv, const int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_cv, volatile int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_cv, const volatile int);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_const, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_const, const int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_const, volatile int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_const, const volatile int);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_volatile, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_volatile, const int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_volatile, volatile int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_volatile, const volatile int);
}

TEST(TypeTraitsTest, TestAddCVAliases) {
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_cv, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_cv, const int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_cv, volatile int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_cv, const volatile int);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_const, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_const, const int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_const, volatile int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_const, const volatile int);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_volatile, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_volatile, const int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_volatile, volatile int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_volatile, const volatile int);
}

TEST(TypeTraitsTest, TestReferenceAliases) {
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, volatile int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, volatile int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, int&&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, volatile int&&);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, volatile int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, volatile int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, int&&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, volatile int&&);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, volatile int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, volatile int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, int&&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, volatile int&&);
}

TEST(TypeTraitsTest, TestPointerAliases) {
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_pointer, int*);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_pointer, volatile int*);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_pointer, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_pointer, volatile int);
}

TEST(TypeTraitsTest, TestSignednessAliases) {
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_signed, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_signed, volatile int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_signed, unsigned);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_signed, volatile unsigned);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_unsigned, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_unsigned, volatile int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_unsigned, unsigned);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_unsigned, volatile unsigned);
}

TEST(TypeTraitsTest, TestExtentAliases) {
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_extent, int[]);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_extent, int[1]);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_extent, int[1][1]);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_extent, int[][1]);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_all_extents, int[]);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_all_extents, int[1]);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_all_extents, int[1][1]);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_all_extents, int[][1]);
}

TEST(TypeTraitsTest, TestAlignedStorageAlias) {
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 1);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 2);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 3);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 4);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 5);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 6);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 7);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 8);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 9);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 10);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 11);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 12);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 13);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 14);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 15);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 16);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 17);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 18);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 19);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 20);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 21);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 22);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 23);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 24);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 25);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 26);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 27);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 28);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 29);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 30);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 31);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 32);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 33);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 1, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 2, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 3, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 4, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 5, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 6, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 7, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 8, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 9, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 10, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 11, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 12, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 13, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 14, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 15, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 16, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 17, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 18, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 19, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 20, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 21, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 22, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 23, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 24, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 25, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 26, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 27, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 28, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 29, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 30, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 31, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 32, 128);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 33, 128);
}

TEST(TypeTraitsTest, TestDecay) {
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, volatile int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const volatile int);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, volatile int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const volatile int&);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, volatile int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const volatile int&);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int[1]);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int[1][1]);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int[][1]);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int());
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int(float));  // NOLINT
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int(char, ...));  // NOLINT
}

struct TypeA {};
struct TypeB {};
struct TypeC {};
struct TypeD {};

template <typename T>
struct Wrap {};

enum class TypeEnum { A, B, C, D };

struct GetTypeT {
  template <typename T,
            absl::enable_if_t<std::is_same<T, TypeA>::value, int> = 0>
  TypeEnum operator()(Wrap<T>) const {
    return TypeEnum::A;
  }

  template <typename T,
            absl::enable_if_t<std::is_same<T, TypeB>::value, int> = 0>
  TypeEnum operator()(Wrap<T>) const {
    return TypeEnum::B;
  }

  template <typename T,
            absl::enable_if_t<std::is_same<T, TypeC>::value, int> = 0>
  TypeEnum operator()(Wrap<T>) const {
    return TypeEnum::C;
  }

  // NOTE: TypeD is intentionally not handled
} constexpr GetType = {};

TEST(TypeTraitsTest, TestEnableIf) {
  EXPECT_EQ(TypeEnum::A, GetType(Wrap<TypeA>()));
  EXPECT_EQ(TypeEnum::B, GetType(Wrap<TypeB>()));
  EXPECT_EQ(TypeEnum::C, GetType(Wrap<TypeC>()));
}

TEST(TypeTraitsTest, TestConditional) {
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(conditional, true, int, char);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(conditional, false, int, char);
}

// TODO(calabrese) Check with specialized std::common_type
TEST(TypeTraitsTest, TestCommonType) {
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int, char);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int, char, int);

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int, char&);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int, char, int&);
}

TEST(TypeTraitsTest, TestUnderlyingType) {
  enum class enum_char : char {};
  enum class enum_long_long : long long {};  // NOLINT(runtime/int)

  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(underlying_type, enum_char);
  ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(underlying_type, enum_long_long);
}

struct GetTypeExtT {
  template <typename T>
  absl::result_of_t<const GetTypeT&(T)> operator()(T&& arg) const {
    return GetType(std::forward<T>(arg));
  }

  TypeEnum operator()(Wrap<TypeD>) const { return TypeEnum::D; }
} constexpr GetTypeExt = {};

TEST(TypeTraitsTest, TestResultOf) {
  EXPECT_EQ(TypeEnum::A, GetTypeExt(Wrap<TypeA>()));
  EXPECT_EQ(TypeEnum::B, GetTypeExt(Wrap<TypeB>()));
  EXPECT_EQ(TypeEnum::C, GetTypeExt(Wrap<TypeC>()));
  EXPECT_EQ(TypeEnum::D, GetTypeExt(Wrap<TypeD>()));
}

template <typename T>
bool TestCopyAssign() {
  return absl::is_copy_assignable<T>::value ==
         std::is_copy_assignable<T>::value;
}

TEST(TypeTraitsTest, IsCopyAssignable) {
  EXPECT_TRUE(TestCopyAssign<int>());
  EXPECT_TRUE(TestCopyAssign<int&>());
  EXPECT_TRUE(TestCopyAssign<int&&>());

  struct S {};
  EXPECT_TRUE(TestCopyAssign<S>());
  EXPECT_TRUE(TestCopyAssign<S&>());
  EXPECT_TRUE(TestCopyAssign<S&&>());

  class C {
   public:
    explicit C(C* c) : c_(c) {}
    ~C() { delete c_; }

   private:
    C* c_;
  };
  EXPECT_TRUE(TestCopyAssign<C>());
  EXPECT_TRUE(TestCopyAssign<C&>());
  EXPECT_TRUE(TestCopyAssign<C&&>());

  // Reason for ifndef: add_lvalue_reference<T> in libc++ breaks for these cases
#ifndef _LIBCPP_VERSION
  EXPECT_TRUE(TestCopyAssign<int()>());
  EXPECT_TRUE(TestCopyAssign<int(int) const>());
  EXPECT_TRUE(TestCopyAssign<int(...) volatile&>());
  EXPECT_TRUE(TestCopyAssign<int(int, ...) const volatile&&>());
#endif  // _LIBCPP_VERSION
}

template <typename T>
bool TestMoveAssign() {
  return absl::is_move_assignable<T>::value ==
         std::is_move_assignable<T>::value;
}

TEST(TypeTraitsTest, IsMoveAssignable) {
  EXPECT_TRUE(TestMoveAssign<int>());
  EXPECT_TRUE(TestMoveAssign<int&>());
  EXPECT_TRUE(TestMoveAssign<int&&>());

  struct S {};
  EXPECT_TRUE(TestMoveAssign<S>());
  EXPECT_TRUE(TestMoveAssign<S&>());
  EXPECT_TRUE(TestMoveAssign<S&&>());

  class C {
   public:
    explicit C(C* c) : c_(c) {}
    ~C() { delete c_; }
    void operator=(const C&) = delete;
    void operator=(C&&) = delete;

   private:
    C* c_;
  };
  EXPECT_TRUE(TestMoveAssign<C>());
  EXPECT_TRUE(TestMoveAssign<C&>());
  EXPECT_TRUE(TestMoveAssign<C&&>());

  // Reason for ifndef: add_lvalue_reference<T> in libc++ breaks for these cases
#ifndef _LIBCPP_VERSION
  EXPECT_TRUE(TestMoveAssign<int()>());
  EXPECT_TRUE(TestMoveAssign<int(int) const>());
  EXPECT_TRUE(TestMoveAssign<int(...) volatile&>());
  EXPECT_TRUE(TestMoveAssign<int(int, ...) const volatile&&>());
#endif  // _LIBCPP_VERSION
}

namespace adl_namespace {

struct DeletedSwap {
};

void swap(DeletedSwap&, DeletedSwap&) = delete;

struct SpecialNoexceptSwap {
  SpecialNoexceptSwap(SpecialNoexceptSwap&&) {}
  SpecialNoexceptSwap& operator=(SpecialNoexceptSwap&&) { return *this; }
  ~SpecialNoexceptSwap() = default;
};

void swap(SpecialNoexceptSwap&, SpecialNoexceptSwap&) noexcept {}

}  // namespace adl_namespace

TEST(TypeTraitsTest, IsSwappable) {
  using absl::type_traits_internal::IsSwappable;
  using absl::type_traits_internal::StdSwapIsUnconstrained;

  EXPECT_TRUE(IsSwappable<int>::value);

  struct S {};
  EXPECT_TRUE(IsSwappable<S>::value);

  struct NoConstruct {
    NoConstruct(NoConstruct&&) = delete;
    NoConstruct& operator=(NoConstruct&&) { return *this; }
    ~NoConstruct() = default;
  };

  EXPECT_EQ(IsSwappable<NoConstruct>::value, StdSwapIsUnconstrained::value);
  struct NoAssign {
    NoAssign(NoAssign&&) {}
    NoAssign& operator=(NoAssign&&) = delete;
    ~NoAssign() = default;
  };

  EXPECT_EQ(IsSwappable<NoAssign>::value, StdSwapIsUnconstrained::value);

  EXPECT_FALSE(IsSwappable<adl_namespace::DeletedSwap>::value);

  EXPECT_TRUE(IsSwappable<adl_namespace::SpecialNoexceptSwap>::value);
}

TEST(TypeTraitsTest, IsNothrowSwappable) {
  using absl::type_traits_internal::IsNothrowSwappable;
  using absl::type_traits_internal::StdSwapIsUnconstrained;

  EXPECT_TRUE(IsNothrowSwappable<int>::value);

  struct NonNoexceptMoves {
    NonNoexceptMoves(NonNoexceptMoves&&) {}
    NonNoexceptMoves& operator=(NonNoexceptMoves&&) { return *this; }
    ~NonNoexceptMoves() = default;
  };

  EXPECT_FALSE(IsNothrowSwappable<NonNoexceptMoves>::value);

  struct NoConstruct {
    NoConstruct(NoConstruct&&) = delete;
    NoConstruct& operator=(NoConstruct&&) { return *this; }
    ~NoConstruct() = default;
  };

  EXPECT_FALSE(IsNothrowSwappable<NoConstruct>::value);

  struct NoAssign {
    NoAssign(NoAssign&&) {}
    NoAssign& operator=(NoAssign&&) = delete;
    ~NoAssign() = default;
  };

  EXPECT_FALSE(IsNothrowSwappable<NoAssign>::value);

  EXPECT_FALSE(IsNothrowSwappable<adl_namespace::DeletedSwap>::value);

  EXPECT_TRUE(IsNothrowSwappable<adl_namespace::SpecialNoexceptSwap>::value);
}

}  // namespace


The New Zealand and Pacific private sector have been provided with a briefing on the implementation process for PACER Plus, and what this landmark trade and development agreement means for the region.
Ambassador for Pacific Economic Development Matua Shane Jones introduced today's session, organised by The Ministry of Foreign Affairs and Trade (MFAT), and staged at their Auckland office.
New Zealand's Chief Negotiator for PACER Plus Tessa Te Mata then presented an informative update on the April 20 conclusion PACER Plus negotiations at a special trade minister's meeting, in Brisbane, followed by a Q&A session with the audience.
The 14 countries participating in PACER Plus are NZ, Australia, Cook Islands, Federated States of Micronesia, Nauru, Kiribati, Niue, Palau, Republic of Marshall Islands, Samoa, Solomon Islands, Tonga, Tuvalu, and Vanuatu.
Pacific Cooperation Foundation (PCF) Chief Executive Laulu Mac Leauanae says the Foundation supports the work of PACER Plus, and the opportunities it will provide for NZ and the Pacific.
"It's a new type of trade agreement and it has a development component, which is really exciting," Mac says.
The development package of more than $55 million aims to help raise standards of living, create employment opportunities and increase export capacity in Pacific Island countries.
A formal signing of the agreement is scheduled to take place in Tonga during June.
Contact MFAT for more information on PACER PLUS.


text:
Terranea's bathroom proposal goes down the drain
This is the site of the future Pacifica Pool building within the Terranea Resort in Rancho Palos Verdes. The developer proposed to significantly reduce the size of the public bathrooms to make way for a larger kitchen and bar area for hotel guests. However, the City Council on Tuesday directed the resort to maintain the same square footage as was initially approved in 2002.
By Palos Verdes Peninsula News |
PUBLISHED: May 9, 2008 at 6:00 p.m. | UPDATED: May 25, 2021 at 7:53 a.m.
Council says decision keeps the public's best interest in mind.
By Ashley Ratcliff, Peninsula News
RPV – A request to amend a segment of Terranea Resort, which prides itself on offering public amenities, on Tuesday raised a point of contention between the developer and the Rancho Palos Verdes City Council. Officials saw the proposed changes as unfair.
When council in 2002 approved the 1,400-square-foot Pacifica Pool snack bar and restrooms building, officials didn't foresee alterations that would adversely impact the way the public enjoyed the resort. Plans for the restroom dedicated 496 square feet to guests and 409 square feet to the public.
However, the California Coastal Commission reduced the structure's footprint to 1,200 square feet, and health restrictions led the developer to reconfigure the kitchen. In the aftermath of bureaucratic decisions, public restrooms were reduced to 214 square feet -107 square feet each for the women's and men's lavatories – while the hotel guests' feature was unchanged.
Reducing the public's access, about 2 1/2 times smaller than hotel guests', didn't sit well with council members, who said that the proposal "slights the public tremendously."
"The whole purpose and major issue was public amenities, and this almost seems like a backhanded slap at the public," said Councilman Steve Wolowicz. "That's mighty small … [The developer essentially is saying,] 'You're welcome to have public beach access, but by the way, we're going to have a long line out there or you're going to be uncomfortable in using these facilities.'"
Said Councilman Peter Gardiner, "No matter how you redesign the restrooms, when I go to places, it seems to me the line for the ladies' is longer than the line for the gentleman's. So I would not be amenable to cutting the number of ladies' facilities in half. The men, they can handle that."
Councilman Larry Clark questioned why the guest restroom wasn't subject to any cutbacks. He said the public shouldn't be "inconvenienced" by design issues on the applicant's part.
"My initial reaction is this is too small. I'm not supportive of this … since this would be a diminishment of a public-serving amenity approved by the Coastal Commission at a different size," he said.
RPV Principal Planner Ara Mihranian said the nearest restroom facilities are within hotel accommodations – the luxury restaurant and Lookout Bar, which aren't designated as public.
Todd Majcher, vice president of Long Point Development LLC, said the changes stemmed from Los Angeles County Health Department restrictions and discussions with the resort's food and beverage consultant, who required the facility to be vermin-proof and fully enclosed. The result was relocating the guest-serving amenities – a bar with stools – and providing more space for food preparation.
"Our intent with the reduction of the public restrooms was most certainly not to offend or misrepresent our commitment to the public component of the resort … We've obviously demonstrated our commitment to the public amenities. It was not [done] to reduce the quality or user experience," Majcher said.
He added that the resort intended to provide the same amount of "fixtures" as was previously proposed.
Clark, also a coastal commissioner, offered stern words of advice to the applicant: "I heard your words, but to me actions speak louder than words … You can leave the kitchen as redesigned, but you either make all the restrooms open to the public … or redesign the hotel guest restrooms so that you increase capacity for the public. But this won't fly with me."
Councilman Tom Long suggested reallocating 214 square feet from the front side of the guest restroom to public's end of the building.
Council ultimately directed the applicant to redesign, whichever way it sees fit, the Pacifica Pool building such that the square footage of the public restrooms doen't decrease.
Terranea officials, Majcher said, are willing to consider the proposed arrangements and added that the developer was reluctant to go before the Coastal Commission a second time to revise the project.
"Perhaps there's a happy medium," Majcher said.
Extended hours to remain on target
Hoping to meet the targeted June 1, 2009, completion date, Terranea Resort on Tuesday also requested amending construction hours beyond the permitted timeframe of Monday through Saturday from 7 a.m. to 7 p.m.
Extending construction hours from 6 a.m. to 10 p.m. Monday through Saturday and working on Memorial Day, Columbus Day, Veterans Day, Martin Luther King Jr.'s Birthday and Memorial Day 2009, officials said, would "accelerate the pace of construction."
The new work schedule would commence once the hotel, spa and fitness buildings were completely enclosed with roofs, walls, windows and doors to muffle the construction noise.
Council approved on a trial basis the extended construction hours and holidays – subject to independent noise monitoring by city staff or a consultant at an added cost paid for by Terranea Resort – and permitted work on Veterans Day 2008 and Memorial Day 2009 during the regular hours of 7 a.m. to 7 p.m.
Work hours, council decided, are subject to cancellation or further restrictions at the planning director's discretion and may be appealed to the City Council. Officials didn't establish a time period for the review or specify a "threshold of complaints."
Residents Derrick A. Ball and Mark Detweiler wrote letters to council in opposition to the augmented hours, while Sandra Nelson, president of the Sea Bluff Homeowners Association, sat on the other side of the fence.
"Neither will pose problems to our membership. The interior two shifts … occur at off-traffic hours, and with the new traffic light operational, will have a minimum impact," she wrote. "We believe prompt approval will expedite our city's commencement of Transient Occupancy Tax (TOT) income, critical to our future financial picture, by quickening the completion of construction."
Added Majcher, "We have a great relationship with our neighbors – we intend to keep it that way."
Terranea officials will give a presentation about the resort's progress today during the Community Leader's Breakfast at 9 a.m. at the Point Vicente Interpretive Center, 31501 Palos Verdes Drive West in RPV.
aratcliff@pvnews.com
PV City News
More in PV News
Despite anti-Semitism, South Bay Jewish leaders spotlight their faith as Hanukkah approaches
Photos: Rolling Hills Estates turns out for 25th annual Parade of Lights
South Bay mother creates 'superfood' for daughter with autism
Photos: Palos Verdes Peninsula community turns out for Terranea tree lighting

redpajama_set_name: RedPajamaCommonCrawl


text:
Q & A with Vivian Villamizar, spa director at Renew the Spa at The James Royal Palm (Miami)
by American Spa Staff
Jul 7, 2014 10:01am
How many years have you been involved in the spa/hospitality industry?
I have been in the hospitality industry for 15 years, and nine of those years have been devoted entirely to the spa industry. Most recently, I was at Canyon Ranch Hotel & Spa in Miami Beach for four years before coming to Renew the Spa at The James Royal Palm.
What are the most challenging and rewarding parts of being in the spa industry?
Since the early growth days in our industry, we have had to survive numerous challenges, and those challenges continue today. Individual spa growth and market share have both been threatened by the growing number of spas and for the industry as a whole. The hospitality industry has never been more challenging and exciting than it is today. Our industry is highly competitive, and to prosper, we need to ensure that our operation is the best in its class, and that is exactly how we get to the rewarding part—meeting amazing individuals along the way and knowing that you have made a difference in their lives.
What qualities do you look for in your spa staff?
Our staff members are handpicked because of their excellence. Our core values and company culture is based on love, trust, respect, and discipline. Consequently, we strive to hire individuals who are passionate about what they do while making sure their vision is in line with our vision of providing operative excellence and optimal spa experiences.
Where do you think the industry is heading?
I continue to see growth in the industry—consumers no longer view spa treatments as a simple pampering experience. In today's fast-paced environment with increasingly hectic schedules, a lack of true leisure time and the pressures of being in constant contact with the office, family, friends, and via email are the kinds of pressures that not only increase stress but also contribute to unhealthy behaviors. I believe that people will continue to seek ways in which to reduce stress, and most of them will continue heading to spas to do that.
What is the most bizarre treatment you've experienced?
The Manaka Tapping Treatment. It is similar to acupuncture, but without the needles. During the treatment, a wooden hammer called a manaka is employed to gently tap wooden pegs placed along the body's acupressure points. The tapping, done rhythmically to the beat of a metronome, is said to provide the same benefits as acupuncture: balance energy and relief from both general stress and specific bodily pains.
What's your go-to spa treatment?
I love treatments that have more than one modality or sequence within the service, like our Jet Set treatment (90 minutes). Within this treatment, there is a stimulating lymphatic body brushing, a warm cocoon body wrap, and a full-body massage with frankincense, grapefruit, lemon, and myrrh. It doesn't get much better than that.
What's your favorite skincare ingredient?
My favorite skincare ingredient is vitamin C because it is a great antioxidant that slows the rate of free-radical damage, and free radicals are unstable molecules that damage collagen and cause skin dryness, fine lines, and wrinkles. Vitamin C plays a big role in my skincare regimen, as I live in sunny Florida. Research suggests that vitamin C also reduces sunburn caused by exposure to ultraviolet B radiation and prevents the consequences of long-term sun exposure, which can lead to skin cancer.
If you could work in any other profession in the world, what would you be?
Although I have no plans to leave the spa industry anytime soon, if I were to envision myself doing something different, a few things come to mind. I think I would enjoy being a social worker, an elementary teacher, or a professional makeup artist.
How would you sum up your personal philosophy?
My passion is to assist in creating memorable experiences with heartfelt intentions. I nurture our associates and respect our core values, which perpetuate a culture of respect, professional behavior, and passion for everything I do.
American Spa Staff


text:
Why it's not fair to lump Nicaragua with the U.S. when it comes to the Paris climate accord
The Eiffel tower is illuminated in green with the words 'Paris Agreement is Done' on Nov. 4, 2016. Only three UN members have opted not to sign one: Syria, Nicaragua and the United States. (Jacky Naegelen/Reuters)
Nicaragua is tired of being lumped in with the U.S. when it comes to the Paris climate accord.
When President Donald Trump announced earlier this month the U.S. would not sign the international agreement, the U.S. joined just two other UN members in the same boat. One of them is Syria, which is mired in a devastating civil war. The other is Nicaragua.
But Nicaragua's problem with the Paris agreement is a lot different than Trump's.
Nicaraguan National Policy Minister Paul Oquist, the country's negotiator at the 2015 Paris talks, outlined those differences to As It Happens host Carol Off. Here is part of their conversation:
U.S. President Donald Trump
U.S. President Donald Trump refers to amounts of temperature change as he announces his decision that the United States will withdraw from the landmark Paris climate agreement. (Joshua Roberts/Reuters)
Carol Off: Donald Trump says the Paris climate accord is too restrictive for the United States. Why didn't Nicaragua sign on?
Paul Oquist: Because the agreement is too weak. The agreement is not legally binding. The agreement does not keep temperature under 2 C. It doesn't achieve the 1.5 C degree goal. It has developing countries renouncing their legal rights to indemnization for the losses and damages that they're receiving year after year. So the Paris agreement doesn't fulfil its own objectives.
The Paris agreement is set up in such a way that it is getting the large emitters off the hook. The large emitting countries do not want to commit themselves to the degree of emissions reductions required to reach the 1.5 C target, or even the 2 C target. So they are looking for all kinds of subterfuges to not oblige themselves to take the political decisions, economic decisions, that would be required to stop climate change.
Nicaraguan National Policy Minister Paul Oquist
Paul Oquist, seen here at the 2016 UN climate change conference, says the Paris accord lets countries that emit the most greenhouse gases off the hook. (Youssef Boudlal/Reuters)
CO: You're saying it's because it doesn't go far enough.
PO: Absolutely.
It will be less water, less food, less health, less nutrition, more poverty — and more migration, by the way, towards the northern countries.
There are already climate change refugees in the world. … The world is headed to very difficult times because of the failure of the high-emitter countries to come to terms with the absolute necessity that they reduce their emissions … so I think that the developed countries should think this through. Think through what the consequences of not assuming the responsibilities now are going to be.
CO: What do you think of Canada's record on greenhouse gas emissions?
PO: Canada left the Kyoto agreement, as you know. … Canada has two per cent of the world's emissions. It's among the top 10. [Editor's Note: Canada's emissions in 2013 made up 1.6 per cent of global greenhouse gas emissions, according to Environment Canada. It ranks ninth among the world's top 10 emitters.]
It would be wonderful if Canada would take a leadership role among them, because Canada has the ability to do so, I think. It has very good international relations. And to take a leadership role in here so as to plant the necessity of reducing the gigatonnes for 2030 from 55 to below 35. With that we could put the lid on 1.5 C temperature change in this century and save the world from a lot of grief — of death, destruction, massive migrations, and disease.
But to do that it's going to very strong measures to take the world very swiftly to a genuinely low-carbon economy and to massive capture of greenhouse gases via the reforestation of degraded land.
Source: CBC Radio
Previous articleNicaragua Ex-Diplomat Miguel D'Escoto Brockmann Dies at 84
Next articleNicaragua Economic Activity Up 4.9% up to April 2017


Circle Diamond Earrings New 2018 A Retro 925 Silver Cz Stone Round Stud Earrings for Women is a part of 33 Awesome Of Circle Diamond Earrings pictures gallery. To download this Circle Diamond Earrings New 2018 A Retro 925 Silver Cz Stone Round Stud Earrings for Women in High Resolution, right click on the image and choose "Save Image As" and then you will get this image about Circle Diamond Earrings New 2018 A Retro 925 Silver Cz Stone Round Stud Earrings for Women.
This digital photography of Circle Diamond Earrings New 2018 A Retro 925 Silver Cz Stone Round Stud Earrings for Women has dimension 1000 × 1000 pixels. You can see another items of this gallery of 33 Awesome Of Circle Diamond Earrings below. Get interesting article about 33 Awesome Of Circle Diamond Earrings that may help you.
great goods to immortalize confident life gatherings that are very essential towards be overlooked Elegant Of Circle Diamond Earrings.
placed through hash at 2018-09-05 23:09:02. To see just about all graphics with Elegant Of Circle Diamond Earrings graphics gallery you need to follow that url.


text:
Aug, 2, 2019 Posted in Action, Adventure, Anime, Anime Birthdays, Anime Challenge, Anime Lore, Anime Music, Articles, Bento Bites, Comedy, Events, Game, Games, Interest, Kawaii Kulture, Mecha, School, Science-Fiction
Explore Japan's Mountains!
Japan is a land of islands, forests and mountains and since it will be Mountain Day in Japan soon we are going on a journey, discovering Japan's mountain culture, learning the Japanese word for mountain and exploring the food you can get on and around Mount Fuji. We also explore the events of the Kyoto Animation arson news that shocked the anime world in July as well as other anime news, and much more. If you are hungry for anime and Japan-related news, we will satisfy your appetite. We are YOUR source of monthly anime news. Itadakimasu!!
Anime we watched last month
This anime season has great new series to get lost into. There is Cop Craft where a cop and a Semanian Knight, a fairy knight try to investigate a group of people that use fairies as ingredients for drugs, a group also responsible for the death of his partner. Will they succeed in bringing down a group of drug lords dead-set on murdering fairies for drug ingredients. Dr. Stone is another excellent anime series. In Dr. Stone the whole world was suddenly petrified and 3,700 years later two teenagers awaken and try to turn humanity back from stone and kick-start civilization. Problem is sometimes when you resurrect a person his ideals may not be yours as they resurrect a boy with murderous notions. Will they save all of humanity or will he crumble all their hopes and dreams? For more recommendations have a look at our Top 10 Summer 2019 Anime Recommendations.
When the science fiction movie Akira was released in 1988 is was a groundbreaking masterpiece for anime and science fiction in animation movies. It was based on the Akira manga which was unfinished. The manga started in 1982 and finished in 1990, two years after the anime movie. Director Katsuhiro Otomo felt his adaptation was a failure, despite it's roaring success because of its major budget and time constrains.
Thus director Katsuhiro Otomo has announced a new anime series based on his original Akira manga which will incorporate events from the manga in its entirety. Sunrise is also launching an Akira 4K remaster of the original movie in Japan on April 24th, 2020. We will reveal more about the anime series as more detail is revealed.
Otomo also has an unrelated movie up his sleaves called Orbital Era which takes place in the near-future on a space colony under construction. This movie is written, directed as well as designed by Otoma. It could be just as epic as his previous feature-length movies, Akira and Steamboy (2004).
Picross: Lord of the Nazarick
Nintendo and Jupiter is well known for crossing over into anime with their Picross game such as in the case of Pokémon, Sanrio and Kemono Friends. Now fans of both Picross and the anime Overlord has their turn with Picross: Lord of the Nazarick. This crossover tie-in will be more elaborate as players will be able to solve the puzzles as Ainz Ooal Gown, as well as his nine followers while reliving their memories through images. High-resolution images from Overlord can also be unlocked in the gallery. This game was released at the Nintendo Switch eShop globally on July 25th.
The Overlord anime ran for 13 episodes in 2015 and was a massive hit. It plays off in the year 2137 and tells the tale of Momonga. When his favourite game, Yggdrasil is shut down he decides to not log out of it. NPCs starts to feel emotions and other changes start to occur in this world. Momonga decides to take over this new world. It was followed by a second and third season in 2018.
The Kyoto Animation Tragedy
Middle July on a Thursday at 10:35 AM a horrible tragedy at Kyoto Animation studios left at least 35 people deceased and 34 (arsonist included) injured. A 41-year-old man busted into the offices, setting the famous anime studio on fire. About 70 people was believed to be at work in the building. According to witnesses the arsonist screamed: "Die!" as he set the offices ablaze. The death toll is so far the highest for an arson event since 1989 according to the police. The arson attack had the whole anime community in Japan as well as globally in shock. It has also been confirmed that the arsonist has admitted to setting the fire. According to media sources the arsonist has a criminal record and has been known as a troublemaker.
In an interview with the company's president Hideaki Hatta, he said, "This has just broken our hearts. What's the use of resorting to violence?" Twitter exploded with tweets from across the globe of anime fanatiks sending messages of condolences for the the victims and their families, offering prayers in English and Japanese and expressing their shock. The Prime Minister of Japan, Shinzo Abe also tweeted saying, "So many people were killed or injured. It's so appalling I can't find the right words. I pray for … their souls."
Kyoto Animation's work has touched a lot of hearts with their anime. Some of their most famous anime series include Full Metal Panic? Fumoffu, Clannad, K-On!, Miss Kobayashi's Dragon Maid and Violet Evergarden.
Sentai Filmworks, a U.S. based anime licensing company started a crowdfunding campaign to aid Kyoto Animation, and as of Thursday evening on August 01, the fund has already raised a total of $2,370,920. If you wish to contribute please follow this link: Help KyoAni Heal
AnimeFanatika wishes to express our condolences and offer our prayers to the victims of the Kyoto Animation arson.
We live in a world where depression and anger can lead to a life of crime, suicide and death. We we feel negative we feel like there is no-one to talk to. Problems can be solved only if we are willing to communicate and there are a lot of places where trained professionals can help us deal with problems of the heart and soul. Happy Happy Vegan is a website that created a page on their website named Mental Health Helplines, Suicide Hotlines, And Depression Advice Centers that lists numbers for mental health helplines, hotlines and centres in every country you can think off from Argentina to Venezuela. If you are in need of counselling or know of someone in need please use this list and reach out. You are important. Never give up on getting help. Here is the link Mental Health Helplines, Suicide Hotlines, And Depression Advice Centers
About Happy Happy Vegan in their own words:
"Happy Happy Vegan was created because we felt that there was a need for an easy-to-understand vegan blog that wasn't solely about recipes. One that also incorporated more about the other aspects of veganism, too.
Our aim is to demystify the vegan lifestyle and provide readers of the HHV blog with solid, actionable advice that will help you along every step of your plant-based journey."
Kawaii Kulture: Mountain Day
On August 11th it is Mountain Day in Japan, an apt holiday for a country of which 73% is mountainous, that has a mountain range running through each of its main islands. The highest mountain of Japan is Mount Fuji, with an elevation of 12, 388 feet (that is 3,776 meters). We have discussed Mount Fuji before in it's own bento but there is a lot more mountain and mountain lore to uncover about Japan. Mount Fuji is one of the Three Holy Mountains of Japan, a trio of mountains most revered by the tradition in Japan, the other two mountains being Mount Haku (The White Mountain, which is best know for its UNESCO World Heritage site, Shirakawago) and Mount Tate, known for its onsen and the cobalt blue waters of Mikurigaike).
Mount Haku, commonly referred to as Hakusan, is a dormant volcano, which was estimated to be first active 300,000 to 400,000 years ago and its most recent eruption was in 1659. Hakusan is the westernmost mountain in Japan, and is over 2,000 m (6, 562 ft) in height. It is located on the borders of Gifu and Ishikawa prefectures in Japan. Thanks to the dormant volcano, the mountain is also well-known for its many onsen. Mount Tate, also known commonly as Tateyama, is located in the southeastern are of Toyama Prefecture. The mountain is the source for the Hayatsuki as well as Tsurugisawa rivers, which each flows to the Sea of Japan.
There are hundreds more mountains each unique but one mountain deserves an honourble mention: Mount Asama. This mountain is an active complex volcano in central Honshū, which is the main island of Japan. It is the most active on Honshū and has been classified by the Japan Meteorological Agency as a rank A. It stands 2,568 meters (8, 425 feet) above sea level, bordering the Gunma and Nagano prefectures. Japanese history is riddled with confirmed volcanic eruptions. Here is examples of eruptions in the last 100 years: 2009, 2008, 2004, 2003, 1995, 1990, 1983, 1982, 1973, 1965, 1961, 1958–59, 1953–55, 1952, 1952, 1950–51, 1949, 1947, 1946, 1944–45, 1938–42, 1935–37, 1934, 1934, 1933, 1931–32, 1930, 1929, 1929, 1927–28, 1924, 1922, 1920–21, and 1919. These eruptions are but drops in a melting bucket of history. The real reason why Mount Asama is our honourable mention is because it served as the backdrop to Japan's first colour film, Carmen Comes Home and in the anime Neon Genesis Evangelion, the Eighth Angel was located inside Mount Asama.
We share with you two brilliant videos, in celebration of Japan's majestic mountains. First off we will visit Mount Fuji and then we will be 'Escaping to a Secluded Japanese Mountain' with two gentlemen experiencing Japanese cuisine and becoming one with a mountain.
Escaping to a Secluded Japanese Mountain
Spread the Word & Word of the Month: Mountain
The word for this month is Yama which means 'Mountain' in Japanese. Here are some examples of how to use 'Yama' in Japanese sentences.
Yama desu – it is a mountain
Are ha yama desu – that (over there) is a mountain
Nihon ni yama ga arimasu – There are mountains in Japan
Yama ha ookiku nai desu – The mountain is not big.
Recipes of the month: Mountain Cuisine
Climbing mountains can work up voracious appetites and we decided to explore the information highway to see what and where one can eat on a mountain like Mount Fuji. We came across an interesting article called 15 Must Try Restaurants When Visiting Mount Fuji. The article is definitively worth a read on cuisine found near and around the mountain. One restaurant called Arubi -Tei- were praised for their Chicken Katsu and we share a recipe video from YouTube channel TabiEats, where the chef and his mom show us how to make Chicken Katsu easily.
We also include a video of how to make carpaccio with flounder and dill inspired by the 'Escaping to a Secluded Japanese Mountain' we shared in Kawaii Kulture, as it is one of the meals they featured on their trip to the mountain.
Easy Chicken Katsu
How to make carpaccio with flounder and dill
Top 5 Anime from Kyoto Animation
What happened at Kyoto Animation is a huge loss for the world of anime. In honour of this brilliant anime house we would like to share our top five favourite anime from Kyoto Animation. Their work touched a lot of people and are favourite series and movies to many.
Full Metal Panic? Fumoffu
Birthday of the month: Seiya Kanie
Our birthday of the month is Seiya Kanie from the Kyoto Animation series, Amagi Brilliant Park. His birth-date is August 10th making Kanie a Leo. His first appearance is in episode 1 of the anime, Chapter 1 or the manga and volume 1 or the light novel series. He is known as a sharp-witted, coordinated and intelligent young man. One day a beautiful and mysterious girl named Isuzu Sento transferred to his school. Sento threatens him at gun point to accompany her to an amusement park on a date. At the end of the date he meets a girl called Lafita Fleuranza. She asks him to be the manager of the amusement park called Amagi Brilliant Park and bring a revival to the park as the park is going under.
We also learn that he was a popular child actor, five years prior to the start of the anime and his stage name was Seiya Kodama. And in episode 1 it's confirmed through a flashback that he actually share a childhood connection with Latifa. Kanie shared his birth-month with Faye Valentine from Cowboy Bebop on the 14th and Temari from the Naruto franchise on the 23rd.
AMV of the Month: Full Metal Panic! Invisible Victory
This month we bring you an AMV featuring footage of Full Metal Panic! Invisible Victory and the song is Foo Fighters' The Pretender. Enjoy the AMV!
This month's challenge is Full Metal Panic? Fumoffu, which is an anime from Kyoto Animation and a companion series to Full Metal Panic and Full Metal Panic The Second Raid. It is not as serious as Full Metal Panic and thus is a Science Fiction Adventure with a lighter tone. It emphasizes the high school romantic comedy aspects of Full Metal Panic with a bit of crude humour mixed into it. The anime was directed by Yasuhiro Takemoto (Amagi Brilliant Park) and was produced at Kyoto Animation, replacing Gonzo as series producer. It is also the first animation television show from Kyoto Animation. We want to feature this series as challenge as a homage to Kyoto Animation. It may be part of the Full Metal Panic franchise but there is little plot continuity between this and the original series. Most episodes are stand-alone.
Very loosely continuing the story from Full Metal Panic the story takes place half a year after the series. Sousuke Sagara is tasked with protecting a valuable target Kaname Chidori and has to juggle that with trying to fit in with the society of Jindai High School. He employs interesting technology and combat training facing thugs and gangsters set on kidnapping and torturing Chidori. This series also focus on the bond formed between him and his charge.
Sci-Fi Anime Day
Come and park your mecha at Cool Runnings on August 17th as we enjoy a Sci-Fi Anime Day. We're going to screen classics like Robotech, Macross, The Vision of Escaflowne and Gundam and more recent series like Bubuki/Buranki and Eureka Seven. Domo arigato Mister Roboto, let us blast off again and space travel boldly to where maybe no of us has gone before.
Cool Runnings has food and drinks specials on the day and Yum-Mee treats will be sponsoring popcorn to enjoy during the screenings. Entrance is free! Grab a friend and come join us for a super sugoi day.
When: August 17th
Place: Cool Runnings, Centurion (120 Ivan Str , Hennops Park Centurion, Pretoria) The anime day is at the back of the club in the anime screening room
Be sure to look at our event page on our website as we may update with more news on events.
A Silent Voice,
Akira,
Amagi Brilliant Park,
Cop Craft,
Dr. Stone,
Foo Fighters,
Full Metal Panic! Invisible Victory,
Full Metal Panic? Fumoffu,
Kyoto Animation,
Mount Fuji,
Mountain Day,
Overlord,
Picross,
Picross: Lord of the Nazarick,


In the center of town a few minutes from supermarkets, entertainment, meals, and travel destinations.
Each room has its own bathroom. We also have hammocks for lounging.
Open Kitchen from 7:30 am until 9:30 pm.
Private room U$ 16.00 dollars.
From La Recolección church 1 block east, 1/2 block south.


Ok, so in a case of clearly getting what you paid for, my experience with Fiverr is decidedly mixed.
I am not too embarrassed to say that I was disappointed with the results. I am embarrassed enough to NOT display what I ended up paying $10 for.
So what did I do? In the ultimate display of my cheapness, I used a FREE online vector editing system that I like: Aviary.
I downloaded the font and was able to use Aviary to create a simple vector file, which I imagine is somewhat akin to a FREE version of Photoshop online.
From there, I created several versions including the one you see if you scroll to the top of the page using a GREAT online photo editor: Lunapic.
Back to Fiverr. While I was disappointed with my results, I was not disappointed in the system.
Using Paypal in such a manner for easily completed tasks is a great idea. I can see other one-time uses making it a great option but when you want something done graphically as any designer will tell you "don't skimp."
Or at least, consider doing it yourself.


text:
Mayor Stoney Announces New Director of Citizen Service and Response
Mayor Levar M. Stoney today announced the appointment of Peter Breil as the city's first director of the Department of Citizen Service and Response.
"The Department of Citizen Service and Response was recently created to improve service delivery and enhance citizen engagement, and Peter's background and experience make him the right person for the job," said Mayor Stoney. "I am looking forward to the ideas and leadership Peter will bring to this department to help better connect City Hall to city residents."
A Richmond resident for the last 11 years, Breil brings a wealth of experience to the new department, including over 15 years at Capital One and Time Warner Cable, where he served in various leadership roles. He has managed a contact call center and developed customer contact strategies to improve processes and performance.
Breil's knowledge in developing operational metrics, reporting and data requirements will be critical in his leadership of the new department, which will oversee …
Mayor Stoney Announces New Director of Citizen Ser...