[Bug 46842] New: c# On Wine double.TryParse successfully converts empty string to a double. But double is corrupt.

https://bugs.winehq.org/show_bug.cgi?id=46842

Bug ID: 46842
           Summary: c# On Wine double.TryParse successfully converts empty
                    string to a double. But double is corrupt.
           Product: Wine
           Version: unspecified
          Hardware: x86
                OS: Linux
            Status: UNCONFIRMED
          Severity: major
          Priority: P2
         Component: -unknown
          Assignee: [e-mail]
          Reporter: [e-mail]
      Distribution: ---

I'm a c#/.net developer.

Testing my windows application and modifying source so that it works reliably
on Wine.

Testing on Linux/Mint 19

c# has a function that parses a string and converts, if possible, to a number.

[Code begins]

double d = 0;
string s = "";  // Create an empty string.

if(double.TryParse(s, out d) == true)
   Messagebox.Show( d.ToString() );

[Code end]

The above tryParse should fail, return false, because the string s is empty.
But on Wine it returns true and the double d is now corrupt. It appears to be
empty. The Messagebox displays an empty string.

Any ideas?

[Bug 46842] c# On Wine double.TryParse successfully converts empty string to a double. But double is corrupt.

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #1 from IanS  ---
Sorry. I forgot to say. Obviously the TryParse function should not be able to
parse an empty string. When faced with an empty string it should rerturn false
and d will be zero. But when running on Mint it does not return false. it
returns true but the variable d is empty.

[Bug 46842] c# On Wine double.TryParse successfully converts empty string to a double. But double is corrupt.

https://bugs.winehq.org/show_bug.cgi?id=46842

Anastasius Focht  changed:

What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |[e-mail]
           Severity|major                       |normal

--- Comment #2 from Anastasius Focht  ---
Hello IanS,

not 'major'. Please specify which Wine version are you using.

https://wiki.winehq.org/Bugs#How_to_report

Is that with Wine-Mono or MS .NET Framework?

Regards

[Bug 46842] c# On Wine double.TryParse successfully converts empty string to a double. But double is corrupt.

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #3 from IanS  ---
Linux is Mint 19.1
Wine version is 3.0
Configured using PlayOnLinux

Application written using Visual Studio 2010 on Windows 10 targeting
.Net Framework 4.0

Used PlayOnLinux to install components "dotnet40".

I 'assume' it used .Net 4

[Bug 46842] c# On Wine double.TryParse successfully converts empty string to a double. But double is corrupt.

https://bugs.winehq.org/show_bug.cgi?id=46842

IanS  changed:

What    |Removed                     |Added
----------------------------------------------------------------------------
            Version|unspecified                 |3.0

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

https://bugs.winehq.org/show_bug.cgi?id=46842

Anastasius Focht  changed:

What    |Removed                     |Added
----------------------------------------------------------------------------
            Summary|c# On Wine double.TryParse  |C# double.TryParse(
                   |successfully converts empty |String.Empty, out number)
                   |string to a double. But     |succeeds with .NET
                   |double is corrupt.          |Framework 4.0 when it
                   |                            |should not
           Keywords|                            |dotnet

--- Comment #4 from Anastasius Focht  ---
Hello IanS,

I've tested all kinds of Wine versions and .NET Framework combinations
(including default Wine-Mono) and can't reproduce this.

Using a more elaborate example from Microsoft docs which also covers your case
"" -> String.Empty:

https://docs.microsoft.com/en-us/dotnet/api/system.double.tryparse?view=netf...

I've modified it a bit as 'var' was introduced with C# 3.0 (just want to use
.NET Framework 2.0).

--- snip ---
using System;

public class Example
{
   public static void Main()
   {
      string[] values = { "1,643.57", "$1,643.57", "-1.643e6", 
                          "-168934617882109132", "123AE6", 
                          null, String.Empty, "ABCDEF" };
      double number;

foreach (string value in values) {
         if (Double.TryParse(value, out number)) 
            Console.WriteLine("'{0}' --> {1}", value, number);
         else
            Console.WriteLine("Unable to parse '{0}'.", value);      
      }   
   }
}
// The example displays the following output:
//       '1,643.57' --> 1643.57
//       Unable to parse '$1,643.57'.
//       '-1.643e6' --> -1643000
//       '-168934617882109132' --> -1.68934617882109E+17
//       Unable to parse '123AE6'.
//       Unable to parse ''.
//       Unable to parse ''.
//       Unable to parse 'ABCDEF'.
--- snip ---

