• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

thetic / mutiny / 24437497481

15 Apr 2026 05:08AM UTC coverage: 98.75% (-0.2%) from 98.953%
24437497481

Pull #54

github

web-flow
Merge a3cb4e9fb into cc6c1f755
Pull Request #54: Handle fixed-width types in mocking

145 of 145 new or added lines in 12 files covered. (100.0%)

5 existing lines in 2 files now uncovered.

5058 of 5122 relevant lines covered (98.75%)

3996.99 hits per line

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

99.2
/src/mock/NamedValue.cpp
1
#include "mutiny/mock/NamedValue.hpp"
2

3
#include "mutiny/mock/NamedValueComparatorsAndCopiersRepository.hpp"
4

5
#include "mutiny/test/Shell.hpp"
6

7
namespace mu {
8
namespace tiny {
9
namespace mock {
10

11
NamedValueComparatorsAndCopiersRepository* NamedValue::default_repository_ =
12
    nullptr;
13
const double NamedValue::default_double_tolerance = 0.005;
14

15
void NamedValue::set_default_comparators_and_copiers_repository(
2,303✔
16
    NamedValueComparatorsAndCopiersRepository* repository
17
)
18
{
19
  default_repository_ = repository;
2,303✔
20
}
2,303✔
21

22
NamedValueComparatorsAndCopiersRepository* NamedValue::
58✔
23
    get_default_comparators_and_copiers_repository()
24
{
25
  return default_repository_;
58✔
26
}
27

28
NamedValue::NamedValue(const String& name)
1,596✔
29
  : name_(name)
1,596✔
30
  , type_("int")
1,596✔
31

32
{
33
  value_.int_value = 0;
1,596✔
34
}
1,596✔
35

36
NamedValue::NamedValue(NamedValue&& other) noexcept
1,072✔
37
  : name_(static_cast<String&&>(other.name_))
1,072✔
38
  , type_(static_cast<String&&>(other.type_))
1,072✔
39
  , is_const_object_(other.is_const_object_)
1,072✔
40
  , value_(other.value_)
1,072✔
41
  , size_(other.size_)
1,072✔
42
  , comparator_(other.comparator_)
1,072✔
43
  , copier_(other.copier_)
1,072✔
44
{
45
}
1,072✔
46

47
template<>
48
void NamedValue::set_value<bool>(bool value)
30✔
49
{
50
  type_ = "bool";
30✔
51
  value_.bool_value = value;
30✔
52
}
30✔
53

54
template<>
55
void NamedValue::set_value<int>(int value)
233✔
56
{
57
  type_ = "int";
233✔
58
  value_.int_value = value;
233✔
59
}
233✔
60

61
template<>
62
void NamedValue::set_value<unsigned int>(unsigned int value)
61✔
63
{
64
  type_ = "unsigned int";
61✔
65
  value_.unsigned_int_value = value;
61✔
66
}
61✔
67

68
template<>
69
void NamedValue::set_value<long int>(long int value)
41✔
70
{
71
  type_ = "long int";
41✔
72
  value_.long_int_value = value;
41✔
73
}
41✔
74

75
template<>
76
void NamedValue::set_value<unsigned long int>(unsigned long int value)
41✔
77
{
78
  type_ = "unsigned long int";
41✔
79
  value_.unsigned_long_int_value = value;
41✔
80
}
41✔
81

82
template<>
83
void NamedValue::set_value<long long>(long long value)
35✔
84
{
85
  type_ = "long long int";
35✔
86
  value_.long_long_int_value = value;
35✔
87
}
35✔
88

89
template<>
90
void NamedValue::set_value<unsigned long long>(unsigned long long value)
34✔
91
{
92
  type_ = "unsigned long long int";
34✔
93
  value_.unsigned_long_long_int_value = value;
34✔
94
}
34✔
95

96
template<>
97
void NamedValue::set_value<double>(double value)
43✔
98
{
99
  set_value(value, default_double_tolerance);
43✔
100
}
43✔
101

102
void NamedValue::set_value(double value, double tolerance)
52✔
103
{
104
  type_ = "double";
52✔
105
  value_.double_value.value = value;
52✔
106
  value_.double_value.tolerance = tolerance;
52✔
107
}
52✔
108

109
template<>
110
void NamedValue::set_value<void*>(void* value)
47✔
111
{
112
  type_ = "void*";
47✔
113
  value_.pointer_value = value;
47✔
114
}
47✔
115

116
template<>
117
void NamedValue::set_value<const void*>(const void* value)
61✔
118
{
119
  type_ = "const void*";
61✔
120
  value_.const_pointer_value = value;
61✔
121
}
61✔
122

123
template<>
124
void NamedValue::set_value<NamedValue::FunctionPointerValue>(
23✔
125
    NamedValue::FunctionPointerValue value
126
)
127
{
128
  type_ = "void (*)()";
23✔
129
  value_.function_pointer_value = value;
23✔
130
}
23✔
131

132
template<>
133
void NamedValue::set_value<const char*>(const char* value)
43✔
134
{
135
  type_ = "const char*";
43✔
136
  value_.string_value = value;
43✔
137
}
43✔
138

139
void NamedValue::set_memory_buffer(const unsigned char* value, size_t size)
21✔
140
{
141
  type_ = "const unsigned char*";
21✔
142
  value_.memory_buffer_value = value;
21✔
143
  size_ = size;
21✔
144
}
21✔
145

146
void NamedValue::set_const_object_pointer(
101✔
147
    const String& type,
148
    const void* object_ptr
149
)
150
{
151
  type_ = type;
101✔
152
  is_const_object_ = true;
101✔
153
  value_.const_object_pointer_value = object_ptr;
101✔
154
  if (default_repository_) {
101✔
155
    comparator_ = default_repository_->get_comparator_for_type(type);
88✔
156
    copier_ = default_repository_->get_copier_for_type(type);
88✔
157
  }
158
}
101✔
159

160
void NamedValue::set_object_pointer(const String& type, void* object_ptr)
49✔
161
{
162
  type_ = type;
49✔
163
  is_const_object_ = false;
49✔
164
  value_.object_pointer_value = object_ptr;
49✔
165
  if (default_repository_) {
49✔
166
    comparator_ = default_repository_->get_comparator_for_type(type);
49✔
167
    copier_ = default_repository_->get_copier_for_type(type);
49✔
168
  }
169
}
49✔
170

171
void NamedValue::set_size(size_t size)
37✔
172
{
173
  size_ = size;
37✔
174
}
37✔
175

UNCOV
176
void NamedValue::set_name(const char* name)
×
177
{
UNCOV
178
  name_ = name;
×
UNCOV
179
}
×
180

181
String NamedValue::get_name() const
2,899✔
182
{
183
  return name_;
2,899✔
184
}
185

186
String NamedValue::get_type() const
1,107✔
187
{
188
  return type_;
1,107✔
189
}
190

191
template<>
192
bool NamedValue::get_value<bool>() const
25✔
193
{
194
  STRCMP_EQUAL("bool", type_.c_str());
25✔
195
  return value_.bool_value;
25✔
196
}
197

198
template<>
199
int NamedValue::get_value<int>() const
53✔
200
{
201
  STRCMP_EQUAL("int", type_.c_str());
53✔
202
  return value_.int_value;
53✔
203
}
204

205
template<>
206
unsigned int NamedValue::get_value<unsigned int>() const
30✔
207
{
208
  if (type_ == "int" && value_.int_value >= 0)
30✔
209
    return static_cast<unsigned int>(value_.int_value);
1✔
210
  STRCMP_EQUAL("unsigned int", type_.c_str());
29✔
211
  return value_.unsigned_int_value;
29✔
212
}
213

214
template<>
215
long int NamedValue::get_value<long int>() const
31✔
216
{
217
  if (type_ == "int")
31✔
218
    return value_.int_value;
1✔
219
  else if (type_ == "unsigned int")
30✔
220
    return static_cast<long int>(value_.unsigned_int_value);
1✔
221
  STRCMP_EQUAL("long int", type_.c_str());
29✔
222
  return value_.long_int_value;
29✔
223
}
224

225
template<>
226
unsigned long int NamedValue::get_value<unsigned long int>() const
31✔
227
{
228
  if (type_ == "unsigned int")
31✔
229
    return value_.unsigned_int_value;
1✔
230
  else if (type_ == "int" && value_.int_value >= 0)
30✔
231
    return static_cast<unsigned long int>(value_.int_value);
1✔
232
  else if (type_ == "long int" && value_.long_int_value >= 0)
29✔
233
    return static_cast<unsigned long int>(value_.long_int_value);
1✔
234
  STRCMP_EQUAL("unsigned long int", type_.c_str());
28✔
235
  return value_.unsigned_long_int_value;
28✔
236
}
237

238
template<>
239
long long NamedValue::get_value<long long>() const
29✔
240
{
241
  if (type_ == "int")
29✔
242
    return value_.int_value;
1✔
243
  else if (type_ == "unsigned int")
28✔
244
    return static_cast<long long int>(value_.unsigned_int_value);
1✔
245
  else if (type_ == "long int")
27✔
246
    return value_.long_int_value;
1✔
247
  else if (type_ == "unsigned long int")
26✔
248
    return static_cast<long long int>(value_.unsigned_long_int_value);
1✔
249
  STRCMP_EQUAL("long long int", type_.c_str());
25✔
250
  return value_.long_long_int_value;
25✔
251
}
252

253
template<>
254
unsigned long long NamedValue::get_value<unsigned long long>() const
30✔
255
{
256
  if (type_ == "unsigned int")
30✔
257
    return value_.unsigned_int_value;
1✔
258
  else if (type_ == "int" && value_.int_value >= 0)
29✔
259
    return static_cast<unsigned long long int>(value_.int_value);
1✔
260
  else if (type_ == "long int" && value_.long_int_value >= 0)
28✔
261
    return static_cast<unsigned long long int>(value_.long_int_value);
1✔
262
  else if (type_ == "unsigned long int")
27✔
263
    return value_.unsigned_long_int_value;
1✔
264
  else if (type_ == "long long int" && value_.long_long_int_value >= 0)
26✔
265
    return static_cast<unsigned long long int>(value_.long_long_int_value);
1✔
266
  STRCMP_EQUAL("unsigned long long int", type_.c_str());
25✔
267
  return value_.unsigned_long_long_int_value;
25✔
268
}
269

270
template<>
271
double NamedValue::get_value<double>() const
19✔
272
{
273
  STRCMP_EQUAL("double", type_.c_str());
19✔
274
  return value_.double_value.value;
19✔
275
}
276

277
double NamedValue::get_double_tolerance() const
3✔
278
{
279
  STRCMP_EQUAL("double", type_.c_str());
3✔
280
  return value_.double_value.tolerance;
3✔
281
}
282

283
template<>
284
const char* NamedValue::get_value<const char*>() const
17✔
285
{
286
  STRCMP_EQUAL("const char*", type_.c_str());
17✔
287
  return value_.string_value;
17✔
288
}
289

290
template<>
291
void* NamedValue::get_value<void*>() const
17✔
292
{
293
  STRCMP_EQUAL("void*", type_.c_str());
17✔
294
  return value_.pointer_value;
17✔
295
}
296

297
template<>
298
const void* NamedValue::get_value<const void*>() const
38✔
299
{
300
  STRCMP_EQUAL("const void*", type_.c_str());
38✔
301
  return value_.const_pointer_value;
38✔
302
}
303

304
template<>
305
NamedValue::FunctionPointerValue NamedValue::get_value<
16✔
306
    NamedValue::FunctionPointerValue>() const
307
{
308
  STRCMP_EQUAL("void (*)()", type_.c_str());
16✔
309
  return value_.function_pointer_value;
16✔
310
}
311

312
const unsigned char* NamedValue::get_memory_buffer() const
3✔
313
{
314
  STRCMP_EQUAL("const unsigned char*", type_.c_str());
3✔
315
  return value_.memory_buffer_value;
3✔
316
}
317

318
const void* NamedValue::get_const_object_pointer() const
21✔
319
{
320
  return value_.const_object_pointer_value;
21✔
321
}
322

323
void* NamedValue::get_object_pointer() const
478✔
324
{
325
  return value_.object_pointer_value;
478✔
326
}
327

328
bool NamedValue::is_const_object() const
5✔
329
{
330
  return is_const_object_;
5✔
331
}
332

333
size_t NamedValue::get_size() const
24✔
334
{
335
  return size_;
24✔
336
}
337

338
NamedValueComparator* NamedValue::get_comparator() const
19✔
339
{
340
  return comparator_;
19✔
341
}
342

343
NamedValueCopier* NamedValue::get_copier() const
44✔
344
{
345
  return copier_;
44✔
346
}
347

348
bool NamedValue::equals(const NamedValue& p) const
199✔
349
{
350
  if ((type_ == "long int") && (p.type_ == "int"))
199✔
351
    return value_.long_int_value == p.value_.int_value;
1✔
352
  else if ((type_ == "int") && (p.type_ == "long int"))
198✔
353
    return value_.int_value == p.value_.long_int_value;
1✔
354
  else if ((type_ == "unsigned int") && (p.type_ == "int"))
197✔
355
    return (p.value_.int_value >= 0) &&
2✔
356
           (value_.unsigned_int_value ==
1✔
357
            static_cast<unsigned int>(p.value_.int_value));
2✔
358
  else if ((type_ == "int") && (p.type_ == "unsigned int"))
196✔
359
    return (value_.int_value >= 0) &&
2✔
360
           (static_cast<unsigned int>(value_.int_value) ==
1✔
361
            p.value_.unsigned_int_value);
2✔
362
  else if ((type_ == "unsigned long int") && (p.type_ == "int"))
195✔
363
    return (p.value_.int_value >= 0) &&
2✔
364
           (value_.unsigned_long_int_value ==
1✔
365
            static_cast<unsigned long>(p.value_.int_value));
2✔
366
  else if ((type_ == "int") && (p.type_ == "unsigned long int"))
194✔
367
    return (value_.int_value >= 0) &&
2✔
368
           (static_cast<unsigned long>(value_.int_value) ==
1✔
369
            p.value_.unsigned_long_int_value);
2✔
370
  else if ((type_ == "unsigned int") && (p.type_ == "long int"))
193✔
371
    return (p.value_.long_int_value >= 0) &&
2✔
372
           (value_.unsigned_int_value ==
1✔
373
            static_cast<unsigned long>(p.value_.long_int_value));
2✔
374
  else if ((type_ == "long int") && (p.type_ == "unsigned int"))
192✔
375
    return (value_.long_int_value >= 0) &&
2✔
376
           (static_cast<unsigned long>(value_.long_int_value) ==
1✔
377
            p.value_.unsigned_int_value);
2✔
378
  else if ((type_ == "unsigned int") && (p.type_ == "unsigned long int"))
191✔
379
    return value_.unsigned_int_value == p.value_.unsigned_long_int_value;
1✔
380
  else if ((type_ == "unsigned long int") && (p.type_ == "unsigned int"))
190✔
381
    return value_.unsigned_long_int_value == p.value_.unsigned_int_value;
1✔
382
  else if ((type_ == "long int") && (p.type_ == "unsigned long int"))
189✔
383
    return (value_.long_int_value >= 0) &&
3✔
384
           (static_cast<unsigned long>(value_.long_int_value) ==
1✔
385
            p.value_.unsigned_long_int_value);
3✔
386
  else if ((type_ == "unsigned long int") && (p.type_ == "long int"))
187✔
387
    return (p.value_.long_int_value >= 0) &&
3✔
388
           (value_.unsigned_long_int_value ==
1✔
389
            static_cast<unsigned long>(p.value_.long_int_value));
3✔
390
  else if ((type_ == "long long int") && (p.type_ == "int"))
185✔
391
    return value_.long_long_int_value == p.value_.int_value;
1✔
392
  else if ((type_ == "int") && (p.type_ == "long long int"))
184✔
393
    return value_.int_value == p.value_.long_long_int_value;
1✔
394
  else if ((type_ == "long long int") && (p.type_ == "long int"))
183✔
395
    return value_.long_long_int_value == p.value_.long_int_value;
1✔
396
  else if ((type_ == "long int") && (p.type_ == "long long int"))
182✔
397
    return value_.long_int_value == p.value_.long_long_int_value;
1✔
398
  else if ((type_ == "long long int") && (p.type_ == "unsigned int"))
181✔
399
    return (value_.long_long_int_value >= 0) &&
2✔
400
           (static_cast<unsigned long long>(value_.long_long_int_value) ==
1✔
401
            p.value_.unsigned_int_value);
2✔
402
  else if ((type_ == "unsigned int") && (p.type_ == "long long int"))
180✔
403
    return (p.value_.long_long_int_value >= 0) &&
2✔
404
           (value_.unsigned_int_value ==
1✔
405
            static_cast<unsigned long long>(p.value_.long_long_int_value));
2✔
406
  else if ((type_ == "long long int") && (p.type_ == "unsigned long int"))
179✔
407
    return (value_.long_long_int_value >= 0) &&
2✔
408
           (static_cast<unsigned long long>(value_.long_long_int_value) ==
1✔
409
            p.value_.unsigned_long_int_value);
2✔
410
  else if ((type_ == "unsigned long int") && (p.type_ == "long long int"))
178✔
411
    return (p.value_.long_long_int_value >= 0) &&
2✔
412
           (value_.unsigned_long_int_value ==
1✔
413
            static_cast<unsigned long long>(p.value_.long_long_int_value));
2✔
414
  else if ((type_ == "long long int") && (p.type_ == "unsigned long long int"))
177✔
415
    return (value_.long_long_int_value >= 0) &&
2✔
416
           (static_cast<unsigned long long>(value_.long_long_int_value) ==
1✔
417
            p.value_.unsigned_long_long_int_value);
2✔
418
  else if ((type_ == "unsigned long long int") && (p.type_ == "long long int"))
176✔
419
    return (p.value_.long_long_int_value >= 0) &&
2✔
420
           (value_.unsigned_long_long_int_value ==
1✔
421
            static_cast<unsigned long long>(p.value_.long_long_int_value));
2✔
422
  else if ((type_ == "unsigned long long int") && (p.type_ == "int"))
175✔
423
    return (p.value_.int_value >= 0) &&
2✔
424
           (value_.unsigned_long_long_int_value ==
1✔
425
            static_cast<unsigned long long>(p.value_.int_value));
2✔
426
  else if ((type_ == "int") && (p.type_ == "unsigned long long int"))
174✔
427
    return (value_.int_value >= 0) &&
2✔
428
           (static_cast<unsigned long long>(value_.int_value) ==
1✔
429
            p.value_.unsigned_long_long_int_value);
2✔
430
  else if ((type_ == "unsigned long long int") && (p.type_ == "unsigned int"))
173✔
431
    return value_.unsigned_long_long_int_value == p.value_.unsigned_int_value;
1✔
432
  else if ((type_ == "unsigned int") && (p.type_ == "unsigned long long int"))
172✔
433
    return value_.unsigned_int_value == p.value_.unsigned_long_long_int_value;
1✔
434
  else if ((type_ == "unsigned long long int") && (p.type_ == "long int"))
171✔
435
    return (p.value_.long_int_value >= 0) &&
2✔
436
           (value_.unsigned_long_long_int_value ==
1✔
437
            static_cast<unsigned long long>(p.value_.long_int_value));
2✔
438
  else if ((type_ == "long int") && (p.type_ == "unsigned long long int"))
170✔
439
    return (value_.long_int_value >= 0) &&
2✔
440
           (static_cast<unsigned long long>(value_.long_int_value) ==
1✔
441
            p.value_.unsigned_long_long_int_value);
2✔
442
  else if (
169✔
443
      (type_ == "unsigned long long int") && (p.type_ == "unsigned long int")
169✔
444
  )
445
    return value_.unsigned_long_long_int_value ==
1✔
446
           p.value_.unsigned_long_int_value;
1✔
447
  else if (
168✔
448
      (type_ == "unsigned long int") && (p.type_ == "unsigned long long int")
168✔
449
  )
450
    return value_.unsigned_long_int_value ==
1✔
451
           p.value_.unsigned_long_long_int_value;
1✔
452

453
  if (type_ != p.type_)
167✔
454
    return false;
2✔
455

456
  if (type_ == "bool")
165✔
457
    return value_.bool_value == p.value_.bool_value;
6✔
458
  else if (type_ == "int")
159✔
459
    return value_.int_value == p.value_.int_value;
77✔
460
  else if (type_ == "unsigned int")
82✔
461
    return value_.unsigned_int_value == p.value_.unsigned_int_value;
10✔
462
  else if (type_ == "long int")
72✔
463
    return value_.long_int_value == p.value_.long_int_value;
2✔
464
  else if (type_ == "unsigned long int")
70✔
465
    return value_.unsigned_long_int_value == p.value_.unsigned_long_int_value;
3✔
466
  else if (type_ == "long long int")
67✔
467
    return value_.long_long_int_value == p.value_.long_long_int_value;
3✔
468
  else if (type_ == "unsigned long long int")
64✔
469
    return value_.unsigned_long_long_int_value ==
3✔
470
           p.value_.unsigned_long_long_int_value;
3✔
471
  else if (type_ == "const char*")
61✔
472
    return String(value_.string_value) == String(p.value_.string_value);
7✔
473
  else if (type_ == "void*")
54✔
474
    return value_.pointer_value == p.value_.pointer_value;
4✔
475
  else if (type_ == "const void*")
50✔
476
    return value_.const_pointer_value == p.value_.const_pointer_value;
3✔
477
  else if (type_ == "void (*)()")
47✔
478
    return value_.function_pointer_value == p.value_.function_pointer_value;
4✔
479
  else if (type_ == "double")
43✔
480
    return (test::approx_equal(
36✔
481
        value_.double_value.value,
18✔
482
        p.value_.double_value.value,
18✔
483
        value_.double_value.tolerance
18✔
484
    ));
18✔
485
  else if (type_ == "const unsigned char*") {
25✔
486
    if (size_ != p.size_) {
6✔
487
      return false;
1✔
488
    }
489
    return memcmp(
10✔
490
               value_.memory_buffer_value, p.value_.memory_buffer_value, size_
5✔
491
           ) == 0;
5✔
492
  }
493

494
  if (comparator_)
19✔
495
    return comparator_->is_equal(
32✔
496
        value_.const_object_pointer_value, p.value_.const_object_pointer_value
16✔
497
    );
16✔
498

499
  return false;
3✔
500
}
501

502
bool NamedValue::compatible_for_copying(const NamedValue& p) const
51✔
503
{
504
  if (type_ == p.type_)
51✔
505
    return true;
24✔
506

507
  if ((type_ == "const void*") && (p.type_ == "void*"))
27✔
508
    return true;
25✔
509

510
  return false;
2✔
511
}
512

513
String NamedValue::to_string() const
119✔
514
{
515
  if (type_ == "bool")
119✔
516
    return string_from(value_.bool_value);
2✔
517
  else if (type_ == "int")
117✔
518
    return string_from(value_.int_value) + " " +
76✔
519
           brackets_formatted_hex_string_from(value_.int_value);
114✔
520
  else if (type_ == "unsigned int")
79✔
521
    return string_from(value_.unsigned_int_value) + " " +
22✔
522
           brackets_formatted_hex_string_from(value_.unsigned_int_value);
33✔
523
  else if (type_ == "long int")
68✔
524
    return string_from(value_.long_int_value) + " " +
10✔
525
           brackets_formatted_hex_string_from(value_.long_int_value);
15✔
526
  else if (type_ == "unsigned long int")
63✔
527
    return string_from(value_.unsigned_long_int_value) + " " +
10✔
528
           brackets_formatted_hex_string_from(value_.unsigned_long_int_value);
15✔
529
  else if (type_ == "long long int")
58✔
530
    return string_from(value_.long_long_int_value) + " " +
4✔
531
           brackets_formatted_hex_string_from(value_.long_long_int_value);
6✔
532
  else if (type_ == "unsigned long long int")
56✔
533
    return string_from(value_.unsigned_long_long_int_value) + " " +
4✔
534
           brackets_formatted_hex_string_from(
2✔
535
               value_.unsigned_long_long_int_value
2✔
536
           );
2✔
537
  else if (type_ == "const char*")
54✔
538
    return value_.string_value;
19✔
539
  else if (type_ == "void*")
35✔
540
    return string_from(value_.pointer_value);
1✔
541
  else if (type_ == "void (*)()")
34✔
542
    return string_from(value_.function_pointer_value);
2✔
543
  else if (type_ == "const void*")
32✔
544
    return string_from(value_.const_pointer_value);
3✔
545
  else if (type_ == "double")
29✔
546
    return string_from(value_.double_value.value);
8✔
547
  else if (type_ == "const unsigned char*")
21✔
548
    return string_from_binary_with_size_or_null(
549
        value_.memory_buffer_value, size_
13✔
550
    );
13✔
551

552
  if (comparator_)
8✔
553
    return comparator_->value_to_string(value_.const_object_pointer_value);
5✔
554

555
  return string_from_format(
556
      "No comparator found for type: \"%s\"", type_.c_str()
557
  );
3✔
558
}
559

560
} // namespace mock
561
} // namespace tiny
562
} // namespace mu
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc