Formatting error for round numbers in add-on manager

[sevu]

Maybe unrelated to #3870, could proof-check if #1396 is affected or not.

It's 1000 KiB
Not really reproducible I guess ;)

[jyrkive]

The size is formatted with function si_string_impl_stream_write(). That function uses the C++ standard library default formatting mode on all compilers except Microsoft Visual Studio.

wesnoth/src/serialization/string_utils.cpp

Line 525 in 7ea1377

static void si_string_impl_stream_write(std::stringstream &ss, double input) {

I believe the fix would involve using the fixed formatting mode with all compilers.

[sevu]

I used gcc.
Could it be that it's rounded up to 1000 for 995-999, and the workaround only works from 1000?

[jyrkive]

Yes, it's possible that the actual value was slightly less than 1000 kiB. Thus, the precision was only set to three digits, and libstdc++ (GCC's standard library implementation) chose the scientific formatting mode.

We should just use the fixed mode everywhere. Relying on the default mode not using scientific formatting is fragile.

[Wedge009]

A pity it's not easy to reproduce. I could check this with MSVC on Windows and gcc on Linux.

[jyrkive]

To test this, you could just hardcode the value to whatever you want.

wesnoth/src/gui/dialogs/network_transmission.cpp

Line 46 in a7e65de

completed = connection_->current();

[Wedge009]

Thanks for the pointer. The nice thing is that I don't need to download anything extra - the add-ons list download is sufficient.

I saw the commit that Vultraz did and given that sevu is using gcc I focused on that, but both MSVC and gcc (with a value of 1024000) show 1000.0 KiB instead of 1e+03 KiB now. I'd say this can be closed, assuming sevu is okay with it.

[AI0867]

First off, 1 MiB = 1024 KiB, so the case in the report can be reproduced with values from 1000 KiB to 1023 KiB. (just add std::cerr << utils::si_string(1024000, true, _("unit_byte^B")) << "\n"; to the top of your main).

I tried to keep the number size fairly small and constant, hence the 3-digit precision, bumped to 4 digits for just the above case. This means at all times, at most 4 characters are used for the number.

Unfortunately, MSVC ignores the standard saying that in default mode, the precision method specifies the number of significant digits, and takes it to mean the number of decimals instead. So for MSVC we do the next-best thing and just use fixed mode with 1 decimal, even though this can use up to 6 characters (e.g. 1000.0), and can result in fairly nonsensical precisions (1.0 bytes).

Equivalent printf statements: http://cpp.sh/23ign (according to standard sections 30.7.5.2.2 and 25.4.2.2.2, also: https://en.cppreference.com/w/cpp/locale/num_put/put)

I do wonder why 1024000 would return as 1e+03 KiB instead of 1000 KiB though, so I wonder what configuration is needed to produce this issue.

[AI0867]

Ah, I seem to have found the problem: http://cpp.sh/26hia
Further analysis: http://cpp.sh/7ppnb

There is a range of double values [999.5, 1000) that will display as 1000 when printed. Printing these with a precision of 4 will cause 999.5 to be printed instead, but that's less of an issue.

A more robust comparison will fix this (rounding before comparing will do). We could also round all values >= 999 before printing to avoid the whole thing altogether.