tor-browser

test_instance_tracker.h (8913B)

---

// Copyright 2017 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
#define ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_

#include <cstdlib>
#include <ostream>

#include "absl/types/compare.h"

namespace absl {
ABSL_NAMESPACE_BEGIN
namespace test_internal {

// A type that counts number of occurrences of the type, the live occurrences of
// the type, as well as the number of copies, moves, swaps, and comparisons that
// have occurred on the type. This is used as a base class for the copyable,
// copyable+movable, and movable types below that are used in actual tests. Use
// InstanceTracker in tests to track the number of instances.
class BaseCountedInstance {
public:
 explicit BaseCountedInstance(int x) : value_(x) {
   ++num_instances_;
   ++num_live_instances_;
 }
 BaseCountedInstance(const BaseCountedInstance& x)
     : value_(x.value_), is_live_(x.is_live_) {
   ++num_instances_;
   if (is_live_) ++num_live_instances_;
   ++num_copies_;
 }
 BaseCountedInstance(BaseCountedInstance&& x)
     : value_(x.value_), is_live_(x.is_live_) {
   x.is_live_ = false;
   ++num_instances_;
   ++num_moves_;
 }
 ~BaseCountedInstance() {
   --num_instances_;
   if (is_live_) --num_live_instances_;
 }

 BaseCountedInstance& operator=(const BaseCountedInstance& x) {
   value_ = x.value_;
   if (is_live_) --num_live_instances_;
   is_live_ = x.is_live_;
   if (is_live_) ++num_live_instances_;
   ++num_copies_;
   return *this;
 }
 BaseCountedInstance& operator=(BaseCountedInstance&& x) {
   value_ = x.value_;
   if (is_live_) --num_live_instances_;
   is_live_ = x.is_live_;
   x.is_live_ = false;
   ++num_moves_;
   return *this;
 }

 bool operator==(const BaseCountedInstance& x) const {
   ++num_comparisons_;
   return value_ == x.value_;
 }

 bool operator!=(const BaseCountedInstance& x) const {
   ++num_comparisons_;
   return value_ != x.value_;
 }

 bool operator<(const BaseCountedInstance& x) const {
   ++num_comparisons_;
   return value_ < x.value_;
 }

 bool operator>(const BaseCountedInstance& x) const {
   ++num_comparisons_;
   return value_ > x.value_;
 }

 bool operator<=(const BaseCountedInstance& x) const {
   ++num_comparisons_;
   return value_ <= x.value_;
 }

 bool operator>=(const BaseCountedInstance& x) const {
   ++num_comparisons_;
   return value_ >= x.value_;
 }

 absl::weak_ordering compare(const BaseCountedInstance& x) const {
   ++num_comparisons_;
   return value_ < x.value_
              ? absl::weak_ordering::less
              : value_ == x.value_ ? absl::weak_ordering::equivalent
                                   : absl::weak_ordering::greater;
 }

 int value() const {
   if (!is_live_) std::abort();
   return value_;
 }

 friend std::ostream& operator<<(std::ostream& o,
                                 const BaseCountedInstance& v) {
   return o << "[value:" << v.value() << "]";
 }

 // Implementation of efficient swap() that counts swaps.
 static void SwapImpl(
     BaseCountedInstance& lhs,    // NOLINT(runtime/references)
     BaseCountedInstance& rhs) {  // NOLINT(runtime/references)
   using std::swap;
   swap(lhs.value_, rhs.value_);
   swap(lhs.is_live_, rhs.is_live_);
   ++BaseCountedInstance::num_swaps_;
 }

private:
 friend class InstanceTracker;

 int value_;

 // Indicates if the value is live, ie it hasn't been moved away from.
 bool is_live_ = true;

 // Number of instances.
 static int num_instances_;

 // Number of live instances (those that have not been moved away from.)
 static int num_live_instances_;

 // Number of times that BaseCountedInstance objects were moved.
 static int num_moves_;

 // Number of times that BaseCountedInstance objects were copied.
 static int num_copies_;

 // Number of times that BaseCountedInstance objects were swapped.
 static int num_swaps_;

