1
|
|
#region Copyright
|
2
|
|
|
3
|
|
|
4
|
|
|
5
|
|
|
6
|
|
|
7
|
|
|
8
|
|
|
9
|
|
|
10
|
|
|
11
|
|
|
12
|
|
|
13
|
|
|
14
|
|
|
15
|
|
|
16
|
|
|
17
|
|
#endregion
|
18
|
|
|
19
|
|
using System;
|
20
|
|
using System.Data.SqlTypes;
|
21
|
|
using NUnit.Framework;
|
22
|
|
using Seasar.Framework.Util;
|
23
|
|
using Nullables;
|
24
|
|
|
25
|
|
namespace Seasar.Tests.Framework.Util
|
26
|
|
{
|
27
|
|
[TestFixture]
|
28
|
|
public class ConversionUtilTest
|
29
|
|
{
|
30
|
1
|
[Test]
|
31
|
|
public void TestConvertNullable_SqlBinary()
|
32
|
|
{
|
33
|
1
|
SqlBinary ret = (SqlBinary) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlBinary));
|
34
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
35
|
1
|
ret = (SqlBinary) ConversionUtil.ConvertNullable(null, typeof(SqlBinary));
|
36
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
37
|
1
|
ret = (SqlBinary) ConversionUtil.ConvertNullable(new byte[] { 1, 2, 3}, typeof(SqlBinary));
|
38
|
1
|
Assert.AreEqual(new SqlBinary(new byte[] { 1, 2, 3}), ret, "3");
|
39
|
|
}
|
40
|
|
|
41
|
1
|
[Test]
|
42
|
|
public void TestConvertNullable_SqlInt64()
|
43
|
|
{
|
44
|
1
|
SqlInt64 ret = (SqlInt64) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlInt64));
|
45
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
46
|
1
|
ret = (SqlInt64) ConversionUtil.ConvertNullable(null, typeof(SqlInt64));
|
47
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
48
|
1
|
ret = (SqlInt64) ConversionUtil.ConvertNullable(12345, typeof(SqlInt64));
|
49
|
1
|
Assert.AreEqual(new SqlInt64(12345), ret, "3");
|
50
|
|
}
|
51
|
|
|
52
|
1
|
[Test]
|
53
|
|
public void TestConvertNullable_SqlString()
|
54
|
|
{
|
55
|
1
|
SqlString ret = (SqlString) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlString));
|
56
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
57
|
1
|
ret = (SqlString) ConversionUtil.ConvertNullable(null, typeof(SqlString));
|
58
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
59
|
1
|
ret = (SqlString) ConversionUtil.ConvertNullable("aiueo", typeof(SqlString));
|
60
|
1
|
Assert.AreEqual(new SqlString("aiueo"), ret, "3");
|
61
|
|
}
|
62
|
|
|
63
|
1
|
[Test]
|
64
|
|
public void TestConvertNullable_SqlDateTime()
|
65
|
|
{
|
66
|
1
|
SqlDateTime ret = (SqlDateTime) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlDateTime));
|
67
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
68
|
1
|
ret = (SqlDateTime) ConversionUtil.ConvertNullable(null, typeof(SqlDateTime));
|
69
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
70
|
1
|
ret = (SqlDateTime) ConversionUtil.ConvertNullable(new DateTime(2006, 3, 14), typeof(SqlDateTime));
|
71
|
1
|
Assert.AreEqual(new SqlDateTime(new DateTime(2006, 3, 14)), ret, "3");
|
72
|
|
}
|
73
|
|
|
74
|
1
|
[Test]
|
75
|
|
public void TestConvertNullable_SqlDecimal()
|
76
|
|
{
|
77
|
1
|
SqlDecimal ret = (SqlDecimal) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlDecimal));
|
78
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
79
|
1
|
ret = (SqlDecimal) ConversionUtil.ConvertNullable(null, typeof(SqlDecimal));
|
80
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
81
|
1
|
ret = (SqlDecimal) ConversionUtil.ConvertNullable(3, typeof(SqlDecimal));
|
82
|
1
|
Assert.AreEqual(new SqlDecimal(3), ret, "3");
|
83
|
|
}
|
84
|
|
|
85
|
1
|
[Test]
|
86
|
|
public void TestConvertNullable_SqlDouble()
|
87
|
|
{
|
88
|
1
|
SqlDouble ret = (SqlDouble) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlDouble));
|
89
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
90
|
1
|
ret = (SqlDouble) ConversionUtil.ConvertNullable(null, typeof(SqlDouble));
|
91
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
92
|
1
|
ret = (SqlDouble) ConversionUtil.ConvertNullable(3.1415, typeof(SqlDouble));
|
93
|
1
|
Assert.AreEqual(new SqlDouble(3.1415), ret, "3");
|
94
|
|
}
|
95
|
|
|
96
|
1
|
[Test]
|
97
|
|
public void TestConvertNullable_SqlInt32()
|
98
|
|
{
|
99
|
1
|
SqlInt32 ret = (SqlInt32) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlInt32));
|
100
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
101
|
1
|
ret = (SqlInt32) ConversionUtil.ConvertNullable(null, typeof(SqlInt32));
|
102
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
103
|
1
|
ret = (SqlInt32) ConversionUtil.ConvertNullable(10310712, typeof(SqlInt32));
|
104
|
1
|
Assert.AreEqual(new SqlInt32(10310712), ret, "3");
|
105
|
|
}
|
106
|
|
|
107
|
1
|
[Test]
|
108
|
|
public void TestConvertNullable_SqlMoney()
|
109
|
|
{
|
110
|
1
|
SqlMoney ret = (SqlMoney) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlMoney));
|
111
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
112
|
1
|
ret = (SqlMoney) ConversionUtil.ConvertNullable(null, typeof(SqlMoney));
|
113
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
114
|
1
|
ret = (SqlMoney) ConversionUtil.ConvertNullable(10310712, typeof(SqlMoney));
|
115
|
1
|
Assert.AreEqual(new SqlMoney(10310712), ret, "3");
|
116
|
|
}
|
117
|
|
|
118
|
1
|
[Test]
|
119
|
|
public void TestConvertNullable_SqlSingle()
|
120
|
|
{
|
121
|
1
|
SqlSingle ret = (SqlSingle) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlSingle));
|
122
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
123
|
1
|
ret = (SqlSingle) ConversionUtil.ConvertNullable(null, typeof(SqlSingle));
|
124
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
125
|
1
|
ret = (SqlSingle) ConversionUtil.ConvertNullable(250.1, typeof(SqlSingle));
|
126
|
1
|
Assert.AreEqual(new SqlSingle(250.1), ret, "3");
|
127
|
|
}
|
128
|
|
|
129
|
1
|
[Test]
|
130
|
|
public void TestConvertNullable_SqlInt16()
|
131
|
|
{
|
132
|
1
|
SqlInt16 ret = (SqlInt16) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlInt16));
|
133
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
134
|
1
|
ret = (SqlInt16) ConversionUtil.ConvertNullable(null, typeof(SqlInt16));
|
135
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
136
|
1
|
ret = (SqlInt16) ConversionUtil.ConvertNullable(30140, typeof(SqlInt16));
|
137
|
1
|
Assert.AreEqual(new SqlInt16(30140), ret, "3");
|
138
|
|
}
|
139
|
|
|
140
|
1
|
[Test]
|
141
|
|
public void TestConvertNullable_SqlByte()
|
142
|
|
{
|
143
|
1
|
SqlByte ret = (SqlByte) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlByte));
|
144
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
145
|
1
|
ret = (SqlByte) ConversionUtil.ConvertNullable(null, typeof(SqlByte));
|
146
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
147
|
1
|
ret = (SqlByte) ConversionUtil.ConvertNullable(254, typeof(SqlByte));
|
148
|
1
|
Assert.AreEqual(new SqlByte(254), ret, "3");
|
149
|
|
}
|
150
|
|
|
151
|
1
|
[Test]
|
152
|
|
public void TestConvertNullable_SqlGuid()
|
153
|
|
{
|
154
|
1
|
SqlGuid ret = (SqlGuid) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlGuid));
|
155
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
156
|
1
|
ret = (SqlGuid) ConversionUtil.ConvertNullable(null, typeof(SqlGuid));
|
157
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
158
|
1
|
ret = (SqlGuid) ConversionUtil.ConvertNullable(
|
159
|
|
new Guid("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4"), typeof(SqlGuid));
|
160
|
1
|
Assert.AreEqual(new SqlGuid(new Guid("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4")), ret, "3");
|
161
|
|
}
|
162
|
|
|
163
|
1
|
[Test]
|
164
|
|
public void TestConvertNullable_SqlBoolean()
|
165
|
|
{
|
166
|
1
|
SqlBoolean ret = (SqlBoolean) ConversionUtil.ConvertNullable(DBNull.Value, typeof(SqlBoolean));
|
167
|
1
|
Assert.IsTrue(ret.IsNull, "1");
|
168
|
1
|
ret = (SqlBoolean) ConversionUtil.ConvertNullable(null, typeof(SqlBoolean));
|
169
|
1
|
Assert.IsTrue(ret.IsNull, "2");
|
170
|
1
|
ret = (SqlBoolean) ConversionUtil.ConvertNullable(true, typeof(SqlBoolean));
|
171
|
1
|
Assert.AreEqual(new SqlBoolean(true), ret, "3");
|
172
|
|
}
|
173
|
|
|
174
|
1
|
[Test]
|
175
|
|
public void TestConvertNullableType_NullableBoolean()
|
176
|
|
{
|
177
|
1
|
NullableBoolean ret = (NullableBoolean) ConversionUtil.ConvertNullableType(
|
178
|
|
DBNull.Value, typeof(NullableBoolean));
|
179
|
1
|
Assert.IsFalse(ret.HasValue, "1");
|
180
|
1
|
ret = (NullableBoolean) ConversionUtil.ConvertNullableType(null, typeof(NullableBoolean));
|
181
|
1
|
Assert.IsFalse(ret.HasValue, "2");
|
182
|
1
|
ret = (NullableBoolean) ConversionUtil.ConvertNullableType(true, typeof(NullableBoolean));
|
183
|
1
|
Assert.AreEqual(new NullableBoolean(true), ret, "3");
|
184
|
|
}
|
185
|
|
|
186
|
1
|
[Test]
|
187
|
|
public void TestConvertNullableType_NullableByte()
|
188
|
|
{
|
189
|
1
|
NullableByte ret = (NullableByte) ConversionUtil.ConvertNullableType(
|
190
|
|
DBNull.Value, typeof(NullableByte));
|
191
|
1
|
Assert.IsFalse(ret.HasValue, "1");
|
192
|
1
|
ret = (NullableByte) ConversionUtil.ConvertNullableType(null, typeof(NullableByte));
|
193
|
1
|
Assert.IsFalse(ret.HasValue, "2");
|
194
|
1
|
ret = (NullableByte) ConversionUtil.ConvertNullableType(240, typeof(NullableByte));
|
195
|
1
|
Assert.AreEqual(new NullableByte(240), ret, "3");
|
196
|
|
}
|
197
|
|
|
198
|
1
|
[Test]
|
199
|
|
public void TestConvertNullableType_NullableChar()
|
200
|
|
{
|
201
|
1
|
NullableChar ret = (NullableChar) ConversionUtil.ConvertNullableType(
|
202
|
|
DBNull.Value, typeof(NullableChar));
|
203
|
1
|
Assert.IsFalse(ret.HasValue, "1");
|
204
|
1
|
ret = (NullableChar) ConversionUtil.ConvertNullableType(null, typeof(NullableChar));
|
205
|
1
|
Assert.IsFalse(ret.HasValue, "2");
|
206
|
1
|
ret = (NullableChar) ConversionUtil.ConvertNullableType('s', typeof(NullableChar));
|
207
|
1
|
Assert.AreEqual(new NullableChar('s'), ret, "3");
|
208
|
|
}
|
209
|
|
|
210
|
1
|
[Test]
|
211
|
|
public void TestConvertNullableType_NullableDateTime()
|
212
|
|
{
|
213
|
1
|
NullableDateTime ret = (NullableDateTime) ConversionUtil.ConvertNullableType(
|
214
|
|
DBNull.Value, typeof(NullableDateTime));
|
215
|
1
|
Assert.IsFalse(ret.HasValue, "1");
|
216
|
1
|
ret = (NullableDateTime) ConversionUtil.ConvertNullableType(null, typeof(NullableDateTime));
|
217
|
1
|
Assert.IsFalse(ret.HasValue, "2");
|
218
|
1
|
ret = (NullableDateTime) ConversionUtil.ConvertNullableType(
|
219
|
|
new DateTime(2006, 4, 1), typeof(NullableDateTime));
|
220
|
1
|
Assert.AreEqual(new NullableDateTime(new DateTime(2006, 4, 1)), ret, "3");
|
221
|
|
}
|
222
|
|
|
223
|
1
|
[Test]
|
224
|
|
public void TestConvertNullableType_NullableDecimal()
|
225
|
|
{
|
226
|
1
|
NullableDecimal ret = (NullableDecimal) ConversionUtil.ConvertNullableType(
|
227
|
|
DBNull.Value, typeof(NullableDecimal));
|
228
|
1
|
Assert.IsFalse(ret.HasValue, "1");
|
229
|
1
|
ret = (NullableDecimal) ConversionUtil.ConvertNullableType(null, typeof(NullableDecimal));
|
230
|
1
|
Assert.IsFalse(ret.HasValue, "2");
|
231
|
1
|
ret = (NullableDecimal) ConversionUtil.ConvertNullableType(122345, typeof(NullableDecimal));
|
232
|
1
|
Assert.AreEqual(new NullableDecimal(122345), ret, "3");
|
233
|
|
}
|
234
|
|
|
235
|
1
|
[Test]
|
236
|
|
public void TestConvertNullableType_NullableDouble()
|
237
|
|
{
|
238
|
1
|
NullableDouble ret = (NullableDouble) ConversionUtil.ConvertNullableType(
|
239
|
|
DBNull.Value, typeof(NullableDouble));
|
240
|
1
|
Assert.IsFalse(ret.HasValue, "1");
|
241
|
1
|
ret = (NullableDouble) ConversionUtil.ConvertNullableType(null, typeof(NullableDouble));
|
242
|
1
|
Assert.IsFalse(ret.HasValue, "2");
|
243
|
1
|
ret = (NullableDouble) ConversionUtil.ConvertNullableType(3.1415, typeof(NullableDouble));
|
244
|
1
|
Assert.AreEqual(new NullableDouble(3.1415), ret, "3");
|
245
|
|
}
|
246
|
|
|
247
|
1
|
[Test]
|
248
|
|
public void TestConvertNullableType_NullableGuid()
|
249
|
|
{
|
250
|
1
|
NullableGuid ret = (NullableGuid) ConversionUtil.ConvertNullableType(
|
251
|
|
DBNull.Value, typeof(NullableGuid));
|
252
|
1
|
Assert.IsFalse(ret.HasValue, "1");
|
253
|
1
|
ret = (NullableGuid) ConversionUtil.ConvertNullableType(null, typeof(NullableGuid));
|
254
|
1
|
Assert.IsFalse(ret.HasValue, "2");
|
255
|
1
|
ret = (NullableGuid) ConversionUtil.ConvertNullableType(
|
256
|
|
new Guid("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4"), typeof(NullableGuid));
|
257
|
1
|
Assert.AreEqual(new NullableGuid(new Guid("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4")), ret, "3");
|
258
|
|
}
|
259
|
|
|
260
|
1
|
[Test]
|
261
|
|
public void TestConvertNullableType_NullableInt16()
|
262
|
|
{
|
263
|
1
|
NullableInt16 ret = (NullableInt16) ConversionUtil.ConvertNullableType(
|
264
|
|
DBNull.Value, typeof(NullableInt16));
|
265
|
1
|
Assert.IsFalse(ret.HasValue, "1");
|
266
|
1
|
ret = (NullableInt16) ConversionUtil.ConvertNullableType(null, typeof(NullableInt16));
|
267
|
1
|
Assert.IsFalse(ret.HasValue, "2");
|
268
|
1
|
ret = (NullableInt16) ConversionUtil.ConvertNullableType(1031, typeof(NullableInt16));
|
269
|
1
|
Assert.AreEqual(new NullableInt16(1031), ret, "3");
|
270
|
|
}
|
271
|
|
|
272
|
1
|
[Test]
|
273
|
|
public void TestConvertNullableType_NullableInt32()
|
274
|
|
{
|
275
|
1
|
NullableInt32 ret = (NullableInt32) ConversionUtil.ConvertNullableType(
|
276
|
|
DBNull.Value, typeof(NullableInt32));
|
277
|
1
|
Assert.IsFalse(ret.HasValue, "1");
|
278
|
1
|
ret = (NullableInt32) ConversionUtil.ConvertNullableType(null, typeof(NullableInt32));
|
279
|
1
|
Assert.IsFalse(ret.HasValue, "2");
|
280
|
1
|
ret = (NullableInt32) ConversionUtil.ConvertNullableType(1031, typeof(NullableInt32));
|
281
|
1
|
Assert.AreEqual(new NullableInt32(1031), ret, "3");
|
282
|
|
}
|
283
|
|
|
284
|
1
|
[Test]
|
285
|
|
public void TestConvertNullableType_NullableInt64()
|
286
|
|
{
|
287
|
1
|
NullableInt64 ret = (NullableInt64) ConversionUtil.ConvertNullableType(
|
288
|
|
DBNull.Value, typeof(NullableInt64));
|
289
|
1
|
Assert.IsFalse(ret.HasValue, "1");
|
290
|
1
|
ret = (NullableInt64) ConversionUtil.ConvertNullableType(null, typeof(NullableInt64));
|
291
|
1
|
Assert.IsFalse(ret.HasValue, "2");
|
292
|
1
|
ret = (NullableInt64) ConversionUtil.ConvertNullableType(1031, typeof(NullableInt64));
|
293
|
1
|
Assert.AreEqual(new NullableInt64(1031), ret, "3");
|
294
|
|
}
|
295
|
|
|
296
|
1
|
[Test]
|
297
|
|
public void TestConvertNullableType_NullableSByte()
|
298
|
|
{
|
299
|
1
|
NullableSByte ret = (NullableSByte) ConversionUtil.ConvertNullableType(
|
300
|
|
DBNull.Value, typeof(NullableSByte));
|
301
|
1
|
Assert.IsFalse(ret.HasValue, "1");
|
302
|
1
|
ret = (NullableSByte) ConversionUtil.ConvertNullableType(null, typeof(NullableSByte));
|
303
|
1
|
Assert.IsFalse(ret.HasValue, "2");
|
304
|
1
|
ret = (NullableSByte) ConversionUtil.ConvertNullableType(112, typeof(NullableSByte));
|
305
|
1
|
Assert.AreEqual(new NullableSByte(112), ret, "3");
|
306
|
|
}
|
307
|
|
|
308
|
1
|
[Test]
|
309
|
|
public void TestConvertNullableType_NullableSingle()
|
310
|
|
{
|
311
|
1
|
NullableSingle ret = (NullableSingle) ConversionUtil.ConvertNullableType(
|
312
|
|
DBNull.Value, typeof(NullableSingle));
|
313
|
1
|
Assert.IsFalse(ret.HasValue, "1");
|
314
|
1
|
ret = (NullableSingle) ConversionUtil.ConvertNullableType(null, typeof(NullableSingle));
|
315
|
1
|
Assert.IsFalse(ret.HasValue, "2");
|
316
|
1
|
ret = (NullableSingle) ConversionUtil.ConvertNullableType(1.2f, typeof(NullableSingle));
|
317
|
1
|
Assert.AreEqual(new NullableSingle(1.2f), ret, "3");
|
318
|
|
}
|
319
|
|
}
|
320
|
|
}
|
321
|
|
|