11678739314

Committed 05 Nov 2024 06:25AM UTC coverage: 64.664% (+0.009%) from 64.655%

Build # 11678739314

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #14807 from omoerbeek/rec-packetid-ref

rec: drop ref in mtasker when it is no longer needed

Run Details

37311 of 88528 branches covered (42.15%)

Branch coverage included in aggregate %.

63 of 68 new or added lines in 2 files covered. (92.65%)

61 existing lines in 13 files now uncovered.

125391 of 163084 relevant lines covered (76.89%)

4554390.28 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.45

/pdns/recursordist/test-mtasker.cc

#ifndef BOOST_TEST_DYN_LINK
#define BOOST_TEST_DYN_LINK
#endif

#define BOOST_TEST_NO_MAIN

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <boost/test/unit_test.hpp>
#include "mtasker.hh"
#include <fcntl.h>

BOOST_AUTO_TEST_SUITE(mtasker_cc)

static int g_result;

static void doSomething(void* p)
{
  MTasker<>* mt = reinterpret_cast<MTasker<>*>(p);
  int i = 12, o = 0;
  if (mt->waitEvent(i, &o) == 1)
    g_result = o;
}

BOOST_AUTO_TEST_CASE(test_Simple)
{
  MTasker<> mt;
  mt.makeThread(doSomething, &mt);
  struct timeval now;
  gettimeofday(&now, 0);
  bool first = true;
  int o = 24;
  for (;;) {
    while (mt.schedule(now)) {
    }

    if (first) {
      mt.sendEvent(12, &o);
      first = false;
    }
    if (mt.noProcesses())
      break;
  }
  BOOST_CHECK_EQUAL(g_result, o);
  vector<int> events;
  mt.getEvents(events);
  BOOST_CHECK_EQUAL(events.size(), 0U);
}

struct MTKey
{
  int key;
  shared_ptr<int> ptr;

  bool operator<(const MTKey& /* b */) const
  {
    // We don't want explicit PacketID compare here, but always via predicate class below
    assert(0); // NOLINT: lib
  }
};

struct MTKeyCompare
{
  bool operator()(const std::shared_ptr<MTKey>& lhs, const std::shared_ptr<MTKey>& rhs) const
  {
    return lhs->key < rhs->key;
  }
};

using KeyMT_t = MTasker<std::shared_ptr<MTKey>, int, MTKeyCompare>;

// Test the case of #14807
static void doSomethingKey(void* ptr)
{
  auto* multiTasker = reinterpret_cast<KeyMT_t*>(ptr); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
  auto key = std::make_shared<MTKey>();
  key->key = 12;
  key->ptr = std::make_shared<int>(13);
  BOOST_CHECK_EQUAL(key.use_count(), 1U);
  BOOST_CHECK_EQUAL(key->ptr.use_count(), 1U);
  int value = 0;
  if (multiTasker->waitEvent(key, &value) == 1) {
    g_result = value;
  }
  BOOST_CHECK_EQUAL(key.use_count(), 1U);
  BOOST_CHECK_EQUAL(key->key, 12);
  BOOST_REQUIRE(key->ptr != nullptr);
  BOOST_CHECK_EQUAL(key->ptr.use_count(), 1U);
  BOOST_CHECK_EQUAL(*key->ptr, 13);
}

BOOST_AUTO_TEST_CASE(test_SharedPointer)
{
  g_result = 0;
  KeyMT_t multiTasker;
  multiTasker.makeThread(doSomethingKey, &multiTasker);
  timeval now{};
  gettimeofday(&now, nullptr);
  bool first = true;
  int value = 24;
  auto key = std::make_shared<MTKey>();
  key->key = 12;
  key->ptr = std::make_shared<int>(1);
  BOOST_CHECK_EQUAL(key->ptr.use_count(), 1U);
  for (;;) {
    while (multiTasker.schedule(now)) {
    }

    if (first) {
      multiTasker.sendEvent(key, &value);
      BOOST_CHECK_EQUAL(key.use_count(), 1U);
      BOOST_CHECK_EQUAL(key->ptr.use_count(), 1U);
      first = false;
    }
    if (multiTasker.noProcesses()) {
      break;
    }
  }
  BOOST_CHECK_EQUAL(g_result, value);
  vector<std::shared_ptr<MTKey>> events;
  multiTasker.getEvents(events);
  BOOST_CHECK_EQUAL(events.size(), 0U);
  BOOST_CHECK_EQUAL(key.use_count(), 1U);
  BOOST_CHECK_EQUAL(key->ptr.use_count(), 1U);
  BOOST_CHECK_EQUAL(*key->ptr, 1);
}

static const size_t stackSize = 8 * 1024;
static const size_t headroom = 1536; // Decrease to hit stackoverflow