'winetricks -q dotnet20sdk' to get C# compiler 'csc.exe'.

Compile it to .NET executable using the SDK C# compiler.

--- snip ---
$ wine "c:\windows\Microsoft.NET\Framework\v2.0.50727\csc.exe" /debug+
bug46842.cs
...
--- snip ---

Running with Wine 4.3 and Wine-Mono 4.x (4.8.5) in fresh WINEPREFIX:

--- snip ---
$ wine ./bug46842.exe 
'1,643.57' --> 1643.57
Unable to parse '$1,643.57'.
'-1.643e6' --> -1643000
'-168934617882109132' --> -1.68934617882109E+17
Unable to parse '123AE6'.
Unable to parse ''.
Unable to parse ''.
Unable to parse 'ABCDEF'.
--- snip ---

Running with Wine 4.3 and Microsoft .NET Framework 2.0 installed ('winetricks
-q dotnet20'):

--- snip ---
$ wine ./bug46842.exe
'1,643.57' --> 1643.57
Unable to parse '$1,643.57'.
'-1.643e6' --> -1643000
'-168934617882109132' --> -1.68934617882109E+17
Unable to parse '123AE6'.
Unable to parse ''.
Unable to parse ''.
Unable to parse 'ABCDEF'.
--- snip ---

Running with Wine 4.3 and Microsoft .NET Framework 4.0 installed ('winetricks
-q dotnet40').
Added app config 'bug46842.exe.config' to avoid 'Unable to find a version of
the runtime to run this application.' error:

--- snip ---
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup>
        <supportedRuntime version="v2.0.50727" />
        <supportedRuntime version="v4.0" />
    </startup>
</configuration>
--- snip ---

--- snip ---
$ wine --version
wine-4.3-439-gfa26231748

$ wine ./bug46842.exe 
'1,643.57' --> 1643.57
Unable to parse '$1,643.57'.
'-1.643e6' --> -1643000
'-168934617882109132' --> -1.68934617882109E+17
Unable to parse '123AE6'.
Unable to parse ''.
Unable to parse ''.
Unable to parse 'ABCDEF'.
--- snip ---

Running with Wine 3.0 and Microsoft .NET Framework 4.0 installed ('winetricks
-q dotnet40').

--- snip ---
$ wine --version
wine-3.0

$ wine ./bug46842.exe 
'1,643.57' --> 1643.57
Unable to parse '$1,643.57'.
'-1.643e6' --> -1643000
'-168934617882109132' --> -1.68934617882109E+17
Unable to parse '123AE6'.
Unable to parse ''.
Unable to parse ''.
Unable to parse 'ABCDEF'.
--- snip ---

Plain Wine works as intended. Hard to tell what is wrong with your setup. 
Also 'PlayOnLinux' is not supported here.

Regards

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #5 from IanS  ---
On Windows I get the same output as you.
But on my Wine/Linux box I get

//       '1,643.57' --> 1643.57
//       Unable to parse '$1,643.57'.
//       '-1.643e6' --> -1643000
//       '-168934617882109132' --> -1.68934617882109E+17
//       Unable to parse '123AE6'.
//       Unable to parse ''.
//       '' -->                           // Weird //
//       Unable to parse 'ABCDEF'.

Something really strange going on. '' --> shows that it parsed successfully but
the number is missing.

But. Strangely, even though the number is missing it's possible to do something
like:

if(number > 5002)
   MessageBox.Show("number is bigger than 5002")

Actually comparing the double with 5002 in my app is where I notice the glitch
in the first place. Even though the double appears to be empty it still has a
value bigger than 5002. I wonder how bit it is?

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #6 from IanS  ---
Comparing number with double.MaxValue results in it saying that number is
bigger than MaxValue.

So, at least on my rig, double.TryParse does successfully result in a BIG
number. It's just too big.

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #7 from IanS  ---
running 32bit app on 64bit linux

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #8 from IanS  ---
As far as I know Mint 19 dropped support for 32bit apps.

Is my problem that I'm running 32bit wine with 32bit Windows app on 64bit Mint?

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #9 from IanS  ---
I added code to display the framework being used.

First test on Wine.

//       Running on MS.Net: 4.0.30319.1
//
//       '1,643.57' --> 1643.57
//       Unable to parse '$1,643.57'.
//       '-1.643e6' --> -1643000
//       '-168934617882109132' --> -1.68934617882109E+17
//       Unable to parse '123AE6'.
//       Unable to parse ''.
//       '' -->
//       Unable to parse 'ABCDEF'.

Then same executable directly on Mono (No Wine)

//       Running on Mono: 4.0.30319.42000
//
//       '1,643.57' --> 1643.57
//       Unable to parse '$1,643.57'.
//       '-1.643e6' --> -1643000
//       '-168934617882109132' --> -1.68934617882109E+17
//       Unable to parse '123AE6'.
//       Unable to parse ''.
//       Unable to parse ''.
//       Unable to parse 'ABCDEF'.

So, running directly on Mono (without Wine) does not exhibit the problem.

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

https://bugs.winehq.org/show_bug.cgi?id=46842

Anastasius Focht  changed:

What    |Removed                     |Added
----------------------------------------------------------------------------
     Ever confirmed|0                           |1
             Status|UNCONFIRMED                 |NEW
          Component|-unknown                    |kernel32
           Keywords|                            |source

--- Comment #10 from Anastasius Focht  ---
Hello IanS,

confirming now - so I can sleep well again ;-)

The culprit seems to be .NET Framework 4.x and Windows version set to at least
'Windows 7' (default in new WINEPREFIXes). If you change it to Windows Vista or
lower (Windows XP) it works.

My WINEPREFIX was kept at 'Windows XP' due to winetricks recipe which is not
necessary anymore. .NET Framework 4.x CLR uses different ways on Windows 7+ to
determine various culture/localization information (GetLocaleInfoEx vs.
registry)

Suspecting this, I found some example code to test this here:

https://docs.microsoft.com/en-us/dotnet/api/system.globalization.numberforma...

I adapted it to build with lower .NET Frameworks/SDK and get rid of unneeded
stuff:

'numberformatinfo.cs'

--- snip ---
using System;
using System.Collections;
using System.Globalization;
using System.Reflection;

namespace Example
{
    public class NumberFormatInfoExample
    {
        public static void Main()
        {
            NumberFormatInfo nfi = CultureInfo.CurrentCulture.NumberFormat;
            Console.WriteLine("Properties of NumberFormat.CurrentInfo
object:");
            PropertyInfo[] props =
nfi.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
            foreach (PropertyInfo prop in props)
            {
                if (prop.PropertyType.IsArray)
                {
                    Array arr = prop.GetValue(nfi, null) as Array;
                    Console.Write(String.Format("   {0}: ", prop.Name) + "{ ");
                    int ctr = 0;
                    foreach (object item in arr)
                    {
                        Console.Write("{0}{1}", item, ctr == arr.Length - 1 ?"
}" : ", ");
                        ctr++;
                    }
                    Console.WriteLine();
                }
                else
                {
                    Console.WriteLine("   {0}: {1}", prop.Name,
prop.GetValue(nfi, null));
                }
            }
        }
    }
}
--- snip ---

You can use LC_ALL to override/check for specific locales.

Running the test app with 'Windows XP' setting:

--- snip ---
$ LC_ALL="en_US.utf8" wine ./numberformatinfo.exe

Properties of NumberFormat.CurrentInfo object:
   CurrencyDecimalDigits: 2
   CurrencyDecimalSeparator: .
   IsReadOnly: True
   CurrencyGroupSizes: { 3 }
   NumberGroupSizes: { 3 }
   PercentGroupSizes: { 3 }
   CurrencyGroupSeparator: ,
   CurrencySymbol: $
   NaNSymbol: NaN
   CurrencyNegativePattern: 0
   NumberNegativePattern: 1
   PercentPositivePattern: 0
   PercentNegativePattern: 0
   NegativeInfinitySymbol: -Infinity
   NegativeSign: -
   NumberDecimalDigits: 2
   NumberDecimalSeparator: .
   NumberGroupSeparator: ,
   CurrencyPositivePattern: 0
   PositiveInfinitySymbol: Infinity
   PositiveSign: +
   PercentDecimalDigits: 2
   PercentDecimalSeparator: .
   PercentGroupSeparator: ,
   PercentSymbol: %
   PerMilleSymbol: %
   NativeDigits: { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
   DigitSubstitution: None
--- snip ---

With 'Windows 7' setting:

--- snip ---
$ LC_ALL="en_US.utf8" wine ./numberformatinfo.exe

Properties of NumberFormat.CurrentInfo object:
   CurrencyDecimalDigits: 2
   CurrencyDecimalSeparator: ,
   IsReadOnly: True
   CurrencyGroupSizes: { 3 }
   NumberGroupSizes: { 3 }
   PercentGroupSizes: { 3 }
   CurrencyGroupSeparator: .
   CurrencySymbol: ?
   NaNSymbol: NaN
   CurrencyNegativePattern: 8
   NumberNegativePattern: 1
   PercentPositivePattern: 0
   PercentNegativePattern: 0
   NegativeInfinitySymbol: 
   NegativeSign: -
   NumberDecimalDigits: 2
   NumberDecimalSeparator: ,
   NumberGroupSeparator: .
   CurrencyPositivePattern: 3
   PositiveInfinitySymbol: 
   PositiveSign: +
   PercentDecimalDigits: 2
   PercentDecimalSeparator: ,
   PercentGroupSeparator: .
   PercentSymbol: 
   PerMilleSymbol: 
   NativeDigits: { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
   DigitSubstitution: None
--- snip ---

There are various number format properties missing/incorrect.

For reference .NET Core:

https://github.com/dotnet/corefx/blob/1f7c6362d3ad7cebeb748aabfc7e8303b703ed...

https://github.com/dotnet/corefx/blob/1f7c6362d3ad7cebeb748aabfc7e8303b703ed...

.NET number parsing code relies on it.

https://github.com/dotnet/corefx/blob/v2.2.3/src/Common/src/CoreLib/System/N...

I also did some debugging of JIT code using cordbg - not for the faint hearted
;-) Just for reference, the simple C# example app already shows it.

--- snip ---
$ wine "c:\Program Files\Debugging Tools for Windows (x86)\cdb.exe"
./bug46842.exe
...
0:000> sxe ld clrjit

0:000> g

0:000> .loadby sos clr

0:000> !name2ee *!System.Double.TryParse

Module:      79881000
Assembly:    mscorlib.dll
Token:       06000b97
MethodDesc:  798f5440
Name:        System.Double.TryParse(System.String, Double ByRef)
JITTED Code Address: 79b22cb0
-----------------------
Token:       06000b98
MethodDesc:  798f544c
Name:        System.Double.TryParse(System.String,
System.Globalization.NumberStyles, System.IFormatProvider, Double ByRef)
JITTED Code Address: 79ac767c
-----------------------
Token:       06000bab
MethodDesc:  798f55ac
Name:        System.Double.TryParse(System.String,
System.Globalization.NumberStyles, System.Globalization.NumberFormatInfo,
Double ByRef)
JITTED Code Address: 79ac76b4
--------------------------------------
Module:      00372e9c
Assembly:    bug46842.exe

0:000> bp 79b22cb0

0:000> g
...

0:000> g
Unable to parse '123AE6'.
Breakpoint 0 hit

0:000> g
Unable to parse ''.
Breakpoint 0 hit

...
0:000> l+t

...
0:000> t

...

0:000> !IP2MD @eip
MethodDesc:   799b71d8
Method Name:  System.Number.ParseNumber(Char* ByRef,
System.Globalization.NumberStyles, NumberBuffer ByRef,
System.Text.StringBuilder, System.Globalization.NumberFormatInfo, Boolean)
Class:        798dc1e4
MethodTable:  79ba6a48
mdToken:      06000e20
Module:       79881000
IsJitted:     yes
CodeAddr:     79ac5db0
Transparency: Critical

0:000> !clrstack
OS Thread Id: 0x30 (0)
Child SP IP       Call Site
0032f1a0 79ac5db0 System.Number.ParseNumber(Char* ByRef,
System.Globalization.NumberStyles, NumberBuffer ByRef,
System.Text.StringBuilder, System.Globalization.NumberFormatInfo, Boolean)
0032f1b4 79ac6394 System.Number.TryStringToNumber(System.String,
System.Globalization.NumberStyles, NumberBuffer ByRef,
System.Text.StringBuilder, System.Globalization.NumberFormatInfo, Boolean)
0032f1e0 79b11f12 System.Number.TryParseDouble(System.String,
System.Globalization.NumberStyles, System.Globalization.NumberFormatInfo,
Double ByRef)
0032f2a4 79ac76d3 System.Double.TryParse(System.String,
System.Globalization.NumberStyles, System.Globalization.NumberFormatInfo,
Double ByRef)
0032f2c0 79b22ccc System.Double.TryParse(System.String, Double ByRef)
0032f2d0 003b0182 Example.Main()
0032f538 791421db [GCFrame: 0032f538]

0:000> !DumpIL 799b71d8
ilAddr = 79c1fd28
IL_0000: ldarg.2 
IL_0001: ldc.i4.0 
IL_0002: stfld NumberBuffer::scale
IL_0007: ldarg.2 
IL_0008: ldc.i4.0 
IL_0009: stfld NumberBuffer::sign
IL_000e: ldnull 
IL_000f: stloc.2 
IL_0010: ldnull 
IL_0011: stloc.3 
IL_0012: ldnull 
IL_0013: stloc.s VAR OR ARG 4
IL_0015: ldnull 
IL_0016: stloc.s VAR OR ARG 5
IL_0018: ldc.i4.0 
IL_0019: stloc.s VAR OR ARG 6
IL_001b: ldarg.1 
IL_001c: ldc.i4 256
IL_0021: and 
IL_0022: brfalse.s IL_0064
IL_0024: ldarg.s VAR OR ARG 4
IL_0026: callvirt System.Globalization.NumberFormatInfo::get_CurrencySymbol
IL_002b: stloc.2 
IL_002c: ldarg.s VAR OR ARG 4
IL_002e: ldfld System.Globalization.NumberFormatInfo::ansiCurrencySymbol
IL_0033: brfalse.s IL_003d
IL_0035: ldarg.s VAR OR ARG 4
IL_0037: ldfld System.Globalization.NumberFormatInfo::ansiCurrencySymbol
IL_003c: stloc.3 
IL_003d: ldarg.s VAR OR ARG 4
IL_003f: callvirt
System.Globalization.NumberFormatInfo::get_NumberDecimalSeparator
IL_0044: stloc.s VAR OR ARG 4
IL_0046: ldarg.s VAR OR ARG 4
IL_0048: callvirt
System.Globalization.NumberFormatInfo::get_NumberGroupSeparator
IL_004d: stloc.s VAR OR ARG 5
IL_004f: ldarg.s VAR OR ARG 4
IL_0051: callvirt
System.Globalization.NumberFormatInfo::get_CurrencyDecimalSeparator
IL_0056: stloc.0 
IL_0057: ldarg.s VAR OR ARG 4
IL_0059: callvirt
System.Globalization.NumberFormatInfo::get_CurrencyGroupSeparator
IL_005e: stloc.1 
IL_005f: ldc.i4.1 
IL_0060: stloc.s VAR OR ARG 6
IL_0062: br.s IL_0074
IL_0064: ldarg.s VAR OR ARG 4
IL_0066: callvirt
System.Globalization.NumberFormatInfo::get_NumberDecimalSeparator
IL_006b: stloc.0 
IL_006c: ldarg.s VAR OR ARG 4
IL_006e: callvirt
System.Globalization.NumberFormatInfo::get_NumberGroupSeparator
IL_0073: stloc.1 
IL_0074: ldc.i4.0 
IL_0075: stloc.s VAR OR ARG 7
IL_0077: ldc.i4.0 
IL_0078: stloc.s VAR OR ARG 8

...

0:000> !clrstack -a
OS Thread Id: 0x30 (0)
Child SP IP       Call Site
0032f150 79ac6260 System.Number.MatchChars(Char*, System.String)
    PARAMETERS:
        p (<CLR reg>) = 0x00c91230
        str (<CLR reg>) = 0x00c91748
    LOCALS:
        <no data>
        <no data>
        <no data>

0032f154 79ac5e7d System.Number.ParseNumber(Char* ByRef,
System.Globalization.NumberStyles, NumberBuffer ByRef,
System.Text.StringBuilder, System.Globalization.NumberFormatInfo, Boolean)
    PARAMETERS:
        str (0x0032f16c) = 0x0032f1b8
        options (0x0032f18c) = 0x000000e7
        number (0x0032f1b0) = 0x0032f270
        sb (0x0032f1ac) = 0x00000000
        numfmt (0x0032f1a8) = 0x00c9b584
        parseDecimal (0x0032f1a4) = 0x00000000
    LOCALS:
        0x0032f168 = 0x00c9b6a0
        0x0032f164 = 0x00c9b6b0
        0x0032f160 = 0x00000000
        0x0032f15c = 0x00000000
        0x0032f158 = 0x00000000
        0x0032f154 = 0x00000000
        0x0032f188 = 0x00000000
        <CLR reg> = 0x00000000
        <CLR reg> = 0x00000001
        0x0032f184 = 0x00000000
        0x0032f180 = 0x00000000
        <no data>
        0x0032f17c = 0x00c91230
        <CLR reg> = 0x00000000
        <no data>
        <no data>
        <no data>
        <no data>
        <no data>
        <no data>

...

0:000> !do 0x00c91748
Name:        System.String
MethodTable: 79b9f9ac
EEClass:     798d8bb0
Size:        16(0x10) bytes
File:       
C:\windows\Microsoft.Net\assembly\GAC_32\mscorlib\v4.0_4.0.0.0__b77a5c561934e089\mscorlib.dll
String:      +
Fields:
      MT    Field   Offset                 Type VT     Attr    Value Name
79ba2978  40000ed        4         System.Int32  1 instance        1
m_stringLength
79ba1dc8  40000ee        8          System.Char  1 instance       2b
m_firstChar
79b9f9ac  40000ef        8        System.String  0   shared   static Empty
    >> Domain:Value  001430c0:00c91228 <<
--- snip ---

$ wine --version
wine-4.4

Regards

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #11 from Anastasius Focht  ---
Created attachment 63890
  --> https://bugs.winehq.org/attachment.cgi?id=63890
small prebuilt .NET executable (4.5K) to dump NumberFormat.CurrentInfo object

Hello folks,

I've attached a small .NET executable (4.5K) for easier reproduce.
You don't need .NET SDK/C# compiler.

Built using Microsoft Windows SDK for Windows 7 and .NET Framework 4

https://download.microsoft.com/download/A/6/A/A6AC035D-DA3F-4F0C-ADA4-37C8E5...

--- snip ---
$ wine "c:\windows\Microsoft.NET\Framework\v4.0.30319\csc.exe"
numberformatinfo.cs
--- snip ---

If you are concerned here is the virii scan:

https://www.virustotal.com/#/file/3f24713df62f560b5c0fe936e89b0b909e3a5d313a...

---snip ---
SHA-256    3f24713df62f560b5c0fe936e89b0b909e3a5d313aca9f9c7b729c92b95a4d8f
File name    numberformatinfo.exe
File size    4.5 KB
Last analysis    2019-03-16 13:47:03 UTC
---snip ---

"2 engines detected this file" (out of 69) .. I guess those are the stupid
ones. Snake oil business as usual ;-)

Regards

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #12 from IanS  ---
Just want to make sure I understand - Are you saying that this problem only
affects Wine and only if Windows version is set to Win7 and app is running on
dotnet40?

Or are you saying that this problem would also occurs on a real windows machine
running Win7 with Net4 ?

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #13 from Anastasius Focht  ---
Hello IanS,

--- quote ---
Just want to make sure I understand - Are you saying that this problem only
affects Wine and only if Windows version is set to Win7 and app is running on
dotnet40?
--- quote ---

This. I would assume the problem is with Wine only.
You could run the attached .NET app on Windows 7 or later and post the results
here. Make sure you set en_US.utf8 locale to have comparable results.

Regards

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #14 from IanS  ---
Sorry. Can't run an executable.

I can confirm though that the problem I initially reported does indeed only
occur when Win version is Win7.

My application has its own <b>Val(string s)</b> function that is supposed to
behave something like VB's Val function. It uses TryParse to convert string to
double. It should return 0 if string was empty.

To avoid the problem I simply changed my <b>Val(s)</b> code to test for empty
string before doing anything and return 0 if string empty.

As far as I'm concerned the problem is fixed.

But it would be great if there was a list of all other things like this. I
could then workaround them all in my application before posting it to your
AppDB

Anyway. Thank you.

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

[WineHQ Bugzilla]

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #15 from Nikolay Sivov  ---
With current wine/win7/en_US.UTF-8 test program gives me:

---
Properties of NumberFormat.CurrentInfo object:
   CurrencyDecimalDigits: 2
   CurrencyDecimalSeparator: .
   IsReadOnly: True
   CurrencyGroupSizes: { 3 }
   NumberGroupSizes: { 3 }
   PercentGroupSizes: { 3 }
   CurrencyGroupSeparator: ,
   CurrencySymbol: $
   NaNSymbol: NaN
   CurrencyNegativePattern: 0
   NumberNegativePattern: 1
   PercentPositivePattern: 1
   PercentNegativePattern: 1
   NegativeInfinitySymbol: -∞
   NegativeSign: -
   NumberDecimalDigits: 2
   NumberDecimalSeparator: .
   NumberGroupSeparator: ,
   CurrencyPositivePattern: 0
   PositiveInfinitySymbol: ∞
   PositiveSign: +
   PercentDecimalDigits: 2
   PercentDecimalSeparator: .
   PercentGroupSeparator: ,
   PercentSymbol: %
   PerMilleSymbol: %
   NativeDigits: { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
   DigitSubstitution: None
---

So at least missing fields are returned now. Will try parsing example from
comment 4 now.

[Bug 46842] C# double.TryParse( String.Empty, out number) succeeds with .NET Framework 4.0 when it should not

[WineHQ Bugzilla]

https://bugs.winehq.org/show_bug.cgi?id=46842

--- Comment #16 from Nikolay Sivov  ---
I don't see any difference in parsing sample output, comparing Windows to Wine
with .NET 4.6.2/Win7 prefix. Please retest.

[Bug 46842] C# 'double.TryParse( String.Empty, out number)' incorrectly succeeds with .NET Framework 4.0 and WinVer set to 'Windows 7'

[WineHQ Bugzilla]

https://bugs.winehq.org/show_bug.cgi?id=46842

Anastasius Focht  changed:

What    |Removed                     |Added
----------------------------------------------------------------------------
            Summary|C# double.TryParse(         |C# 'double.TryParse(
                   |String.Empty, out number)   |String.Empty, out number)'
                   |succeeds with .NET          |incorrectly succeeds with
                   |Framework 4.0 when it       |.NET Framework 4.0 and
                   |should not                  |WinVer set to 'Windows 7'
         Resolution|---                         |FIXED
             Status|NEW                         |RESOLVED
           Hardware|x86                         |x86-64
      Fixed by SHA1|                            |e14249a364311c138439b16f3f7
                   |                            |9586a18a05f7b
           Keywords|                            |testcase

--- Comment #17 from Anastasius Focht  ---
Hello folks,

this was fixed by commits:

*
https://source.winehq.org/git/wine.git/commitdiff/e14249a364311c138439b16f3f...
("kernel32/nls: Add locale data for positive and negative infinity.")

*
https://source.winehq.org/git/wine.git/commitdiff/5d2914b2c2386b8ccc9cfcd16f...
("kernel32/nls: Add percent formatting values.")

*
https://source.winehq.org/git/wine.git/commitdiff/ce82e5e883f4e3bc79d5b2dc15...
("kernel32/nls: Add LOCALE_SPERMILLE data.")

*
https://source.winehq.org/git/wine.git/commitdiff/c9b135cc8888025d7d2dc613c2...
("kernel32/nls: Add LOCALE_SPERCENT locale data.")

Part of Wine 4.13

Thanks Nikolay

$ wine --version
wine-4.21-413-g750d382f54

Regards

[Bug 46842] C# 'double.TryParse( String.Empty, out number)' incorrectly succeeds with .NET Framework 4.0 and WinVer set to 'Windows 7'

[WineHQ Bugzilla]

https://bugs.winehq.org/show_bug.cgi?id=46842

Alexandre Julliard  changed:

What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|RESOLVED                    |CLOSED

--- Comment #18 from Alexandre Julliard  ---
Closing bugs fixed in 5.0-rc1.