 // Number of times that BaseCountedInstance objects were compared.
 static int num_comparisons_;
};

// Helper to track the BaseCountedInstance instance counters. Expects that the
// number of instances and live_instances are the same when it is constructed
// and when it is destructed.
class InstanceTracker {
public:
 InstanceTracker()
     : start_instances_(BaseCountedInstance::num_instances_),
       start_live_instances_(BaseCountedInstance::num_live_instances_) {
   ResetCopiesMovesSwaps();
 }
 ~InstanceTracker() {
   if (instances() != 0) std::abort();
   if (live_instances() != 0) std::abort();
 }

 // Returns the number of BaseCountedInstance instances both containing valid
 // values and those moved away from compared to when the InstanceTracker was
 // constructed
 int instances() const {
   return BaseCountedInstance::num_instances_ - start_instances_;
 }

 // Returns the number of live BaseCountedInstance instances compared to when
 // the InstanceTracker was constructed
 int live_instances() const {
   return BaseCountedInstance::num_live_instances_ - start_live_instances_;
 }

 // Returns the number of moves on BaseCountedInstance objects since
 // construction or since the last call to ResetCopiesMovesSwaps().
 int moves() const { return BaseCountedInstance::num_moves_ - start_moves_; }

 // Returns the number of copies on BaseCountedInstance objects since
 // construction or the last call to ResetCopiesMovesSwaps().
 int copies() const {
   return BaseCountedInstance::num_copies_ - start_copies_;
 }

 // Returns the number of swaps on BaseCountedInstance objects since
 // construction or the last call to ResetCopiesMovesSwaps().
 int swaps() const { return BaseCountedInstance::num_swaps_ - start_swaps_; }

 // Returns the number of comparisons on BaseCountedInstance objects since
 // construction or the last call to ResetCopiesMovesSwaps().
 int comparisons() const {
   return BaseCountedInstance::num_comparisons_ - start_comparisons_;
 }

 // Resets the base values for moves, copies, comparisons, and swaps to the
 // current values, so that subsequent Get*() calls for moves, copies,
 // comparisons, and swaps will compare to the situation at the point of this
 // call.
 void ResetCopiesMovesSwaps() {
   start_moves_ = BaseCountedInstance::num_moves_;
   start_copies_ = BaseCountedInstance::num_copies_;
   start_swaps_ = BaseCountedInstance::num_swaps_;
   start_comparisons_ = BaseCountedInstance::num_comparisons_;
 }

private:
 int start_instances_;
 int start_live_instances_;
 int start_moves_;
 int start_copies_;
 int start_swaps_;
 int start_comparisons_;
};

// Copyable, not movable.
class CopyableOnlyInstance : public BaseCountedInstance {
public:
 explicit CopyableOnlyInstance(int x) : BaseCountedInstance(x) {}
 CopyableOnlyInstance(const CopyableOnlyInstance& rhs) = default;
 CopyableOnlyInstance& operator=(const CopyableOnlyInstance& rhs) = default;

 friend void swap(CopyableOnlyInstance& lhs, CopyableOnlyInstance& rhs) {
   BaseCountedInstance::SwapImpl(lhs, rhs);
 }

 static bool supports_move() { return false; }
};

// Copyable and movable.
class CopyableMovableInstance : public BaseCountedInstance {
public:
 explicit CopyableMovableInstance(int x) : BaseCountedInstance(x) {}
 CopyableMovableInstance(const CopyableMovableInstance& rhs) = default;
 CopyableMovableInstance(CopyableMovableInstance&& rhs) = default;
 CopyableMovableInstance& operator=(const CopyableMovableInstance& rhs) =
     default;
 CopyableMovableInstance& operator=(CopyableMovableInstance&& rhs) = default;

 friend void swap(CopyableMovableInstance& lhs, CopyableMovableInstance& rhs) {
   BaseCountedInstance::SwapImpl(lhs, rhs);
 }

 static bool supports_move() { return true; }
};

// Only movable, not default-constructible.
class MovableOnlyInstance : public BaseCountedInstance {
public:
 explicit MovableOnlyInstance(int x) : BaseCountedInstance(x) {}
 MovableOnlyInstance(MovableOnlyInstance&& other) = default;
 MovableOnlyInstance& operator=(MovableOnlyInstance&& other) = default;

 friend void swap(MovableOnlyInstance& lhs, MovableOnlyInstance& rhs) {
   BaseCountedInstance::SwapImpl(lhs, rhs);
 }

 static bool supports_move() { return true; }
};

}  // namespace test_internal
ABSL_NAMESPACE_END
}  // namespace absl

#endif  // ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_