converter/tests/testIntegerNaN.cpp at main · panchaBhuta/converter · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

// test NaN conversion exceptions for integer-types


#include <iostream>
#include <cmath>

#include <converter/converter.h>

#include "unittest.h"

template <typename T, converter::FailureS2Tprocess EP>
using _ConvS2T_CtoT = converter::ConvertFromStr<T, converter::S2T_Format_std_CtoT<T, EP>>;

template <typename T, converter::FailureS2Tprocess EP>
using _ConvS2T_StoT = converter::ConvertFromStr<T, converter::S2T_Format_std_StoT<T, EP>>;

template <typename T, converter::FailureS2Tprocess EP>
using _ConvS2T_ISS = converter::ConvertFromStr<T, converter::S2T_Format_StreamUseClassicLocale<T, EP, char>>;

template <typename T>
using _ConvT2S_TtoC = converter::ConvertFromVal<T, converter::T2S_Format_std_TtoC>;

template <typename T>
using _ConvT2S_TtoS = converter::ConvertFromVal<T, converter::T2S_Format_StreamDecimalPrecision<T>>;

template <typename T>
using _ConvT2S_OSS = converter::ConvertFromVal<T, converter::T2S_Format_StreamUseClassicLocale<char>>;


template<converter::c_integer_type T>
void checkConversionTemplateInstances()
{
  static_assert(std::is_same_v<typename converter::S2T_DefaultFormat<T>::type,
                                        converter::S2T_Format_std_CtoT<T, converter::FailureS2Tprocess::THROW_ERROR>>);

  static_assert(std::is_same_v<typename converter::T2S_DefaultFormat<T>::type,
                                        converter::T2S_Format_std_TtoC>);

  static_assert(converter::ConvertFromStr<T>::template_uid ==  102);
  static_assert(converter::ConvertFromVal<T>::template_uid == -102);
}

template <typename T>
void conversion_String2Integer_FailureCheck(const std::string& vStr)
{
  {
    ExpectException(_ConvS2T_CtoT<T COMMA converter::FailureS2Tprocess::THROW_ERROR>::ToVal(vStr), std::invalid_argument);

    typename converter::OnError<T, converter::FailureS2Tprocess::VARIANT_NAN>::return_type varT =
      _ConvS2T_CtoT<T , converter::FailureS2Tprocess::VARIANT_NAN>::ToVal(vStr);
    unittest::ExpectTrue(varT.index() == 1);
    unittest::ExpectEqual(std::string, std::get<std::string>(varT), vStr);
  }

  {
    ExpectException(_ConvS2T_StoT<T COMMA converter::FailureS2Tprocess::THROW_ERROR>::ToVal(vStr), std::invalid_argument);
    typename converter::OnError<T, converter::FailureS2Tprocess::VARIANT_NAN>::return_type varT =
      _ConvS2T_StoT<T , converter::FailureS2Tprocess::VARIANT_NAN>::ToVal(vStr);
    unittest::ExpectTrue(varT.index() == 1);
    unittest::ExpectEqual(std::string, std::get<std::string>(varT), vStr);
  }

  {
    ExpectException(_ConvS2T_ISS<T COMMA converter::FailureS2Tprocess::THROW_ERROR>::ToVal(vStr), std::invalid_argument);

    typename converter::OnError<T, converter::FailureS2Tprocess::VARIANT_NAN>::return_type varT =
      _ConvS2T_ISS<T , converter::FailureS2Tprocess::VARIANT_NAN>::ToVal(vStr);
    unittest::ExpectTrue(varT.index() == 1);
    unittest::ExpectEqual(std::string, std::get<std::string>(varT), vStr);
  }
}

template <typename T>
void conversion_IntegerNAN2String_FailureCheck(const std::string& vStr)
{
  {
    unittest::ExpectEqual(std::string, converter::ConvertFromVal< std::variant<T COMMA std::string> COMMA
                                                                  converter::T2S_Format_std_TtoC
                                                    >::ToStr(std::variant<T COMMA std::string>{vStr}),
                                       vStr);
    unittest::ExpectEqual(std::string, converter::ConvertFromVal< std::variant<T COMMA std::string> COMMA
                                                                  converter::T2S_Format_std_TtoC
                                                    >::ToStr(std::variant<T COMMA std::string>{vStr}),
                                       vStr);
  }

  {
    unittest::ExpectEqual(std::string, converter::ConvertFromVal< std::variant<T COMMA std::string> COMMA
                                                                  converter::T2S_Format_StreamUseClassicLocale<char>
                                                    >::ToStr(std::variant<T COMMA std::string>{vStr}),
                                       vStr);
    unittest::ExpectEqual(std::string, converter::ConvertFromVal< std::variant<T COMMA std::string> COMMA
                                                                  converter::T2S_Format_StreamUseClassicLocale<char>
                                                    >::ToStr(std::variant<T COMMA std::string>{vStr}),
                                       vStr);
  }
}


int main()
{
  checkConversionTemplateInstances<short>();
  checkConversionTemplateInstances<int>();
  checkConversionTemplateInstances<long>();
  checkConversionTemplateInstances<long long>();
  checkConversionTemplateInstances<unsigned short>();
  checkConversionTemplateInstances<unsigned int>();
  checkConversionTemplateInstances<unsigned long>();
  checkConversionTemplateInstances<unsigned long long>();

  int rv = 0;
  try {
    // [========[  String to Integer-NaN
    conversion_String2Integer_FailureCheck<short>("rc");
    conversion_String2Integer_FailureCheck<int>("ab");
    conversion_String2Integer_FailureCheck<long>("xy");
    conversion_String2Integer_FailureCheck<long long>("xy");

    conversion_String2Integer_FailureCheck<short>("1.2x1");
    conversion_String2Integer_FailureCheck<int>("2.3.4");
    conversion_String2Integer_FailureCheck<long>("3r.422123445");
    conversion_String2Integer_FailureCheck<long long>("3r.422123445");
    // ]========]  String to Integer-NaN

    // [========[  Integer-NaN to String
    conversion_IntegerNAN2String_FailureCheck<short>("rc");
    conversion_IntegerNAN2String_FailureCheck<int>("ab");
    conversion_IntegerNAN2String_FailureCheck<long>("xy");
    conversion_IntegerNAN2String_FailureCheck<long long>("xy");

    conversion_IntegerNAN2String_FailureCheck<short>("1.2x1");
    conversion_IntegerNAN2String_FailureCheck<int>("2.3.4");
    conversion_IntegerNAN2String_FailureCheck<long>("3r.422123445");
    conversion_IntegerNAN2String_FailureCheck<long long>("3r.422123445");
    // ]========]  Integer-NaN to String
  } catch (const std::exception& ex) {
    std::cout << "Test Failed : err-msg : " << ex.what() << std::endl;
    rv = 1;
  }

  return rv;
}