static void doAlmostStackoverflow(void* arg)
{
  auto* mt = reinterpret_cast<MTasker<>*>(arg);
  int localvar[stackSize / sizeof(int) - headroom]; // experimentally derived headroom
  localvar[0] = 0;
  localvar[sizeof(localvar) / sizeof(localvar[0]) - 1] = 12;
  if (mt->waitEvent(localvar[sizeof(localvar) / sizeof(localvar[0]) - 1], &localvar[0]) == 1) {
    g_result = localvar[0];
  }
}

BOOST_AUTO_TEST_CASE(test_AlmostStackOverflow)
{
  MTasker<> mt(stackSize);
  mt.makeThread(doAlmostStackoverflow, &mt);
  struct timeval now;
  gettimeofday(&now, 0);
  bool first = true;
  int o = 25;
  for (;;) {
    while (mt.schedule(now)) {
      ;
    }
    if (first) {
      mt.sendEvent(12, &o);
      first = false;
    }
    if (mt.noProcesses()) {
      break;
    }
  }
  BOOST_CHECK_EQUAL(g_result, o);
}

static void willThrow(void* /* p */)
{
  throw std::runtime_error("Help!");
}

BOOST_AUTO_TEST_CASE(test_MtaskerException)
{
  BOOST_CHECK_THROW({
    MTasker<> mt;
    mt.makeThread(willThrow, 0);
    struct timeval now;
    now.tv_sec = now.tv_usec = 0;

    for (;;) {
      mt.schedule(now);
    }
  },
                    std::exception);
}

BOOST_AUTO_TEST_SUITE_END()

