private void CheckParseHexFloat64(NativeStringList str_native_big, NativeStringList str_native_lit)
{
// double hex
double[] double_list = new double[]
{
0.0, 128.0, 512.0, 12345.67, -12345678,
-9223372036854775808d, 9223372036854775807d,
-3.40281e+38, 3.40281E+38,
-1.797693134862e+308, 1.797693134862E+308
};
str_native_big.Clear();
str_native_lit.Clear();
for (int i = 0; i < double_list.Length; i++)
{
double double_v = double_list[i];
byte[] bytes = BitConverter.GetBytes(double_v);
string str = BitConverter.ToString(bytes).Replace("-", ""); // BitConverter returns little endian code on x86.
string str_0x = "0x" + str;
str_native_lit.Add(str);
str_native_lit.Add(str_0x);
str_native_big.Add(this.ConvertEndian(str));
str_native_big.Add(this.ConvertEndian(str_0x));
}
for (int i = 0; i < str_native_lit.Length; i++)
{
double value_ref = double_list[i / 2];
ReadOnlyStringEntity str_lit = str_native_lit[i];
ReadOnlyStringEntity str_big = str_native_big[i];
bool success_lit = str_lit.TryParseHex(out double value_lit);
bool success_big = str_big.TryParseHex(out double value_big, Endian.Big);
Debug.Log("parse str[big/little] = [" + str_big.ToString() + "/" + str_lit.ToString()
+ "], try[big/little] = [" + success_big.ToString() + "/" + success_lit.ToString()
+ "], value[ref/big/little] = [" + value_ref.ToString() + "/" + value_big.ToString() + "/" + value_lit.ToString() + "]");
Assert.IsTrue(success_lit);
Assert.IsTrue(success_big);
Assert.AreEqual(value_ref, value_lit);
Assert.AreEqual(value_ref, value_big);
// must be bit-complete convertion in hex data format
if ((value_ref != value_lit || value_ref != value_big) || !success_lit || !success_big)
{
Debug.LogError("failed to parse. i = " + i.ToString()
+ " string [big/little] = [" + str_big.ToString() + "/" + str_lit.ToString()
+ "], try[big/little] = [" + success_big.ToString() + "/" + success_lit.ToString()
+ "], value[ref/big/little] = [" + value_ref.ToString() + "/" + value_big.ToString() + "/" + value_lit.ToString() + "]");
}
}
}
private void CheckParseHexFloat32(NativeStringList str_native_big, NativeStringList str_native_lit)
{
// float hex
float[] float_list = new float[] { 0.0f, 128.0f, 512.0f, 12345.67f, -12345678f, -3.40281e+38f, 3.40281E+38f };
str_native_big.Clear();
str_native_lit.Clear();
for (int i = 0; i < float_list.Length; i++)
{
float float_v = float_list[i];
byte[] bytes = BitConverter.GetBytes(float_v);
string str = BitConverter.ToString(bytes).Replace("-", ""); // BitConverter returns little endian code on x86.
string str_0x = "0x" + str;
str_native_lit.Add(str);
str_native_lit.Add(str_0x);
str_native_big.Add(this.ConvertEndian(str));
str_native_big.Add(this.ConvertEndian(str_0x));
}
for (int i = 0; i < str_native_lit.Length; i++)
{
float value_ref = float_list[i / 2];
ReadOnlyStringEntity str_lit = str_native_lit[i];
ReadOnlyStringEntity str_big = str_native_big[i];
bool success_lit = str_lit.TryParseHex(out float value_lit);
bool success_big = str_big.TryParseHex(out float value_big, Endian.Big);
Debug.Log("parse str[big/little] = [" + str_big.ToString() + "/" + str_lit.ToString()
+ "], try[big/little] = [" + success_big.ToString() + "/" + success_lit.ToString()
+ "], value[ref/big/little] = [" + value_ref.ToString() + "/" + value_big.ToString() + "/" + value_lit.ToString() + "]");
Assert.IsTrue(success_lit);
Assert.IsTrue(success_big);
Assert.AreEqual(value_ref, value_lit);
Assert.AreEqual(value_ref, value_big);
// must be bit-complete convertion in hex data format
if ((value_ref != value_lit || value_ref != value_big) || !success_lit || !success_big)
{
Debug.LogError("failed to parse. i = " + i.ToString()
+ " string [big/little] = [" + str_big.ToString() + "/" + str_lit.ToString()
+ "], try[big/little] = [" + success_big.ToString() + "/" + success_lit.ToString()
+ "], value[ref/big/little] = [" + value_ref.ToString() + "/" + value_big.ToString() + "/" + value_lit.ToString() + "]");
}
}
}
private void CheckParseHexInt32(NativeStringList str_native_big, NativeStringList str_native_lit)
{
// int hex
int[] int_list = new int[] { 0, 128, 512, 10000, -12345678, -2147483648, 2147483647 };
str_native_big.Clear();
str_native_lit.Clear();
for (int i = 0; i < int_list.Length; i++)
{
int int_v = int_list[i];
byte[] bytes = BitConverter.GetBytes(int_v);
string str = BitConverter.ToString(bytes).Replace("-", ""); // BitConverter returns little endian code on x86.
string str_0x = "0x" + str;
str_native_lit.Add(str);
str_native_lit.Add(str_0x);
str_native_big.Add(this.ConvertEndian(str));
str_native_big.Add(this.ConvertEndian(str_0x));
}
for (int i = 0; i < str_native_lit.Length; i++)
{
int value_ref = int_list[i / 2]; // stored 2x elems as [hex data] and 0x[hex data]
ReadOnlyStringEntity str_lit = str_native_lit[i];
ReadOnlyStringEntity str_big = str_native_big[i];
bool success_lit = str_lit.TryParseHex(out int value_lit);
bool success_big = str_big.TryParseHex(out int value_big, Endian.Big);
Debug.Log("parse str[big/little] = [" + str_big.ToString() + "/" + str_lit.ToString()
+ "], try[big/little] = [" + success_big.ToString() + "/" + success_lit.ToString()
+ "], value[ref/big/little] = [" + value_ref.ToString() + "/" + value_big.ToString() + "/" + value_lit.ToString() + "]");
Assert.IsTrue(success_lit);
Assert.IsTrue(success_big);
Assert.AreEqual(value_ref, value_lit);
Assert.AreEqual(value_ref, value_big);
if ((value_ref != value_lit || value_ref != value_big) || !success_lit || !success_big)
{
Debug.LogError("failed to parse. i = " + i.ToString()
+ " string [big/little] = [" + str_big.ToString() + "/" + str_lit.ToString()
+ "], try[big/little] = [" + success_big.ToString() + "/" + success_lit.ToString()
+ "], value[ref/big/little] = [" + value_ref.ToString() + "/" + value_big.ToString() + "/" + value_lit.ToString() + "]");
}
}
}
private void CheckParseHexInt64(NativeStringList str_native_big, NativeStringList str_native_lit)
{
// long hex
long[] long_list = new long[] { 0, 128, 512, 10000, -12345678, -9223372036854775808, 9223372036854775807 };
str_native_big.Clear();
str_native_lit.Clear();
for (int i = 0; i < long_list.Length; i++)
{
long long_v = long_list[i];
byte[] bytes = BitConverter.GetBytes(long_v);
string str = BitConverter.ToString(bytes).Replace("-", ""); // BitConverter returns little endian code on x86.
string str_0x = "0x" + str;
str_native_lit.Add(str);
str_native_lit.Add(str_0x);
str_native_big.Add(this.ConvertEndian(str));
str_native_big.Add(this.ConvertEndian(str_0x));
}
for (int i = 0; i < str_native_lit.Length; i++)
{
long value_ref = long_list[i / 2];
ReadOnlyStringEntity str_lit = str_native_lit[i];
ReadOnlyStringEntity str_big = str_native_big[i];
bool success_lit = str_lit.TryParseHex(out long value_lit);
bool success_big = str_big.TryParseHex(out long value_big, Endian.Big);
Debug.Log("parse str[big/little] = [" + str_big.ToString() + "/" + str_lit.ToString()
+ "], try[big/little] = [" + success_big.ToString() + "/" + success_lit.ToString()
+ "], value[ref/big/little] = [" + value_ref.ToString() + "/" + value_big.ToString() + "/" + value_lit.ToString() + "]");
Assert.IsTrue(success_lit);
Assert.IsTrue(success_big);
Assert.AreEqual(value_ref, value_lit);
Assert.AreEqual(value_ref, value_big);
if ((value_ref != value_lit || value_ref != value_big) || !success_lit || !success_big)
{
Debug.LogError("failed to parse. i = " + i.ToString()
+ " string [big/little] = [" + str_big.ToString() + "/" + str_lit.ToString()
+ "], try[big/little] = [" + success_big.ToString() + "/" + success_lit.ToString()
+ "], value[ref/big/little] = [" + value_ref.ToString() + "/" + value_big.ToString() + "/" + value_lit.ToString() + "]");
}
}
}
public void CheckParseInt64_Boundary()
{
// boundary value check
str_native.Clear();
str_list.Clear();
string in_range_lo = "-9223372036854775808";
string in_range_hi = "9223372036854775807";
string out_range_lo = "-9223372036854775809";
string out_range_hi = "9223372036854775808";
str_list.Add(in_range_lo.ToString());
str_list.Add(in_range_hi.ToString());
str_list.Add(out_range_lo.ToString());
str_list.Add(out_range_hi.ToString());
for (int i = 0; i < str_list.Count; i++)
{
str_native.Add(str_list[i]);
}
for (int i = 0; i < str_native.Length; i++)
{
var str = str_list[i];
ReadOnlyStringEntity str_e = str_native[i];
bool success = long.TryParse(str, out long value);
bool success_e = str_e.TryParse(out long value_e);
Assert.AreEqual(success, success_e);
Assert.AreEqual(value, value_e);
if (success != success_e || value != value_e)
{
Debug.LogError("failed to parse. string [str/entity] = [" + str + "/" + str_e.ToString() + "]"
+ "bool [str/entity] = [" + success.ToString() + "/" + success_e.ToString() + "], "
+ "value [str/entity] = [" + value.ToString() + "/" + value_e.ToString() + "]");
}
}
}
public void CheckParseInt32_Boundary()
{
// boundary value check
str_native.Clear();
str_list.Clear();
string in_range_lo = "-2147483648";
string in_range_hi = "2147483647";
string out_range_lo = "-2147483649";
string out_range_hi = "2147483648";
string out_sp_1 = "4400000000"; // overflow to plus region
str_list.Add(in_range_lo.ToString());
str_list.Add(in_range_hi.ToString());
str_list.Add(out_range_lo.ToString());
str_list.Add(out_range_hi.ToString());
str_list.Add(out_sp_1.ToString());
for (int i = 0; i < str_list.Count; i++)
{
str_native.Add(str_list[i]);
}
for (int i = 0; i < str_native.Length; i++)
{
var str = str_list[i];
ReadOnlyStringEntity str_e = str_native[i];
bool success = int.TryParse(str, out int value);
bool success_e = str_e.TryParse(out int value_e);
Assert.AreEqual(success, success_e);
Assert.AreEqual(value, value_e);
if (success != success_e || value != value_e)
{
Debug.LogError("failed to parse. string [str/entity] = [" + str + "/" + str_e.ToString() + "]"
+ "bool [str/entity] = [" + success.ToString() + "/" + success_e.ToString() + "], "
+ "value [str/entity] = [" + value.ToString() + "/" + value_e.ToString() + "]");
}
}
}
public void CheckParseFloat64(int n_numeric_string)
{
this.GenerateRandomFloatStrings(n_numeric_string, 2, 18, 309, 64);
double max_rel_err = 0.0;
int max_err_id = 0;
int double_count = 0;
for (int i = 0; i < n_numeric_string; i++)
{
string str = str_list[i];
ReadOnlyStringEntity str_e = str_native[i];
bool success = double.TryParse(str, out double value);
bool success_e = str_e.TryParse(out double value_e);
//Debug.Log($"@ parse target: {str_e}");
Assert.AreEqual(success, success_e);
bool check_value = this.EqualsDouble(value, value_e, 1.0e-14, out double rel_diff);
if (!check_value || success != success_e)
{
Debug.LogError("failed to parse i = " + i.ToString() + " string [str/entity] = [" + str + "/" + str_e.ToString() + "]"
+ "bool [str/entity] = [" + success.ToString() + "/" + success_e.ToString() + "], "
+ "value [str/entity] = [" + value.ToString() + "/" + value_e.ToString() + "], rel_diff = " + rel_diff.ToString());
}
Assert.IsTrue(check_value);
if (success)
{
double_count++;
}
if (max_rel_err < rel_diff)
{
max_rel_err = rel_diff;
max_err_id = i;
}
}
Debug.Log("parsed double count = " + double_count.ToString() + " / " + n_numeric_string.ToString());
Debug.Log("max relative error = " + max_rel_err.ToString() + " at " + str_list[max_err_id]);
}
public void CheckParseFloat32(int n_numeric_string)
{
this.GenerateRandomFloatStrings(n_numeric_string, 3, 8, 39, 64);
int fail_count = 0;
float max_rel_err = 0.0f;
int max_err_id = 0;
int float_count = 0;
for (int i = 0; i < n_numeric_string; i++)
{
string str = str_list[i];
ReadOnlyStringEntity str_e = str_native[i];
bool success = float.TryParse(str, out float value);
bool success_e = str_e.TryParse(out float value_e);
Assert.AreEqual(success, success_e);
bool check_value = this.EqualsFloat(value, value_e, 1.0e-5f, out float rel_diff);
if (!check_value || success != success_e)
{
fail_count++;
Debug.LogError("failed to parse i = " + i.ToString() + " string [str/entity] = [" + str + "/" + str_e.ToString() + "]"
+ "bool [str/entity] = [" + success.ToString() + "/" + success_e.ToString() + "], "
+ "value [str/entity] = [" + value.ToString() + "/" + value_e.ToString() + "], rel_diff = " + rel_diff.ToString());
}
Assert.IsTrue(check_value);
if (success)
{
float_count++;
}
if (max_rel_err < rel_diff)
{
max_rel_err = rel_diff;
max_err_id = i;
}
}
Debug.Log("parsed float count = " + float_count.ToString() + " / " + n_numeric_string.ToString());
Debug.Log("max relative error = " + max_rel_err.ToString() + " at " + str_list[max_err_id]);
}
public void CheckParseInt64(int n_numeric_string)
{
// random value check
this.GenerateRandomIntStrings(n_numeric_string, 9, 19, 128);
int long_count = 0;
for (int i = 0; i < n_numeric_string; i++)
{
string str = str_list[i];
ReadOnlyStringEntity str_e = str_native[i];
bool success = long.TryParse(str, out long value);
bool success_e = str_e.TryParse(out long value_e);
Assert.AreEqual(success, success_e);
Assert.AreEqual(value, value_e);
if (success != success_e || value != value_e)
{
Debug.LogError("failed to parse. string [str/entity] = [" + str + "/" + str_e.ToString() + "]"
+ "bool [str/entity] = [" + success.ToString() + "/" + success_e.ToString() + "], "
+ "value [str/entity] = [" + value.ToString() + "/" + value_e.ToString() + "]");
}
if (success)
{
long_count++;
}
}
Debug.Log("parsed long count = " + long_count.ToString() + " / " + n_numeric_string.ToString());
}
public void CheckParseFloat64_Boundary()
{
// boundary value check
str_native.Clear();
str_list.Clear();
string in_range_lo = "-1.797693134862e+308";
string in_range_hi = "1.797693134862E+308";
string out_range_lo = "-1.797693134863e+308";
string out_range_hi = "1.797693134863E+308";
str_list.Add(in_range_lo.ToString());
str_list.Add(in_range_hi.ToString());
str_list.Add(out_range_lo.ToString());
str_list.Add(out_range_hi.ToString());
// this implementation don't aim perfect accuracy for IEEE754 convertion.
// Epsilon = 4.94065645841247e-324
str_list.Add("1e-323");
str_list.Add("-1e-323");
str_list.Add("1e-325");
str_list.Add("-1e-325");
str_list.Add("00924731130.63782E+299");
for (int i = 0; i < str_list.Count; i++)
{
str_native.Add(str_list[i]);
}
for (int i = 0; i < str_native.Length; i++)
{
var str = str_list[i];
ReadOnlyStringEntity str_e = str_native[i];
bool success = double.TryParse(str, out double value);
bool success_e = str_e.TryParse(out double value_e);
Assert.AreEqual(success, success_e);
bool check_value = this.EqualsDouble(value, value_e, 1.0e-14, out double rel_diff);
if (!check_value || success != success_e)
{
Debug.LogError("failed to parse. i = " + i.ToString() + " string [str/entity] = [" + str + "/" + str_e.ToString() + "]"
+ "bool [str/entity] = [" + success.ToString() + "/" + success_e.ToString() + "], "
+ "value [str/entity] = [" + value.ToString() + "/" + value_e.ToString() + "], rel_diff = " + rel_diff.ToString());
}
Assert.IsTrue(check_value);
}
}
public void CheckParseFloat32_Typical()
{
// typical format sample
str_native.Clear();
str_list.Clear();
str_list.Add("12345678987654321");
str_list.Add("-12345678987654321");
str_list.Add("123456789.87654321");
str_list.Add("-123456789.87654321");
str_list.Add("12345678987654321e-5");
str_list.Add("-12345678987654321E-5");
str_list.Add("123456789.87654321e-5");
str_list.Add("-123456789.87654321E-5");
str_list.Add("000.00123456789e-5");
str_list.Add("-000.00123456789E-5");
str_list.Add("1.11111111e-60");
str_list.Add("-1.11111111e-60");
str_list.Add("4E+08");
str_list.Add("3E+08");
str_list.Add("0E+0");
str_list.Add("000E-00");
str_list.Add("321.98e22");
str_list.Add("123E+00000000000000000000221");
str_list.Add("123E-00000000000000000000221");
str_list.Add("123E+00000000000000000000221777");
str_list.Add("123E-00000000000000000000221777");
str_list.Add("e");
str_list.Add(".01234e+2");
str_list.Add("6633.11e+");
str_list.Add("6633.11e-+-4");
str_list.Add("123E+0000000000Kg00000000022");
for (int i = 0; i < str_list.Count; i++)
{
str_native.Add(str_list[i]);
}
for (int i = 0; i < str_native.Length; i++)
{
var str = str_list[i];
ReadOnlyStringEntity str_e = str_native[i];
//Debug.Log($"@ parse target: {str_e}");
bool success = float.TryParse(str, out float value);
bool success_e = str_e.TryParse(out float value_e);
Assert.AreEqual(success, success_e);
bool check_value = this.EqualsFloat(value, value_e, 1.0e-5f, out float rel_diff);
if (!check_value || success != success_e)
{
Debug.LogError("failed to parse. i = " + i.ToString() + " string [str/entity] = [" + str + "/" + str_e.ToString() + "]"
+ "bool [str/entity] = [" + success.ToString() + "/" + success_e.ToString() + "], "
+ "value [str/entity] = [" + value.ToString() + "/" + value_e.ToString() + "], rel_diff = " + rel_diff.ToString());
}
Assert.IsTrue(check_value);
}
}
public void CheckParseFloat32_Boundary()
{
// boundary value check
str_native.Clear();
str_list.Clear();
string in_range_lo = "-3.40281e+38";
string in_range_hi = "3.40281E+38";
string out_range_lo = "-3.40283e+38";
string out_range_hi = "3.40283E+38";
str_list.Add(in_range_lo.ToString());
str_list.Add(in_range_hi.ToString());
str_list.Add(out_range_lo.ToString());
str_list.Add(out_range_hi.ToString());
str_list.Add("1.401298e-45"); // float.Elipson
str_list.Add("-1.401298e-45");
str_list.Add("1.401297e-45");
str_list.Add("-1.401297e-45");
for (int i = 0; i < str_list.Count; i++)
{
str_native.Add(str_list[i]);
}
for (int i = 0; i < str_native.Length; i++)
{
var str = str_list[i];
ReadOnlyStringEntity str_e = str_native[i];
//Debug.Log($"@ parse target: {str_e}");
bool success = float.TryParse(str, out float value);
bool success_e = str_e.TryParse(out float value_e);
Assert.AreEqual(success, success_e);
bool check_value = this.EqualsFloat(value, value_e, 1.0e-5f, out float rel_diff);
if (!check_value || success != success_e)
{
Debug.LogError("failed to parse. i = " + i.ToString() + " string [str/entity] = [" + str + "/" + str_e.ToString() + "]"
+ "bool [str/entity] = [" + success.ToString() + "/" + success_e.ToString() + "], "
+ "value [str/entity] = [" + value.ToString() + "/" + value_e.ToString() + "], rel_diff = " + rel_diff.ToString());
}
Assert.IsTrue(check_value);
}
}
