GTEST模拟功能如何模仿两个功能之间的比赛？

Question

我有一个称为调整大小的函数，该功能会更改共享对象的大小。我有另一个称为getize的函数，该功能获得该共享对象的大小。我想在需要延迟特定的调整大小的延迟的地方介绍一场竞赛，而我想调整大小的特定点才能睡觉，并在该特定时间进行调用并获得运行。有什么办法可以使用GTEST模拟设施来实现这一目标？

Resize(int newsize) {
  resizeint(newsize);
  // Want to introduce delay here and call Getsize().
  // This will simulate cache inconsistency.
  // Getsize() will return old size even though shared object is resized.
  writenewsizetocache();
}
int Getsize() {
  int size = readsizefromlocalcahce();
  return size;
}

Answer 1

一种方法是将您的功能包裹在类sizewrapper中，并引入一个私人变量，例如resize_delay _，模仿您想要的延迟并在构造函数中分配给它。

然后，您可以将sizewrapper实例化，以使您不想要该延迟的情况以及要插入延迟的情况的正数。

请参阅下面：

// Global size, representing the cache.
// Normally, this should be atomic or protected by mutex.
int global_size;

class SizeWrapper {
 private:
  void resizeint(int newsize) { temporary_size_ = newsize; }
  void writenewsizetocache() { global_size = temporary_size_; }
  int readsizefromlocalcahce() { return global_size; }
  int temporary_size_;
  int resize_delay_;

 public:
  SizeWrapper(int resize_delay)
      : resize_delay_(resize_delay), temporary_size_(0) {}
  void Resize(int newsize) {
    resizeint(newsize);
    // Want to introduce delay here and call Getsize().
    // This will simulate cache inconsistency.
    // Getsize() will return old size even though shared object is resized.
    if (resize_delay_ > 0) {
      std::this_thread::sleep_for(std::chrono::milliseconds(resize_delay_));
    }

    writenewsizetocache();
  }

  int Getsize() {
    int size;
    size = readsizefromlocalcahce();
    return size;
  }
};

TEST(SizeWrapperTest, GetSizeBeforeResize) {
  global_size = 0;

  int resize_write_value = 10;
  int getsize_read_value = 0;

  // getsize delay is larger than resize delay.
  const int resize_delay = 100;
  const int getsize_delay = 200;

  SizeWrapper size_wrapper(resize_delay);

  auto t1 = std::thread([&size_wrapper, resize_write_value] {
    size_wrapper.Resize(resize_write_value);
  });

  auto t2 = std::thread([&size_wrapper, &getsize_read_value, getsize_delay] {
    // Read the size with some delay.
    std::this_thread::sleep_for(std::chrono::milliseconds(getsize_delay));
    getsize_read_value = size_wrapper.Getsize();
  });

  t1.join();
  t2.join();

  // Thre read and write values are equal.
  EXPECT_EQ(getsize_read_value, resize_write_value);
}

TEST(SizeWrapperTest, GetSizeAfterResize) {
  global_size = 0;

  int resize_write_value = 10;
  int getsize_read_value = 0;

  // getsize delay is smaller than resize delay.
  const int resize_delay = 200;
  const int getsize_delay = 100;

  SizeWrapper size_wrapper(resize_delay);

  auto t1 = std::thread([&size_wrapper, resize_write_value] {
    size_wrapper.Resize(resize_write_value);
  });

  auto t2 = std::thread([&size_wrapper, &getsize_read_value, getsize_delay] {
    std::this_thread::sleep_for(std::chrono::milliseconds(getsize_delay));
    getsize_read_value = size_wrapper.Getsize();
  });

  t1.join();
  t2.join();

  // Thre read and write values are NOT equal.
  EXPECT_NE(getsize_read_value, resize_write_value);
}

请参见此实时示例： https：//godbolt.org/z/yq9pmokds