Clover.NET coverage report - Coverage for s2container.net

Coverage timestamp: 2006年5月30日 11:21:29

File Stats: LOC: 321   Methods: 25
NCLOC: 279 Classes: 1
 
Source File Conditionals Statements Methods TOTAL
Seasar.Tests.Framework.Util\ConversionUtilTest.cs - 100.0% 100.0% 100.0%
coverage
1   #region Copyright
2   /*
3   * Copyright 2005 the Seasar Foundation and the Others.
4   *
5   * Licensed under the Apache License, Version 2.0 (the "License");
6   * you may not use this file except in compliance with the License.
7   * You may obtain a copy of the License at
8   *
9   * http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
14   * either express or implied. See the License for the specific language
15   * governing permissions and limitations under the License.
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