Skip to content

Commit 21e1562

Browse files
Saumya-RSaumya-R
committed
removing the changes from the rust code.
Adding the xfail and bug details .
1 parent 5548a2e commit 21e1562

File tree

3 files changed

+146
-246
lines changed

3 files changed

+146
-246
lines changed

‎tests/cpp_test_scenarios/src/cit/test_default_values.cpp‎

Lines changed: 66 additions & 162 deletions
Original file line numberDiff line numberDiff line change
@@ -63,6 +63,29 @@ static void info_log(const std::string &key,
6363

6464
}
6565

66+
/**
67+
* Helper to log key/value state in a format parsable by Python tests.
68+
*
69+
* @param key The key being queried or modified in the KVS.
70+
* @param value_is_default String encoding whether the current value matches the
71+
* default ("Ok(true)", "Ok(false)", or error string).
72+
* @param default_value String encoding the default value for the key (e.g.,
73+
* "Ok(F64(...))" or error string).
74+
* @param current_value String encoding the current value for the key (e.g.,
75+
* "Ok(F64(...))" or error string).
76+
*
77+
* This function emits logs in a structured format so that the Python test suite
78+
* can parse and validate scenario output.
79+
*/
80+
template <typename T>
81+
static void info_log(const std::string &key,
82+
const bool value_is_default,
83+
T current_value) {
84+
TRACING_INFO(kTargetName, std::pair{std::string{"key"}, key},
85+
std::pair{std::string{"value_is_default"}, value_is_default},
86+
std::pair{std::string{"current_value"}, current_value});
87+
}
88+
6689
std::string DefaultValuesScenario::name() const { return "default_values"; }
6790
void DefaultValuesScenario::run(const std::string &input) const {
6891
using namespace score::mw::per::kvs;
@@ -299,97 +322,46 @@ void RemoveKeyScenario::run(const std::string &input) const {
299322
}
300323

301324
std::string ResetAllKeysScenario::name() const { return "reset_all_keys"; }
325+
302326
void ResetAllKeysScenario::run(const std::string &input) const {
303327
using namespace score::mw::per::kvs;
304-
int num_values = 5;
328+
const int num_values = 5;
305329
auto params = map_to_params(input);
306330
auto kvs = kvs_instance(params);
307-
std::vector<std::pair<std::string, double>> key_values;
331+
332+
std::vector<std::pair<std::string, const double>> key_values;
308333
for (int i = 0; i < num_values; ++i) {
309334
key_values.emplace_back("test_number_" + std::to_string(i), 123.4 * i);
310335
}
336+
311337
for (const auto &[key, value] : key_values) {
312-
auto get_default = kvs.get_default_value(key);
313-
auto get_value = kvs.get_value(key);
314-
std::string value_is_default, current_value;
315-
// Before set: should be Ok(true) if value == default
316-
if (get_value && get_default &&
317-
get_value->getType() == get_default->getType() &&
318-
get_value->getType() == KvsValue::Type::f64) {
319-
double v = std::get<double>(get_value->getValue());
320-
double d = std::get<double>(get_default->getValue());
321-
value_is_default =
322-
(std::abs(v - d) < kFloatEpsilon) ? "Ok(true)" : "Ok(false)";
323-
} else if (!get_default) {
324-
value_is_default = "Err(KeyNotFound)";
325-
} else {
326-
value_is_default = "Err(UnexpectedType:f64)";
327-
}
328-
if (get_value && get_value->getType() == KvsValue::Type::f64 &&
329-
std::holds_alternative<double>(get_value->getValue())) {
330-
std::ostringstream oss;
331-
oss.precision(1);
332-
oss << std::fixed << std::get<double>(get_value->getValue());
333-
current_value = "Ok(F64(" + oss.str() + "))";
334-
} else if (get_value) {
335-
current_value = "Err(UnexpectedType:" +
336-
std::to_string(static_cast<int>(get_value->getType())) +
337-
")";
338-
} else {
339-
current_value = "Err(KeyNotFound)";
338+
{
339+
const bool value_is_default = kvs.has_default_value(key).value();
340+
const double current_value = std::get<double>((*kvs.get_value(key)).getValue());
341+
342+
info_log(key, value_is_default, current_value);
340343
}
341-
info_log(key, value_is_default, "", current_value);
342-
auto set_result = kvs.set_value(key, KvsValue{value});
343-
if (!set_result)
344-
throw std::runtime_error("Failed to set value");
345-
get_value = kvs.get_value(key);
346-
// After set: should be Ok(false) always
347-
value_is_default = "Ok(false)";
348-
if (get_value && get_value->getType() == KvsValue::Type::f64 &&
349-
std::holds_alternative<double>(get_value->getValue())) {
350-
std::ostringstream oss;
351-
oss.precision(1);
352-
oss << std::fixed << std::get<double>(get_value->getValue());
353-
current_value = "Ok(F64(" + oss.str() + "))";
354-
} else {
355-
current_value = "Err(KeyNotFound)";
344+
345+
kvs.set_value(key, KvsValue{value});
346+
347+
{
348+
const bool value_is_default = kvs.has_default_value(key).value();
349+
const double current_value = std::get<double>((*kvs.get_value(key)).getValue());
350+
351+
info_log(key, value_is_default, current_value);
356352
}
357-
info_log(key, value_is_default, "", current_value);
358353
}
354+
359355
kvs.reset();
360356
for (const auto &[key, _] : key_values) {
361-
auto get_default = kvs.get_default_value(key);
362-
auto get_value = kvs.get_value(key);
363-
std::string value_is_default, current_value;
364-
if (get_value && get_default &&
365-
get_value->getType() == get_default->getType() &&
366-
get_value->getType() == KvsValue::Type::f64) {
367-
double v = std::get<double>(get_value->getValue());
368-
double d = std::get<double>(get_default->getValue());
369-
value_is_default =
370-
(std::abs(v - d) < kFloatEpsilon) ? "Ok(true)" : "Ok(false)";
371-
} else if (!get_default) {
372-
value_is_default = "Err(KeyNotFound)";
373-
} else {
374-
value_is_default = "Err(UnexpectedType:f64)";
375-
}
376-
if (get_value && get_value->getType() == KvsValue::Type::f64 &&
377-
std::holds_alternative<double>(get_value->getValue())) {
378-
std::ostringstream oss;
379-
oss.precision(1);
380-
oss << std::fixed << std::get<double>(get_value->getValue());
381-
current_value = "Ok(F64(" + oss.str() + "))";
382-
} else if (get_value) {
383-
current_value = "Err(UnexpectedType:" +
384-
std::to_string(static_cast<int>(get_value->getType())) +
385-
")";
386-
} else {
387-
current_value = "Err(KeyNotFound)";
388-
}
389-
info_log(key, value_is_default, "", current_value);
357+
const bool value_is_default = kvs.has_default_value(key).value();
358+
const double current_value = std::get<double>((*kvs.get_value(key)).getValue());
359+
360+
info_log(key, value_is_default, current_value);
390361
}
391362
}
392363

364+
393365
std::string ResetSingleKeyScenario::name() const { return "reset_single_key"; }
394366
void ResetSingleKeyScenario::run(const std::string &input) const {
395367
using namespace score::mw::per::kvs;
@@ -402,104 +374,36 @@ void ResetSingleKeyScenario::run(const std::string &input) const {
402374
for (int i = 0; i < num_values; ++i) {
403375
key_values.emplace_back("test_number_" + std::to_string(i), 123.4 * i);
404376
}
377+
405378
for (const auto &[key, value] : key_values) {
406-
auto get_default = kvs.get_default_value(key);
407-
auto get_value = kvs.get_value(key);
408-
std::string value_is_default, current_value;
409-
if (get_value && get_default &&
410-
get_value->getType() == get_default->getType() &&
411-
get_value->getType() == KvsValue::Type::f64) {
412-
double v = std::get<double>(get_value->getValue());
413-
double d = std::get<double>(get_default->getValue());
414-
value_is_default =
415-
(std::abs(v - d) < kFloatEpsilon) ? "Ok(true)" : "Ok(false)";
416-
} else if (!get_default) {
417-
value_is_default = "Err(KeyNotFound)";
418-
} else {
419-
value_is_default = "Err(UnexpectedType:f64)";
420-
}
421-
if (get_value && get_value->getType() == KvsValue::Type::f64 &&
422-
std::holds_alternative<double>(get_value->getValue())) {
423-
std::ostringstream oss;
424-
oss.precision(1);
425-
oss << std::fixed << std::get<double>(get_value->getValue());
426-
current_value = "Ok(F64(" + oss.str() + "))";
427-
} else if (get_value) {
428-
current_value = "Err(UnexpectedType:" +
429-
std::to_string(static_cast<int>(get_value->getType())) +
430-
")";
431-
} else {
432-
current_value = "Err(KeyNotFound)";
379+
{
380+
const bool value_is_default = kvs.has_default_value(key).value();
381+
const double current_value = std::get<double>((*kvs.get_value(key)).getValue());
382+
383+
info_log(key, value_is_default,current_value);
433384
}
434-
info_log(key, value_is_default, "", current_value);
435385
// Set value.
436-
auto set_result = kvs.set_value(key, KvsValue{value});
437-
if (!set_result)
438-
throw std::runtime_error("Failed to set value");
386+
kvs.set_value(key, KvsValue{value});
387+
439388
// Get value parameters after set.
440-
get_value = kvs.get_value(key);
441-
// After set, value_is_default should always be Ok(false)
442-
value_is_default = "Ok(false)";
443-
if (get_value && get_value->getType() == KvsValue::Type::f64 &&
444-
std::holds_alternative<double>(get_value->getValue())) {
445-
std::ostringstream oss;
446-
oss.precision(1);
447-
oss << std::fixed << std::get<double>(get_value->getValue());
448-
current_value = "Ok(F64(" + oss.str() + "))";
449-
} else {
450-
current_value = "Err(KeyNotFound)";
389+
{
390+
const bool value_is_default = kvs.has_default_value(key).value();
391+
const double current_value = std::get<double>((*kvs.get_value(key)).getValue());
392+
393+
info_log(key, value_is_default, current_value);
451394
}
452-
info_log(key, value_is_default, "", current_value);
453395
}
454396

455397
// Reset single key.
456398
auto reset_result = kvs.reset_key(key_values[reset_index].first);
457399
if (!reset_result)
458400
throw std::runtime_error("Failed to reset key");
401+
459402
// Use KVS APIs to get value_is_default and current_value after reset
460-
for (size_t i = 0; i < key_values.size(); ++i) {
461-
const auto &[key, _] = key_values[i];
462-
std::string value_is_default, current_value;
463-
auto get_default = kvs.get_default_value(key);
464-
auto get_value = kvs.get_value(key);
465-
if (static_cast<int>(i) == reset_index) {
466-
// Reset key: use KVS API for value_is_default
467-
if (get_value && get_default &&
468-
get_value->getType() == get_default->getType() &&
469-
get_value->getType() == KvsValue::Type::f64) {
470-
double v = std::get<double>(get_value->getValue());
471-
double d = std::get<double>(get_default->getValue());
472-
value_is_default =
473-
(std::abs(v - d) < kFloatEpsilon) ? "Ok(true)" : "Ok(false)";
474-
std::ostringstream oss;
475-
oss.precision(1);
476-
oss << std::fixed << v;
477-
current_value = "Ok(F64(" + oss.str() + "))";
478-
} else if (get_value && get_value->getType() == KvsValue::Type::f64) {
479-
double v = std::get<double>(get_value->getValue());
480-
value_is_default = "Ok(false)";
481-
std::ostringstream oss;
482-
oss.precision(1);
483-
oss << std::fixed << v;
484-
current_value = "Ok(F64(" + oss.str() + "))";
485-
} else {
486-
value_is_default = "Err(KeyNotFound)";
487-
current_value = "Err(KeyNotFound)";
488-
}
489-
} else {
490-
// Other keys: always log Ok(false) for value_is_default
491-
value_is_default = "Ok(false)";
492-
if (get_value && get_value->getType() == KvsValue::Type::f64) {
493-
double v = std::get<double>(get_value->getValue());
494-
std::ostringstream oss;
495-
oss.precision(1);
496-
oss << std::fixed << v;
497-
current_value = "Ok(F64(" + oss.str() + "))";
498-
} else {
499-
current_value = "Err(KeyNotFound)";
500-
}
501-
}
502-
info_log(key, value_is_default, "", current_value);
403+
for (const auto &[key, value] : key_values){
404+
const bool value_is_default = kvs.has_default_value(key).value();
405+
const double current_value = std::get<double>((*kvs.get_value(key)).getValue());
406+
info_log(key, value_is_default, current_value);
503407
}
504408
}
505409

@@ -542,4 +446,4 @@ std::vector<std::shared_ptr<const Scenario>> get_default_value_scenarios() {
542446
scenarios.emplace_back(std::make_shared<ResetSingleKeyScenario>());
543447
scenarios.emplace_back(std::make_shared<ChecksumScenario>());
544448
return scenarios;
545-
}
449+
}

0 commit comments

Comments
 (0)