1	#ifndef BOOST_TEST_DYN_LINK
2	#define BOOST_TEST_DYN_LINK
3	#endif
4
5	#define BOOST_TEST_NO_MAIN
6
7	#ifdef HAVE_CONFIG_H
8	#include "config.h"
9	#endif
10	#include <boost/test/unit_test.hpp>
11	#include "mtasker.hh"
12	#include <fcntl.h>
13
14	BOOST_AUTO_TEST_SUITE(mtasker_cc)
15
16	static int g_result;
17
18	static void doSomething(void* p)
19	{	2✔
20	MTasker<>* mt = reinterpret_cast<MTasker<>*>(p);	2✔
21	int i = 12, o = 0;	2✔
22	if (mt->waitEvent(i, &o) == 1)	2!
23	g_result = o;	2✔
24	}	2✔
25
26	BOOST_AUTO_TEST_CASE(test_Simple)
27	{	2✔
28	MTasker<> mt;	2✔
29	mt.makeThread(doSomething, &mt);	2✔
30	struct timeval now;	2✔
31	gettimeofday(&now, 0);	2✔
32	bool first = true;	2✔
33	int o = 24;	2✔
34	for (;;) {	4✔
35	while (mt.schedule(now)) {	8✔
36	}	4✔
37
38	if (first) {	4✔
39	mt.sendEvent(12, &o);	2✔
40	first = false;	2✔
41	}	2✔
42	if (mt.noProcesses())	4✔
43	break;	2✔
44	}	4✔
45	BOOST_CHECK_EQUAL(g_result, o);	2✔
46	vector<int> events;	2✔
47	mt.getEvents(events);	2✔
48	BOOST_CHECK_EQUAL(events.size(), 0U);	2✔
49	}	2✔
50
51	struct MTKey
52	{
53	int key;
54	shared_ptr<int> ptr;
55
56	bool operator<(const MTKey& /* b */) const
NEW 57	{	×
NEW 58	// We don't want explicit PacketID compare here, but always via predicate class below	×
NEW 59	assert(0); // NOLINT: lib	×
NEW 60	}	×
61	};
62
63	struct MTKeyCompare
64	{
65	bool operator()(const std::shared_ptr<MTKey>& lhs, const std::shared_ptr<MTKey>& rhs) const
66	{	8✔
67	return lhs->key < rhs->key;	8✔
68	}	8✔
69	};
70
71	using KeyMT_t = MTasker<std::shared_ptr<MTKey>, int, MTKeyCompare>;
72
73	// Test the case of #14807
74	static void doSomethingKey(void* ptr)
75	{	2✔
76	auto* multiTasker = reinterpret_cast<KeyMT_t*>(ptr); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)	2✔
77	auto key = std::make_shared<MTKey>();	2✔
78	key->key = 12;	2✔
79	key->ptr = std::make_shared<int>(13);	2✔
80	BOOST_CHECK_EQUAL(key.use_count(), 1U);	2✔
81	BOOST_CHECK_EQUAL(key->ptr.use_count(), 1U);	2✔
82	int value = 0;	2✔
83	if (multiTasker->waitEvent(key, &value) == 1) {	2!
84	g_result = value;	2✔
85	}	2✔
86	BOOST_CHECK_EQUAL(key.use_count(), 1U);	2✔
87	BOOST_CHECK_EQUAL(key->key, 12);	2✔
88	BOOST_REQUIRE(key->ptr != nullptr);	2✔
89	BOOST_CHECK_EQUAL(key->ptr.use_count(), 1U);	2✔
90	BOOST_CHECK_EQUAL(*key->ptr, 13);	2✔
91	}	2✔
92
93	BOOST_AUTO_TEST_CASE(test_SharedPointer)
94	{	2✔
95	g_result = 0;	2✔
96	KeyMT_t multiTasker;	2✔
97	multiTasker.makeThread(doSomethingKey, &multiTasker);	2✔
98	timeval now{};	2✔
99	gettimeofday(&now, nullptr);	2✔
100	bool first = true;	2✔
101	int value = 24;	2✔
102	auto key = std::make_shared<MTKey>();	2✔
103	key->key = 12;	2✔
104	key->ptr = std::make_shared<int>(1);	2✔
105	BOOST_CHECK_EQUAL(key->ptr.use_count(), 1U);	2✔
106	for (;;) {	4✔
107	while (multiTasker.schedule(now)) {	8✔
108	}	4✔
109
110	if (first) {	4✔
111	multiTasker.sendEvent(key, &value);	2✔
112	BOOST_CHECK_EQUAL(key.use_count(), 1U);	2✔
113	BOOST_CHECK_EQUAL(key->ptr.use_count(), 1U);	2✔
114	first = false;	2✔
115	}	2✔
116	if (multiTasker.noProcesses()) {	4✔
117	break;	2✔
118	}	2✔
119	}	4✔
120	BOOST_CHECK_EQUAL(g_result, value);	2✔
121	vector<std::shared_ptr<MTKey>> events;	2✔
122	multiTasker.getEvents(events);	2✔
123	BOOST_CHECK_EQUAL(events.size(), 0U);	2✔
124	BOOST_CHECK_EQUAL(key.use_count(), 1U);	2✔
125	BOOST_CHECK_EQUAL(key->ptr.use_count(), 1U);	2✔
126	BOOST_CHECK_EQUAL(*key->ptr, 1);	2✔
127	}	2✔
128
129	static const size_t stackSize = 8 * 1024;
130	static const size_t headroom = 1536; // Decrease to hit stackoverflow
131
132	static void doAlmostStackoverflow(void* arg)
133	{	2✔
134	auto* mt = reinterpret_cast<MTasker<>*>(arg);	2✔
135	int localvar[stackSize / sizeof(int) - headroom]; // experimentally derived headroom	2✔
136	localvar[0] = 0;	2✔
137	localvar[sizeof(localvar) / sizeof(localvar[0]) - 1] = 12;	2✔
138	if (mt->waitEvent(localvar[sizeof(localvar) / sizeof(localvar[0]) - 1], &localvar[0]) == 1) {	2!
139	g_result = localvar[0];	2✔
140	}	2✔
141	}	2✔
142
143	BOOST_AUTO_TEST_CASE(test_AlmostStackOverflow)
144	{	2✔
145	MTasker<> mt(stackSize);	2✔
146	mt.makeThread(doAlmostStackoverflow, &mt);	2✔
147	struct timeval now;	2✔
148	gettimeofday(&now, 0);	2✔
149	bool first = true;	2✔
150	int o = 25;	2✔
151	for (;;) {	4✔
152	while (mt.schedule(now)) {	8✔
153	;	4✔
154	}	4✔
155	if (first) {	4✔
156	mt.sendEvent(12, &o);	2✔
157	first = false;	2✔
158	}	2✔
159	if (mt.noProcesses()) {	4✔
160	break;	2✔
161	}	2✔
162	}	4✔
163	BOOST_CHECK_EQUAL(g_result, o);	2✔
164	}	2✔
165
166	static void willThrow(void* /* p */)
167	{	2✔
168	throw std::runtime_error("Help!");	2✔
169	}	2✔
170
171	BOOST_AUTO_TEST_CASE(test_MtaskerException)
172	{	2✔
173	BOOST_CHECK_THROW({	2✔
174	MTasker<> mt;	2✔
175	mt.makeThread(willThrow, 0);	2✔
176	struct timeval now;	2✔
177	now.tv_sec = now.tv_usec = 0;	2✔
178
179	for (;;) {	2✔
180	mt.schedule(now);	2✔
181	}	2✔
182	},	2✔
183	std::exception);	2✔
184	}	2✔
185
186	BOOST_AUTO_TEST_SUITE_END()

PowerDNS / pdns / 11678739314

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous