/*
 * Copyright (c) 2007 NTT DATA Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package jp.terasoluna.fw.util;

import java.lang.reflect.InvocationTargetException;
import java.math.BigInteger;
import java.security.AlgorithmParameterGenerator;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import javax.swing.JWindow;

import jp.terasoluna.utlib.UTUtil;
import junit.framework.TestCase;

import org.apache.commons.beanutils.BeanUtilsBean;
import org.apache.commons.beanutils.ConversionException;
import org.apache.commons.beanutils.PropertyUtilsBean;

/**
 * {@link jp.terasoluna.fw.client.util.ConvertUtil} クラスのテスト。
 * 
 * <p>
 * <h4>【クラスの概要】</h4>
 * 型変換を行うためのユーティリティクラス。
 * <p>
 * 
 * @see jp.terasoluna.fw.client.util.ConvertUtil
 */
public class ConvertUtilTest extends TestCase {
    
    /**
     * PropertyUtilsBean。
     */
    private PropertyUtilsBean defaultPropertyUtilsBean = null;

    /**
     * このテストケースを実行する為の
     * GUI アプリケーションを起動する。
     * 
     * @param args java コマンドに設定されたパラメータ
     */
    public static void main(String[] args) {
        junit.swingui.TestRunner.run(ConvertUtilTest.class);
    }

    /**
     * 初期化処理を行う。
     * 
     * @throws Exception このメソッドで発生した例外
     * @see junit.framework.TestCase#setUp()
     */
    @Override
    protected void setUp() throws Exception {
        super.setUp();
        BeanUtilsBean beanUtilsBean = BeanUtilsBean.getInstance();
        defaultPropertyUtilsBean = beanUtilsBean.getPropertyUtils();
    }

    /**
     * 終了処理を行う。
     * 
     * @throws Exception このメソッドで発生した例外
     * @see junit.framework.TestCase#tearDown()
     */
    @Override
    protected void tearDown() throws Exception {
        super.tearDown();
        BeanUtilsBean beanUtilsBean = BeanUtilsBean.getInstance();
        UTUtil.setPrivateField(beanUtilsBean, "propertyUtilsBean",
                defaultPropertyUtilsBean);
    }

    /**
     * コンストラクタ。
     * 
     * @param name このテストケースの名前。
     */
    public ConvertUtilTest(String name) {
        super(name);
    }

    /**
     * testToArray01()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：C
     * <br><br>
     * 入力値：(引数) obj:null<br>
     *         
     * <br>
     * 期待値：(戻り値) Object[]:要素を持たないObject[] (要素数が0であることを確認)<br>
     *         
     * <br>
     * 引数objがnullだった場合、要素を持たないObject[]が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToArray01() throws Exception {
        // テスト実施
        Object[] result = ConvertUtil.toArray(null); 
        
        // 判定
        assertEquals(0, result.length);
    }

    /**
     * testToArray02()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：C
     * <br><br>
     * 入力値：(引数) obj:""(空文字)<br>
     *         
     * <br>
     * 期待値：(戻り値) Object[]:１要素を持つObject[] (要素数が１であることを確認)<br>
     *                   *要素0:""(空文字)<br>
     *         
     * <br>
     * 引数objが""(空文字)だった場合、１要素を持つObject[]が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToArray02() throws Exception {
        // テスト実施
        Object[] result = ConvertUtil.toArray(""); 
        
        // 判定
        assertEquals(1, result.length);
        assertEquals("", result[0]);
    }

    /**
     * testToArray03()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：C
     * <br><br>
     * 入力値：(引数) obj:"  "(空白文字列)<br>
     *         
     * <br>
     * 期待値：(戻り値) Object[]:１要素を持つObject[] (要素数が１であることを確認)<br>
     *                   *要素0:"  "(空白文字列)<br>
     *         
     * <br>
     * 引数objが"  "(空白文字列)だった場合、１要素を持つObject[]が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToArray03() throws Exception {
        // テスト実施
        Object[] result = ConvertUtil.toArray("  "); 
        
        // 判定
        assertEquals(1, result.length);
        assertEquals("  ", result[0]);
    }

    /**
     * testToArray04()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：E
     * <br><br>
     * 入力値：(引数) obj:"array"<br>
     *         
     * <br>
     * 期待値：(戻り値) Object[]:１要素を持つObject[] (要素数が１であることを確認)<br>
     *                   *要素0:"array"<br>
     *         
     * <br>
     * 引数objが通常の文字列だった場合、１要素を持つObject[]が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToArray04() throws Exception {
        // テスト実施
        Object[] result = ConvertUtil.toArray("array"); 
        
        // 判定
        assertEquals(1, result.length);
        assertEquals("array", result[0]);
    }

    /**
     * testToArray05()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D
     * <br><br>
     * 入力値：(引数) obj:要素を持たないObject[]<br>
     *         
     * <br>
     * 期待値：(戻り値) Object[]:要素を持たないObject[] (要素数が０であることを確認)<br>
     *         
     * <br>
     * 引数objが要素を持たない配列だった場合、要素を持たないObject[]が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToArray05() throws Exception {
        // 前処理
        Object obj = new Object[0];

        // テスト実施
        Object[] result = ConvertUtil.toArray(obj); 
        
        // 判定
        assertEquals(0, result.length);
    }

    /**
     * testToArray06()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D
     * <br><br>
     * 入力値：(引数) obj:１要素を保持するString[]<br>
     *                 *要素０:"array"<br>
     *         
     * <br>
     * 期待値：(戻り値) Object[]:１要素を持つObject[] (要素数が１であることを確認)<br>
     *                   *要素0:"array"<br>
     *         
     * <br>
     * 引数objが１要素を保持する配列だった場合、１要素を保持するObject[]が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToArray06() throws Exception {
        // 前処理
        String[] obj = {"array"};

        // テスト実施
        Object[] result = ConvertUtil.toArray(obj); 
        
        // 判定
        assertEquals(1, result.length);
        assertEquals("array", result[0]);
    }

    /**
     * testToArray07()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D
     * <br><br>
     * 入力値：(引数) obj:３要素を保持するObject[]<br>
     *                 *要素０:"array"<br>
     *                 *要素１:1<br>
     *                 *要素２:Mapインスタンス (key="foo" value="something")<br>
     *         
     * <br>
     * 期待値：(戻り値) Object[]:３要素を持つObject[] (要素数が３であることを確認)<br>
     *                   *要素0:"array"<br>
     *                   *要素1:1<br>
     *                   *要素2:Mapインスタンス(key="foo" value="something")<br>
     *         
     * <br>
     * 引数objが３要素を保持する配列だった場合、３要素を保持するObject[]が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    @SuppressWarnings("unchecked")
    public void testToArray07() throws Exception {
        // 前処理
        Object[] obj = new Object[3];
        obj[0] = "array";
        obj[1] = 1;
        Map map = new HashMap();
        map.put("foo", "something");
        obj[2] = map;

        // テスト実施
        Object[] result = ConvertUtil.toArray(obj); 
        
        // 判定
        assertEquals(3, result.length);
        assertEquals("array", result[0]);
        assertEquals(1, result[1]);
        assertEquals(map, result[2]);
        Map mapResult = (Map) result[2];
        assertEquals("something", mapResult.get("foo"));
    }

    /**
     * testToArray08()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D
     * <br><br>
     * 入力値：(引数) obj:要素を持たないCollection<br>
     *         
     * <br>
     * 期待値：(戻り値) Object[]:要素を持たないObject[] (要素数が０であることを確認)<br>
     *         
     * <br>
     * 引数objが要素を持たないCollectionだった場合、要素を持たないObject[]が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToArray08() throws Exception {
        // 前処理
        Collection obj = new Vector();

        // テスト実施
        Object[] result = ConvertUtil.toArray(obj); 
        
        // 判定
        assertEquals(0, result.length);
    }

    /**
     * testToArray09()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D
     * <br><br>
     * 入力値：(引数) obj:１要素を保持するCollection<br>
     *                 *要素0:"collection"<br>
     *         
     * <br>
     * 期待値：(戻り値) Object[]:１要素を持つObject[] (要素数が１であることを確認)<br>
     *                   *要素0:"collection"<br>
     *         
     * <br>
     * 引数objが１要素を保持するCollectionだった場合、１要素を保持するObject[]が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    @SuppressWarnings("unchecked")
    public void testToArray09() throws Exception {
        // 前処理
        Collection obj = new Vector();
        obj.add("collection");

        // テスト実施
        Object[] result = ConvertUtil.toArray(obj); 
        
        // 判定
        assertEquals(1, result.length);
        assertEquals("collection", result[0]);
    }

    /**
     * testToArray10()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D
     * <br><br>
     * 入力値：(引数) obj:３要素を保持するCollection<br>
     *                 *要素0:"collection"<br>
     *                 *要素1:1<br>
     *                 *要素2:Mapインスタンス(key="key" value="something")<br>
     *         
     * <br>
     * 期待値：(戻り値) Object[]:３要素を持つObject[] (要素数が３であることを確認)<br>
     *                   *要素0:"collection"<br>
     *                   *要素1:1<br>
     *                   *要素2:Mapインスタンス(key="foo" value="something")<br>
     *         
     * <br>
     * 引数objが３要素を保持するcollectionだった場合、３要素を保持するObject[]が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    @SuppressWarnings("unchecked")
    public void testToArray10() throws Exception {
        // 前処理
        Collection obj = new Vector();
        obj.add("collection");
        obj.add(1);
        Map map = new HashMap();
        map.put("foo", "something");
        obj.add(map);

        // テスト実施
        Object[] result = ConvertUtil.toArray(obj); 
        
        // 判定
        assertEquals(3, result.length);
        assertEquals("collection", result[0]);
        assertEquals(1, result[1]);
        Map mapResult = (Map) result[2];
        assertEquals("something", mapResult.get("foo"));
    }

    /**
     * testToList01()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：C,G
     * <br><br>
     * 入力値：(引数) obj:null<br>
     *         (引数) elementClass:null<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    例外のメッセージ:
     *                    "Argument 'elementClass' (" + Class.class.getName() 
     *                    　+ ") is null"<br>
     *         
     * <br>
     * 引数elementClassがnullだった場合、IllegalArgumentExceptionがスローされることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToList01() throws Exception {
        // テスト実施
        try {
            ConvertUtil.toList(null, null);
            fail("IllegalArgumentExceptionがスローされませんでした。");
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertEquals("Argument 'elementClass' (" + Class.class.getName()
                    + ") is null",
                    e.getMessage());
        }

    }

    /**
     * testToList02()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：C
     * <br><br>
     * 入力値：(引数) obj:null<br>
     *         (引数) elementClass:Object.class<br>
     *         
     * <br>
     * 期待値：(戻り値) List:要素を持たないList<Object> (要素数が０であることを確認)<br>
     *         
     * <br>
     * 引数objがnullだった場合、elementsClassで指定した型のListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToList02() throws Exception {
        // テスト実施
        List<Object> result = ConvertUtil.toList(null, Object.class);

        // 判定
        assertEquals(0, result.size());
    }

    /**
     * testToList03()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：C
     * <br><br>
     * 入力値：(引数) obj:""(空文字)<br>
     *         (引数) elementClass:Object.class<br>
     *         
     * <br>
     * 期待値：(戻り値) List:１要素を持つList<Object> (要素数が１であることを確認)<br>
     *                   *要素0:""(空文字)<br>
     *         
     * <br>
     * 引数objが""(空文字)だった場合、elementsClassで指定した型のListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToList03() throws Exception {
        // テスト実施
        List<Object> result = ConvertUtil.toList("", Object.class);

        // 判定
        assertEquals(1, result.size());
        assertEquals("", result.get(0));
        
    }

    /**
     * testToList04()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：C
     * <br><br>
     * 入力値：(引数) obj:"  "(空白文字列)<br>
     *         (引数) elementClass:Object.class<br>
     *         
     * <br>
     * 期待値：(戻り値) List:１要素を持つList<Object> (要素数が１であることを確認)<br>
     *                   *要素0:"  "(空白文字列)<br>
     *         
     * <br>
     * 引数objが""(空文字)だった場合、elementsClassで指定した型のListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToList04() throws Exception {
        // テスト実施
        List<Object> result = ConvertUtil.toList("  ", Object.class);

        // 判定
        assertEquals(1, result.size());
        assertEquals("  ", result.get(0));
    }

    /**
     * testToList05()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：E
     * <br><br>
     * 入力値：(引数) obj:"list"<br>
     *         (引数) elementClass:Object.class<br>
     *         
     * <br>
     * 期待値：(戻り値) List:１要素を持つList<Object> (要素数が１であることを確認)<br>
     *                   *要素0:"list"<br>
     *         
     * <br>
     * 引数objが通常文字列だった場合、elementsClassで指定した型のListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToList05() throws Exception {
        // テスト実施
        List<Object> result = ConvertUtil.toList("list", Object.class);

        // 判定
        assertEquals(1, result.size());
        assertEquals("list", result.get(0));
    }

    /**
     * testToList06()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：G
     * <br><br>
     * 入力値：(引数) obj:"list"<br>
     *         (引数) elementClass:JWindow.class<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    例外のメッセージ:
     *                    "Unable to cast '" + 引数objの完全修飾クラス名 
     *                    　+ "' to '" + 引数elementClassの完全修飾クラス名 + "'"<br>
     *                    ラップされた例外:ClassCastException<br>
     *                    ラップされた例外のメッセージ:"Unable to cast '" 
     *                    　+ 引数objの完全修飾クラス名 + "' to '" 
     *                    + 引数elementClassの完全修飾クラス名 + "'"<br>
     *         
     * <br>
     * 引数objの型がelementClassで指定した型と同一、もしくはサブクラスでは
     * なかった場合、IllegalArgumentExceptionがスローされることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    @SuppressWarnings("unchecked")
    public void testToList06() throws Exception {
        // テスト実施
        try {
            ConvertUtil.toList("list", JWindow.class);
            fail("IllegalArgumentExceptionがスローされませんでした。");
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertEquals("Unable to cast '" + "list".getClass().getName() 
                    + "' to '" + JWindow.class.getName() + "'",
                    e.getMessage());
            assertEquals(ClassCastException.class.getName(),
                    e.getCause().getClass().getName());
            assertEquals("Unable to cast '" + "list".getClass().getName() 
                    + "' to '" + JWindow.class.getName() + "'",
                    e.getCause().getMessage());
        }

    }

    /**
     * testToList07()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D
     * <br><br>
     * 入力値：(引数) obj:要素を持たないObject[]<br>
     *         (引数) elementClass:String.class<br>
     *         
     * <br>
     * 期待値：(戻り値) List:要素を持たないList<String> (要素数が０であることを確認)<br>
     *         
     * <br>
     * 引数objが要素を持たない配列だった場合、elementsClassで指定した型のListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToList07() throws Exception {
        // 前処理
        Object[] obj = new Object[0];
        
        // テスト実施
        List<String> result = ConvertUtil.toList(obj, String.class);

        // 判定
        assertEquals(0, result.size());
    }

    /**
     * testToList08()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D
     * <br><br>
     * 入力値：(引数) obj:１要素を保持するObject[]<br>
     *                 *要素0:"foo"<br>
     *         (引数) elementClass:String.class<br>
     *         
     * <br>
     * 期待値：(戻り値) List:１要素を持つList<String> (要素数が１であることを確認)<br>
     *                   *要素0:"foo"<br>
     *         
     * <br>
     * 引数objが１要素を保持する配列だった場合、elementsClassで指定した型のListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToList08() throws Exception {
        // 前処理
        Object[] obj = {"foo"};
        
        // テスト実施
        List<String> result = ConvertUtil.toList(obj, String.class);

        // 判定
        assertEquals(1, result.size());
        assertEquals("foo", result.get(0));
    }

    /**
     * testToList09()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D
     * <br><br>
     * 入力値：(引数) obj:３要素を保持するObject[]<br>
     *                 *要素0:"foo"<br>
     *                 *要素2:"bar"<br>
     *                 *要素3:"baz"<br>
     *         (引数) elementClass:String.class<br>
     *         
     * <br>
     * 期待値：(戻り値) List:３要素を持つList<String> (要素数が３であることを確認)<br>
     *                   *要素0:"foo"<br>
     *                   *要素1:"bar"<br>
     *                   *要素2:"baz"<br>
     *         
     * <br>
     * 引数objが３要素を保持する配列だった場合、elementsClassで指定した型のListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToList09() throws Exception {
        // 前処理
        Object[] obj = new Object[3];
        obj[0] = "foo";
        obj[1] = "bar";
        obj[2] = "baz";
        
        // テスト実施
        List<String> result = ConvertUtil.toList(obj, String.class);

        // 判定
        assertEquals(3, result.size());
        assertEquals("foo", result.get(0));
        assertEquals("bar", result.get(1));
        assertEquals("baz", result.get(2));
    }

    /**
     * testToList10()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：G
     * <br><br>
     * 入力値：(引数) obj:３要素を保持するObject[]<br>
     *                 *要素0:"foo"<br>
     *                 *要素2:JWindowインスタンス<br>
     *                 *要素3:"baz"<br>
     *         (引数) elementClass:String.class<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    例外のメッセージ:
     *                    　"Unable to cast '" + JWindowの完全修飾クラス名 
     *                    　+ "' to '" + 引数elementClassの完全修飾クラス名 + "'"<br>
     *                    ラップされた例外:ClassCastException<br>
     *                    ラップされた例外のメッセージ:
     *                    　"Unable to cast '" + JWindowの完全修飾クラス名 
     *                    + "' to '" + 引数elementClassの完全修飾クラス名 + "'"<br>
     *         
     * <br>
     * 引数objの配列にelementClassで指定した型と同一、もしくはサブクラスではない
     * 要素が含まれていた場合、IllegalArgumentExceptionがスローされることを
     * 確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToList10() throws Exception {
        // 前処理
        Object[] obj = new Object[3];
        obj[0] = "foo";
        obj[1] = new JWindow();
        obj[2] = "baz";

        // テスト実施
        try {
            ConvertUtil.toList(obj, String.class);
            fail("IllegalArgumentExceptionがスローされませんでした。");
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertEquals("Unable to cast '" + JWindow.class.getName() 
                    + "' to '" + String.class.getName() + "'",
                    e.getMessage());
            assertEquals(ClassCastException.class.getName(),
                    e.getCause().getClass().getName());
            assertEquals("Unable to cast '" + JWindow.class.getName() 
                    + "' to '" + String.class.getName() + "'",
                    e.getCause().getMessage());
        }
    }

    /**
     * testToList11()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D
     * <br><br>
     * 入力値：(引数) obj:要素を持たないCollection<br>
     *         (引数) elementClass:String.class<br>
     *         
     * <br>
     * 期待値：(戻り値) List:要素を持たないList<String> (要素数が０であることを確認)<br>
     *         
     * <br>
     * 引数objが要素を持たないCollectionだった場合、elementsClassで指定した型のListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToList11() throws Exception {
        // 前処理
        Collection obj = new Vector(); 
        
        // テスト実施
        List<String> result = ConvertUtil.toList(obj, String.class);

        // 判定
        assertEquals(0, result.size());

    }

    /**
     * testToList12()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D
     * <br><br>
     * 入力値：(引数) obj:１要素を保持するCollection<br>
     *                 *要素0:"foo"<br>
     *         (引数) elementClass:String.class<br>
     *         
     * <br>
     * 期待値：(戻り値) List:１要素を持つList<String> (要素数が１であることを確認)<br>
     *                   *要素0:"foo"<br>
     *         
     * <br>
     * 引数objが１要素を保持するCollectionだった場合、elementsClassで指定した型のListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    @SuppressWarnings("unchecked")
    public void testToList12() throws Exception {
        // 前処理
        Collection obj = new Vector(); 
        obj.add("foo");
        
        // テスト実施
        List<String> result = ConvertUtil.toList(obj, String.class);

        // 判定
        assertEquals(1, result.size());
        assertEquals("foo", result.get(0));
    }

    /**
     * testToList13()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D
     * <br><br>
     * 入力値：(引数) obj:３要素を保持するCollection<br>
     *                 *要素0:"foo"<br>
     *                 *要素2:"bar"<br>
     *                 *要素3:"baz"<br>
     *         (引数) elementClass:String.class<br>
     *         
     * <br>
     * 期待値：(戻り値) List:３要素を持つList<String> (要素数が３であることを確認)<br>
     *                   *要素0:"foo"<br>
     *                   *要素1:"bar"<br>
     *                   *要素2:"baz"<br>
     *         
     * <br>
     * 引数objが３要素を保持するCollectionだった場合、elementsClassで指定した型のListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    @SuppressWarnings("unchecked")
    public void testToList13() throws Exception {
        // 前処理
        Collection obj = new Vector(); 
        obj.add("foo");
        obj.add("bar");
        obj.add("baz");
        
        // テスト実施
        List<String> result = ConvertUtil.toList(obj, String.class);

        // 判定
        assertEquals(3, result.size());
        assertEquals("foo", result.get(0));    
        assertEquals("bar", result.get(1));    
        assertEquals("baz", result.get(2));    
    }

    /**
     * testToList14()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：G
     * <br><br>
     * 入力値：(引数) obj:３要素を保持するCollection<br>
     *                 *要素0:"foo"<br>
     *                 *要素2:JWindowインスタンス<br>
     *                 *要素3:"baz"<br>
     *         (引数) elementClass:String.class<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    例外のメッセージ:
     *                    "Unable to cast '" + JWindowの完全修飾クラス名 
     *                    　+ "' to '" + 引数elementClassの完全修飾クラス名 + "'"<br>
     *                    ラップされた例外:ClassCastException<br>
     *                    ラップされた例外のメッセージ:
     *                    "Unable to cast '" + JWindowの完全修飾クラス名 
     *                    + "' to '" + 引数elementClassの完全修飾クラス名 + "'"<br>
     *         
     * <br>
     * 引数objのCollectionにelementClassで指定した型と同一、もしくはサブクラス
     * ではない要素が含まれていた場合、IllegalArgumentExceptionがスローされること
     * を確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToList14() throws Exception {
        // 前処理
        Object[] obj = new Object[3];
        obj[0] = "foo";
        obj[1] = new JWindow();
        obj[2] = "baz";

        // テスト実施
        try {
            ConvertUtil.toList(obj, String.class);
            fail("IllegalArgumentExceptionがスローされませんでした。");
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertEquals("Unable to cast '" + JWindow.class.getName() 
                    + "' to '" + String.class.getName() + "'",
                    e.getMessage());
            assertEquals(ClassCastException.class.getName(),
                    e.getCause().getClass().getName());
            assertEquals("Unable to cast '" + JWindow.class.getName() 
                    + "' to '" + String.class.getName() + "'",
                    e.getCause().getMessage());
        }
    }

    /**
     * testConvertObjectClass01()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：G
     * <br><br>
     * 入力値：(引数) obj:"object"<br>
     *         (引数) clazz:null<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    例外のメッセージ:
     *                    "Argument 'clazz' (" + Object.class.getName() 
     *                    + ") is null"<br>
     *         
     * <br>
     * 引数clazzがnullだった場合、IllegalArgumentExceptionがスローされることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertObjectClass01() throws Exception {
        // テスト実施
        try {
            ConvertUtil.convert("object", null);
            fail("IllegalArgumentExceptionがスローされませんでした。");
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertEquals("Argument 'clazz' (" + Object.class.getName()
                    + ") is null",
                    e.getMessage());
        }

    }

    /**
     * testConvertObjectClass02()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：C
     * <br><br>
     * 入力値：(引数) obj:null<br>
     *         (引数) clazz:Object.class<br>
     *         
     * <br>
     * 期待値：(戻り値) <T>:null<br>
     *         
     * <br>
     * 引数objがnullだった場合、nullが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertObjectClass02() throws Exception {
        // テスト実施
        // 判定
        assertNull(ConvertUtil.convert(null, Object.class));
    }

    /**
     * testConvertObjectClass03()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：E
     * <br><br>
     * 入力値：(引数) obj:List (ArrayListでインスタンス化する)<br>
     *         (引数) clazz:ArrayList.class<br>
     *         
     * <br>
     * 期待値：(戻り値) <T>:Listインスタンス (引数objと同じインスタンスであることを確認)<br>
     *         
     * <br>
     * 引数objと同じインスタンスが返却されるのを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertObjectClass03() throws Exception {
        // 前処理
        List list = new ArrayList();

        // テスト実施
        List result = ConvertUtil.convert(list, ArrayList.class);

        // 判定
        assertSame(list, result);
    }

    /**
     * testConvertObjectClass04()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：E
     * <br><br>
     * 入力値：(引数) obj:Jwindowインスタンス<br>
     *         (引数) clazz:AlgorithmParameterGenerator.class<br>
     *         
     * <br>
     * 期待値：(戻り値) <T>:Jwindowインスタンスの文字列表現<br>
     *         
     * <br>
     * 引数objの型がclazzの型と互換性がない場合、objの文字列表現が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertObjectClass04() throws Exception {
        // 前処理
        JWindow window = new JWindow();

        // テスト実施
        Object result = ConvertUtil.convert(window,
                AlgorithmParameterGenerator.class);

        // 判定
        assertTrue(result instanceof String);
        assertEquals(window.toString(), result);
    }

    /**
     * testConvertIfNotNull01()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：G
     * <br><br>
     * 入力値：(引数) obj:"object"<br>
     *         (引数) clazz:null<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    例外のメッセージ:
     *                    "Argument 'clazz' (" + Object.class.getName() 
     *                    　+ ") is null"<br>
     *         
     * <br>
     * 引数clazzがnullだった場合、IllegalArgumentExceptionがスローされることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertIfNotNull01() throws Exception {
        // テスト実施
        try {
            ConvertUtil.convertIfNotNull("object", null);
            fail("IllegalArgumentExceptionがスローされませんでした。");
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertEquals("Argument 'clazz' (" + Object.class.getName()
                    + ") is null",
                    e.getMessage());
        }
    }

    /**
     * testConvertIfNotNull02()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：C
     * <br><br>
     * 入力値：(引数) obj:null<br>
     *         (引数) clazz:Object.class<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    例外のメッセージ:
     *                    "Unable to cast 'null' to '" 
     *                    　+ 引数clazzの完全修飾クラス名 + "'"<br>
     *                    ラップされた例外:ClassCastException<br>
     *                    ラップされた例外のメッセージ:
     *                    "Unable to cast 'null' to '" 
     *                    　+ 引数clazzの完全修飾クラス名 + "'"<br>
     *         
     * <br>
     * 引数objがnullだった場合、IllegalArgumentExceptionがスローされることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertIfNotNull02() throws Exception {
        // テスト実施
        try {
            ConvertUtil.convertIfNotNull(null, Object.class);
            fail("IllegalArgumentExceptionがスローされませんでした。");
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertEquals("Unable to cast 'null' to '" + Object.class.getName()
                    + "'", e.getMessage());
            assertEquals(ClassCastException.class.getName(),
                    e.getCause().getClass().getName());
            assertEquals("Unable to cast 'null' to '" + Object.class.getName()
                    + "'", e.getCause().getMessage());
        }
    }

    /**
     * testConvertIfNotNull03()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：E
     * <br><br>
     * 入力値：(引数) obj:List (ArrayListでインスタンス化する)<br>
     *         (引数) clazz:ArrayList.class<br>
     *         
     * <br>
     * 期待値：(戻り値) <T>:Listインスタンス (引数objと同じインスタンスであることを確認)<br>
     *         
     * <br>
     * 引数objと同じインスタンスが返却されるのを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertIfNotNull03() throws Exception {
        // 前処理
        List list = new ArrayList();

        // テスト実施
        List result = ConvertUtil.convertIfNotNull(list, ArrayList.class);

        // 判定
        assertSame(list, result);
    }

    /**
     * testConvertIfNotNull04()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：E
     * <br><br>
     * 入力値：(引数) obj:Jwindowインスタンス<br>
     *         (引数) clazz:AlgorithmParameterGenerator.class<br>
     *         
     * <br>
     * 期待値：(戻り値) <T>:Jwindowインスタンスの文字列表現<br>
     *         
     * <br>
     * 引数objの型がclazzの型と互換性がない場合、objの文字列表現が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertIfNotNull04() throws Exception {
        // 前処理
        JWindow window = new JWindow();

        // テスト実施
        Object result = ConvertUtil.convert(window,
                AlgorithmParameterGenerator.class);

        // 判定
        assertTrue(result instanceof String);
        assertEquals(window.toString(), result);
    }

    /**
     * testConvertObjectClassboolean01()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：G
     * <br><br>
     * 入力値：(引数) obj:null<br>
     *         (引数) clazz:null<br>
     *         (引数) allowsNull:true<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    例外のメッセージ:
     *                    "Argument 'clazz' (" + Object.class.getName() 
     *                      + ") is null"<br>
     *         
     * <br>
     * 引数clazzがnullだった場合、IllegalArgumentExceptionがスローされることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertObjectClassboolean01() throws Exception {
        // テスト実施
        try {
            ConvertUtil.convert(null, null, true);
            fail("IllegalArgumentExceptionがスローされませんでした。");
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertEquals("Argument 'clazz' (" + Object.class.getName()
                    + ") is null", e.getMessage());
        }

    }

    /**
     * testConvertObjectClassboolean02()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：G
     * <br><br>
     * 入力値：(引数) obj:null<br>
     *         (引数) clazz:Object.class<br>
     *         (引数) allowsNull:false<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    例外のメッセージ:
     *                    "Unable to cast 'null' to '" 
     *                      + 引数clazzの完全修飾クラス名 + "'"<br>
     *                    ラップされた例外:ClassCastException<br>
     *                    ラップされた例外のメッセージ:
     *                    "Unable to cast 'null' to '" 
     *                      + 引数clazzの完全修飾クラス名 + "'"<br>
     *         
     * <br>
     * 引数clazzがnullではなく、objがnull、allowsNullがfalseだった場合、
     * IllegalArgumentExceptionがスローされることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertObjectClassboolean02() throws Exception {
        // テスト実施
        try {
            ConvertUtil.convert(null, Object.class, false);
            fail("IllegalArgumentExceptionがスローされませんでした。");
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertEquals("Unable to cast 'null' to '" + Object.class.getName()
                    + "'", e.getMessage());
            assertEquals(ClassCastException.class.getName(),
                    e.getCause().getClass().getName());
            assertEquals("Unable to cast 'null' to '" + Object.class.getName()
                    + "'", e.getCause().getMessage());
        }    
    }

    /**
     * testConvertObjectClassboolean03()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：C
     * <br><br>
     * 入力値：(引数) obj:null<br>
     *         (引数) clazz:Object.class<br>
     *         (引数) allowsNull:true<br>
     *         
     * <br>
     * 期待値：(戻り値) <T>:null<br>
     *         
     * <br>
     * 引数clazzがnullではなく、objがnull、allowsNullがtrueだった場合、nullが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertObjectClassboolean03() throws Exception {
        // テスト実施
        // 判定
        assertNull(ConvertUtil.convert(null, Object.class, true));
    }

    /**
     * testConvertObjectClassboolean04()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：E
     * <br><br>
     * 入力値：(引数) obj:JWindowインスタンス<br>
     *         (引数) clazz:JWindow.class<br>
     *         (引数) allowsNull:true<br>
     *         
     * <br>
     * 期待値：(戻り値) <T>:JWindowインスタンス (引数objと同一インスタンスであることを確認)<br>
     *         
     * <br>
     * 引数clazzの型とobjの型が同じだった場合、clazzの型のインスタンスが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertObjectClassboolean04() throws Exception {
        // 前処理
        JWindow window = new JWindow();
        
        // テスト実施
        JWindow result = ConvertUtil.convert(window, JWindow.class, true);

        // 判定
        assertSame(window, result);
    }

    /**
     * testConvertObjectClassboolean05()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：E
     * <br><br>
     * 入力値：(引数) obj:List (ArrayListでインスタンス化する)<br>
     *         (引数) clazz:ArrayList.class<br>
     *         (引数) allowsNull:true<br>
     *         
     * <br>
     * 期待値：(戻り値) <T>:Listインスタンス (引数objと同じインスタンスであることを確認)<br>
     *         
     * <br>
     * 引数objと同じインスタンスが返却されるのを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertObjectClassboolean05() throws Exception {
        //  前処理
        List list = new ArrayList();
        
        // テスト実施
        List result = ConvertUtil.convert(list, ArrayList.class, true);

        // 判定
        assertNotNull(result);
        assertSame(list, result);
    }

    /**
     * testConvertObjectClassboolean06()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：E
     * <br><br>
     * 入力値：(引数) obj:Jwindowインスタンス<br>
     *         (引数) clazz:AlgorithmParameterGenerator.class<br>
     *         (引数) allowsNull:true<br>
     *         
     * <br>
     * 期待値：(戻り値) <T>:Jwindowインスタンスの文字列表現<br>
     *         
     * <br>
     * 引数clazzの型がobjの型と互換性がなかった場合、objの文字列表現が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertObjectClassboolean06() throws Exception {
        //  前処理
        JWindow window = new JWindow();
        
        // テスト実施
        Object result = ConvertUtil.convert(window,
                AlgorithmParameterGenerator.class,
                true);

        // 判定
        assertTrue(result instanceof String);
        assertEquals(window.toString(), result);
    }

    /**
     * testConvertObjectClassboolean07()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：G
     * <br><br>
     * 入力値：(引数) obj:"abc"<br>
     *         (引数) clazz:BigInteger.class<br>
     *         (引数) allowsNull:false<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    ラップされた例外:ConversionException<br>
     *         
     * <br>
     * CnvertUtils#convertで例外が発生した場合、IllegalArgumentExceptionがスローされることを確認するテスト
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertObjectClassboolean07() throws Exception {
        
        // テスト実施
        try {
            ConvertUtil.convert("abc", BigInteger.class, false);
            fail("IllegalArgumentExceptionがスローされませんでした。");
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertTrue(e.getCause() instanceof ConversionException);
        }
    }

    /**
     * testConvertPrimitiveArrayToList01()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：C
     * <br><br>
     * 入力値：(引数) value:null<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:null<br>
     *         
     * <br>
     * 引数valueがnullだった場合、nullが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList01() throws Exception {
        // テスト実施
        // 判定
        assertNull(ConvertUtil.convertPrimitiveArrayToList(null));
    }

    /**
     * testConvertPrimitiveArrayToList02()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：C
     * <br><br>
     * 入力値：(引数) value:""(空文字)<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:""(空文字)<br>
     *         
     * <br>
     * 引数valueが""(空文字)だった場合、""(空文字)が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList02() throws Exception {
        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList("");
        
        // 判定
        assertNotNull(result);
        assertEquals("", result);
    }

    /**
     * testConvertPrimitiveArrayToList03()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：C
     * <br><br>
     * 入力値：(引数) value:"  "(空白文字列)<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:"  "(空白文字列)<br>
     *         
     * <br>
     * 引数valueが"  "(空白文字列)だった場合、""(空文字)が返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList03() throws Exception {
        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList("  ");
        
        // 判定
        assertNotNull(result);
        assertEquals("  ", result);
    }

    /**
     * testConvertPrimitiveArrayToList04()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：E
     * <br><br>
     * 入力値：(引数) value:"noArray"<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:"noArray"<br>
     *         
     * <br>
     * 引数valueが通常文字列だった場合、引数の値がそのまま返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList04() throws Exception {
        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList("noarray");
        
        // 判定
        assertNotNull(result);
        assertEquals("noarray", result);
    }

    /**
     * testConvertPrimitiveArrayToList05()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:要素を保持しないObject[]<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:要素を保持しないObject[] (要素数が0であることを確認)<br>
     *         
     * <br>
     * 引数valueがプリミティブ型以外の配列(要素数0)だった場合、引数の値がそのまま返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList05() throws Exception {
        // 前処理
        Object[] value = new Object[0];

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof Object[]);
        Object[] arrayResult = (Object[]) result;
        assertEquals(0, arrayResult.length);
    }

    /**
     * testConvertPrimitiveArrayToList06()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するObject[]<br>
     *                 *要素0:"foo"<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するObject[] (要素数が1であることを確認)<br>
     *                   *要素0:"foo"<br>
     *         
     * <br>
     * 引数valueがプリミティブ型以外の配列(要素数1)だった場合、引数の値がそのまま返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList06() throws Exception {
        // 前処理
        Object[] value = {"foo"};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof Object[]);
        Object[] arrayResult = (Object[]) result;
        assertEquals(1, arrayResult.length);
        assertEquals("foo", arrayResult[0]);
        
    }

    /**
     * testConvertPrimitiveArrayToList07()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するObject[]<br>
     *                 *要素0:"foo"<br>
     *                 *要素1:"bar"<br>
     *                 *要素2:"baz"<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するObject[] (要素数が3であることを確認)<br>
     *                   *要素0:"foo"<br>
     *                   *要素1:"bar"<br>
     *                   *要素3:"baz"<br>
     *         
     * <br>
     * 引数valueがプリミティブ型以外の配列(要素数3)だった場合、引数の値がそのまま返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList07() throws Exception {
        // 前処理
        Object[] value = {"foo", "bar", "baz"};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof Object[]);
        Object[] arrayResult = (Object[]) result;
        assertEquals(3, arrayResult.length);
        assertEquals("foo", arrayResult[0]);
        assertEquals("bar", arrayResult[1]);
        assertEquals("baz", arrayResult[2]);
    }

    /**
     * testConvertPrimitiveArrayToList08()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:要素を保持しないboolean[]<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:要素を保持しないList (sizeが0であることを確認)<br>
     *         
     * <br>
     * 引数valueが要素を保持しないboolean型の配列だった場合、要素を保持しないListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList08() throws Exception {
        // 前処理
        boolean[] value = new boolean[0];

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(0, listResult.size());
    }

    /**
     * testConvertPrimitiveArrayToList09()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するboolean[]<br>
     *                 *要素0:true<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが1であることを確認)<br>
     *                   *要素0:true<br>
     *         
     * <br>
     * 引数valueがboolean型の配列(要素数1)だった場合、boolean型の値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList09() throws Exception {
        // 前処理
        boolean[] value = {true};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(1, listResult.size());
        assertTrue((Boolean) listResult.get(0));
    }

    /**
     * testConvertPrimitiveArrayToList10()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するboolean[]<br>
     *                 *要素0:true<br>
     *                 *要素1:false<br>
     *                 *要素2:true<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが3であることを確認)<br>
     *                   *要素0:true<br>
     *                   *要素1:false<br>
     *                   *要素2:true<br>
     *         
     * <br>
     * 引数valueがboolean型の配列(要素数3)だった場合、boolean型の値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList10() throws Exception {
        // 前処理
        boolean[] value = {true, false, true};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(3, listResult.size());
        assertTrue((Boolean) listResult.get(0));
        assertFalse((Boolean) listResult.get(1));
        assertTrue((Boolean) listResult.get(2));
    }

    /**
     * testConvertPrimitiveArrayToList11()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:要素を保持しないbyte[]<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:要素を保持しないList (sizeが0であることを確認)<br>
     *         
     * <br>
     * 引数valueが要素を保持しないbyte型の配列だった場合、要素を保持しないListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList11() throws Exception {
        // 前処理
        byte[] value = new byte[0];

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(0, listResult.size());
    }

    /**
     * testConvertPrimitiveArrayToList12()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するbyte[]<br>
     *                 *要素0: (byte) 1<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが1であることを確認)<br>
     *                   *要素0:"1"<br>
     *         
     * <br>
     * 引数valueがbyte型の配列(要素数1)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList12() throws Exception {
        // 前処理
        byte[] value = {1};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(1, listResult.size());
        assertEquals("1", listResult.get(0));
    }

    /**
     * testConvertPrimitiveArrayToList13()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するbyte[]<br>
     *                 *要素0: (byte) 1<br>
     *                 *要素1: (byte) 2<br>
     *                 *要素2: (byte) 3<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが3であることを確認)<br>
     *                   *要素0:"1"<br>
     *                   *要素1:"2"<br>
     *                   *要素2:"3"<br>
     *         
     * <br>
     * 引数valueがbyte型の配列(要素数3)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList13() throws Exception {
        // 前処理
        byte[] value = {1, 2, 3};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(3, listResult.size());
        assertEquals("1", listResult.get(0));    
        assertEquals("2", listResult.get(1));    
        assertEquals("3", listResult.get(2));    
    }

    /**
     * testConvertPrimitiveArrayToList14()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:要素を保持しないchar[]<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:要素を保持しないList (sizeが0であることを確認)<br>
     *         
     * <br>
     * 引数valueが要素を保持しないchar型の配列だった場合、要素を保持しないListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList14() throws Exception {
        // 前処理
        char[] value = new char[0];

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(0, listResult.size());
    }

    /**
     * testConvertPrimitiveArrayToList15()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するchar[]<br>
     *                 *要素0: 'A'<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが1であることを確認)<br>
     *                   *要素0: "A"<br>
     *         
     * <br>
     * 引数valueがchar型の配列(要素数1)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList15() throws Exception {
        // 前処理
        char[] value = {'A'};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(1, listResult.size());
        assertEquals("A", listResult.get(0));    
    }

    /**
     * testConvertPrimitiveArrayToList16()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するchar[]<br>
     *                 *要素0: 'A'<br>
     *                 *要素1: 'B'<br>
     *                 *要素2: 'C'<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが3であることを確認)<br>
     *                   *要素0: "A"<br>
     *                   *要素1: "B"<br>
     *                   *要素2: "C"<br>
     *         
     * <br>
     * 引数valueがchar型の配列(要素数3)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList16() throws Exception {
        // 前処理
        char[] value = {'A', 'B', 'C'};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(3, listResult.size());
        assertEquals("A", listResult.get(0));    
        assertEquals("B", listResult.get(1));    
        assertEquals("C", listResult.get(2));    
    }

    /**
     * testConvertPrimitiveArrayToList17()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:要素を保持しないdouble[]<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:要素を保持しないList (sizeが0であることを確認)<br>
     *         
     * <br>
     * 引数valueが要素を保持しないdouble型の配列だった場合、要素を保持しないListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList17() throws Exception {
        // 前処理
        double[] value = new double[0];

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(0, listResult.size());
    }

    /**
     * testConvertPrimitiveArrayToList18()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するdouble[]<br>
     *                 *要素0: 123.456<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが1であることを確認)<br>
     *                   *要素0: "123.456"<br>
     *         
     * <br>
     * 引数valueがdouble型の配列(要素数1)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList18() throws Exception {
        // 前処理
        double[] value = {123.456};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(1, listResult.size());
        assertEquals("123.456", listResult.get(0));    
    }

    /**
     * testConvertPrimitiveArrayToList19()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するdouble[]<br>
     *                 *要素0: 123.456<br>
     *                 *要素1: 12.34<br>
     *                 *要素2: 1.2<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが3であることを確認)<br>
     *                   *要素0: "123.456"<br>
     *                   *要素1: "12.34"<br>
     *                   *要素2: "1.2"<br>
     *         
     * <br>
     * 引数valueがdouble型の配列(要素数3)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList19() throws Exception {
        // 前処理
        double[] value = {123.456, 12.34, 1.2};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(3, listResult.size());
        assertEquals("123.456", listResult.get(0));    
        assertEquals("12.34", listResult.get(1));    
        assertEquals("1.2", listResult.get(2));    
    }

    /**
     * testConvertPrimitiveArrayToList20()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:要素を保持しないfloat[]<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:要素を保持しないList (sizeが0であることを確認)<br>
     *         
     * <br>
     * 引数valueが要素を保持しないfloat型の配列だった場合、要素を保持しないListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList20() throws Exception {
        // 前処理
        float[] value = new float[0];

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(0, listResult.size());
    }

    /**
     * testConvertPrimitiveArrayToList21()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するfloat[]<br>
     *                 *要素0: 12.3F<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが1であることを確認)<br>
     *                   *要素0: "12.3"<br>
     *         
     * <br>
     * 引数valueがfloat型の配列(要素数1)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList21() throws Exception {
        // 前処理
        float[] value = {12.3F};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(1, listResult.size());
        assertEquals("12.3", listResult.get(0));    
    }

    /**
     * testConvertPrimitiveArrayToList22()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するfloat[]<br>
     *                 *要素0: 12.3F<br>
     *                 *要素1: 1.2F<br>
     *                 *要素2: 1F<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが3であることを確認)<br>
     *                   *要素0: "12.3"<br>
     *                   *要素1: "1.2"<br>
     *                   *要素2: "1.0"<br>
     *         
     * <br>
     * 引数valueがfloat型の配列(要素数3)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList22() throws Exception {
        // 前処理
        float[] value = {12.3F, 1.2F, 1F};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(3, listResult.size());
        assertEquals("12.3", listResult.get(0));    
        assertEquals("1.2", listResult.get(1));    
        assertEquals("1.0", listResult.get(2));    
    }

    /**
     * testConvertPrimitiveArrayToList23()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:要素を保持しないint[]<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:要素を保持しないList (sizeが0であることを確認)<br>
     *         
     * <br>
     * 引数valueが要素を保持しないint型の配列だった場合、要素を保持しないListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList23() throws Exception {
        // 前処理
        int[] value = new int[0];

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(0, listResult.size());
    }

    /**
     * testConvertPrimitiveArrayToList24()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するint[]<br>
     *                 *要素0: 1<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが1であることを確認)<br>
     *                   *要素0: "1"<br>
     *         
     * <br>
     * 引数valueがint型の配列(要素数1)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList24() throws Exception {
        // 前処理
        int[] value = {1};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(1, listResult.size());
        assertEquals("1", listResult.get(0));    
    }

    /**
     * testConvertPrimitiveArrayToList25()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するint[]<br>
     *                 *要素0: 1<br>
     *                 *要素1: 2<br>
     *                 *要素2: 3<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが3であることを確認)<br>
     *                   *要素0: "1"<br>
     *                   *要素1: "2"<br>
     *                   *要素2: "3"<br>
     *         
     * <br>
     * 引数valueがint型の配列(要素数3)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList25() throws Exception {
        // 前処理
        int[] value = {1, 2, 3};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(3, listResult.size());
        assertEquals("1", listResult.get(0));    
        assertEquals("2", listResult.get(1));    
        assertEquals("3", listResult.get(2));    
    }

    /**
     * testConvertPrimitiveArrayToList26()
     * <br><br>
     * 
     * (正常系) or (異常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:要素を保持しないlong[]<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:要素を保持しないList (sizeが0であることを確認)<br>
     *         
     * <br>
     * 引数valueが要素を保持しないlong型の配列だった場合、要素を保持しないListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList26() throws Exception {
        // 前処理
        long[] value = new long[0];

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(0, listResult.size());
    }

    /**
     * testConvertPrimitiveArrayToList27()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するlobg[]<br>
     *                 *要素0: 1L<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが1であることを確認)<br>
     *                   *要素0: "1"<br>
     *         
     * <br>
     * 引数valueがlong型の配列(要素数1)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList27() throws Exception {
        // 前処理
        long[] value = {1L};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(1, listResult.size());
        assertEquals("1", listResult.get(0));    
    }

    /**
     * testConvertPrimitiveArrayToList28()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するlong[]<br>
     *                 *要素0: 1L<br>
     *                 *要素1: 2L<br>
     *                 *要素2: 3L<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが3であることを確認)<br>
     *                   *要素0: "1"<br>
     *                   *要素1: "2"<br>
     *                   *要素2: "3"<br>
     *         
     * <br>
     * 引数valueがlong型の配列(要素数3)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList28() throws Exception {
        // 前処理
        long[] value = {1L, 2L, 3L};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(3, listResult.size());
        assertEquals("1", listResult.get(0));    
        assertEquals("2", listResult.get(1));    
        assertEquals("3", listResult.get(2));    
    }

    /**
     * testConvertPrimitiveArrayToList29()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:要素を保持しないshort[]<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:要素を保持しないList (sizeが0であることを確認)<br>
     *         
     * <br>
     * 引数valueが要素を保持しないshort型の配列だった場合、要素を保持しないListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList29() throws Exception {
        // 前処理
        short[] value = new short[0];

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(0, listResult.size());

    }

    /**
     * testConvertPrimitiveArrayToList30()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するshort[]<br>
     *                 *要素0: (short) 1<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが1であることを確認)<br>
     *                   *要素0: "1"<br>
     *         
     * <br>
     * 引数valueがshort型の配列(要素数1)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList30() throws Exception {
        // 前処理
        short[] value = {(short) 1};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(1, listResult.size());
    }

    /**
     * testConvertPrimitiveArrayToList31()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D,E
     * <br><br>
     * 入力値：(引数) value:以下の要素を保持するshort[]<br>
     *                 *要素0: (short) 1<br>
     *                 *要素1: (short) 2<br>
     *                 *要素2: (short) 3<br>
     *         
     * <br>
     * 期待値：(戻り値) Object:以下の要素を保持するList(sizeが3であることを確認)<br>
     *                   *要素0: "1"<br>
     *                   *要素1: "2"<br>
     *                   *要素2: "3"<br>
     *         
     * <br>
     * 引数valueがshort型の配列(要素数3)だった場合、String型に変換された値を保持するListが返却されることを確認するテスト。
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testConvertPrimitiveArrayToList31() throws Exception {
        // 前処理
        short[] value = {(short) 1, (short) 2, (short) 3};

        // テスト実施
        Object result = ConvertUtil.convertPrimitiveArrayToList(value);
        
        // 判定
        assertNotNull(result);
        assertTrue(result instanceof List);
        List listResult = (List) result;
        assertEquals(3, listResult.size());
        assertEquals("1", listResult.get(0));    
        assertEquals("2", listResult.get(1));    
        assertEquals("3", listResult.get(2));    
    }

    /**
     * testToListOfMap01()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D, E
     * <br><br>
     * 入力値：(引数) obj:null<br>
     *         
     * <br>
     * 期待値：(戻り値) List<Map<String, Object>:要素を持たないObject[]<br>
     *         
     * <br>
     * 引数objがnullの場合、要素を持たないList<Map<String,Object>インスタンスが返ることを確認するテスト
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToListOfMap01() throws Exception {
        // 前処理
        // テスト実施
        List<Map<String, Object>> actual = ConvertUtil.toListOfMap(null);

        // 判定
        assertNotNull(actual);
        assertTrue(actual.isEmpty());
    }

    /**
     * testToListOfMap02()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D, E
     * <br><br>
     * 入力値：(引数) obj:3要素を持つJavaBeanスタブのリスト<br>
     *                要素0=JavaBeanスタブインスタンス<br>
     *                ＊フィールドA="value00"<br>
     *                要素1=JavaBeanスタブインスタンス<br>
     *                ＊フィールドA="value01"<br>
     *                要素2=JavaBeanスタブインスタンス<br>
     *                ＊フィールドA="value02"<br>
     *         
     * <br>
     * 期待値：(戻り値) List<Map<String, Object>:
     *      3要素を持つList<Map<String, Object>>インスタンス<br>
     *                  <br>
     *                  要素0-=Map<String,Object>インスタンス<br>
     *                  ＊key="a",value="value00"<br>
     *                  要素1=Map<String,Object>インスタンス<br>
     *                  ＊key="a",value="value01"<br>
     *                  要素2=Map<String,Object>インスタンス<br>
     *                  ＊key="a",value="value02"<br>
     *         
     * <br>
     * 引数objが複数のJavaBean要素を持つリストの場合、
     * 3つの要素を持つList<Map<String,Object>インスタンスが返ることを確認するテスト
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToListOfMap02() throws Exception {

        List<ConvertUtil_Stub01> obj = new ArrayList<ConvertUtil_Stub01>();
        ConvertUtil_Stub01 bean = new ConvertUtil_Stub01();
        bean.setA("value00");
        obj.add(bean);
        ConvertUtil_Stub01 bean02 = new ConvertUtil_Stub01();
        bean02.setA("value01");
        obj.add(bean02);
        ConvertUtil_Stub01 bean03 = new ConvertUtil_Stub01();
        bean03.setA("value02");
        obj.add(bean03);

        // テスト実施
        List<Map<String, Object>> actual = ConvertUtil.toListOfMap(obj);

        // 判定
        assertNotNull(actual);
        assertEquals(3, actual.size());
        assertEquals("value00", actual.get(0).get("a"));
        assertEquals("value01", actual.get(1).get("a"));
        assertEquals("value02", actual.get(2).get("a"));
    }

    /**
     * testToListOfMap03()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D, E
     * <br><br>
     * 入力値：(引数) obj:3要素を持つJavaBeanスタブ配列<br>
     *                要素0=JavaBeanスタブインスタンス<br>
     *                ＊フィールドA="value00"<br>
     *                要素1=JavaBeanスタブインスタンス<br>
     *                ＊フィールドA="value01"<br>
     *                要素2=JavaBeanスタブインスタンス<br>
     *                ＊フィールドA="value02"<br>
     *         
     * <br>
     * 期待値：(戻り値) List<Map<String, Object>:
     * 3要素を持つList<Map<String, Object>>インスタンス<br>
     *                  <br>
     *                  要素0-=Map<String,Object>インスタンス<br>
     *                  ＊key="a",value="value00"<br>
     *                  要素1=Map<String,Object>インスタンス<br>
     *                  ＊key="a",value="value01"<br>
     *                  要素2=Map<String,Object>インスタンス<br>
     *                  ＊key="a",value="value02"<br>
     *         
     * <br>
     * 引数objが複数のJavaBean要素を持つ配列の場合、
     * 3つの要素を持つList<Map<String,Object>インスタンスが返ることを確認するテスト
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToListOfMap03() throws Exception {
        ConvertUtil_Stub01 bean = new ConvertUtil_Stub01();
        bean.setA("value00");
        ConvertUtil_Stub01 bean02 = new ConvertUtil_Stub01();
        bean02.setA("value01");
        ConvertUtil_Stub01 bean03 = new ConvertUtil_Stub01();
        bean03.setA("value02");
        
        ConvertUtil_Stub01[] obj =
            new ConvertUtil_Stub01[] {bean, bean02, bean03};

        // テスト実施
        List<Map<String, Object>> actual = ConvertUtil.toListOfMap(obj);

        // 判定
        assertNotNull(actual);
        assertEquals(3, actual.size());
        assertEquals("value00", actual.get(0).get("a"));
        assertEquals("value01", actual.get(1).get("a"));
        assertEquals("value02", actual.get(2).get("a"));
    }

    /**
     * testToListOfMap04()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D, E
     * <br><br>
     * 入力値：(引数) obj:3要素を持つList<Map<String, Object>>インスタンス<br>
     *                <br>
     *                要素0=Map<String,Object>インスタンス<br>
     *                ＊key="a",value="value00"<br>
     *                要素1=Map<String,Object>インスタンス<br>
     *                ＊key="a",value="value01"<br>
     *                要素2=Map<String,Object>インスタンス<br>
     *                ＊key="a",value="value02"<br>
     *         
     * <br>
     * 期待値：(戻り値) List<Map<String, Object>:
     *      3要素を持つList<Map<String, Object>>インスタンス<br>
     *                  <br>
     *                  要素0-=Map<String,Object>インスタンス<br>
     *                  ＊key="a",value="value00"<br>
     *                  要素1=Map<String,Object>インスタンス<br>
     *                  ＊key="a",value="value01"<br>
     *                  要素2=Map<String,Object>インスタンス<br>
     *                  ＊key="a",value="value02"<br>
     *         
     * <br>
     * 引数objが複数のMap要素を持つリストの場合、
     * 3つの要素を持つList<Map<String,Object>インスタンスが返ることを確認するテスト
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToListOfMap04() throws Exception {
        List<Map<String, Object>> obj = new ArrayList<Map<String, Object>>();
        Map<String, Object> row = new HashMap<String, Object>();
        row.put("a", "value00");
        obj.add(row);
        Map<String, Object> row02 = new HashMap<String, Object>();
        row02.put("a", "value01");
        obj.add(row02);
        Map<String, Object> row03 = new HashMap<String, Object>();
        row03.put("a", "value02");
        obj.add(row03);


        // テスト実施
        List<Map<String, Object>> actual = ConvertUtil.toListOfMap(obj);

        // 判定
        assertNotNull(actual);
        assertEquals(3, actual.size());
        assertEquals("value00", actual.get(0).get("a"));
        assertEquals("value01", actual.get(1).get("a"));
        assertEquals("value02", actual.get(2).get("a"));
    }

    /**
     * testToListOfMap05()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：D, E
     * <br><br>
     * 入力値：(引数) obj:3要素を持つMap<String, Object>インスタンスの配列<br>
     *                <br>
     *                要素0=Map<String,Object>インスタンス<br>
     *                ＊key="a",value="value00"<br>
     *                要素1=Map<String,Object>インスタンス<br>
     *                ＊key="a",value="value01"<br>
     *                要素2=Map<String,Object>インスタンス<br>
     *                ＊key="a",value="value02"<br>
     *         
     * <br>
     * 期待値：(戻り値) List<Map<String, Object>:
     *      3要素を持つList<Map<String, Object>>インスタンス<br>
     *                  <br>
     *                  要素0-=Map<String,Object>インスタンス<br>
     *                  ＊key="a",value="value00"<br>
     *                  要素1=Map<String,Object>インスタンス<br>
     *                  ＊key="a",value="value01"<br>
     *                  要素2=Map<String,Object>インスタンス<br>
     *                  ＊key="a",value="value02"<br>
     *         
     * <br>
     * 引数objが複数のMap要素を持つ配列の場合、
     * 3つの要素を持つList<Map<String,Object>インスタンスが返ることを確認するテスト
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToListOfMap05() throws Exception {
        Map<String, Object> row = new HashMap<String, Object>();
        row.put("a", "value00");
        Map<String, Object> row02 = new HashMap<String, Object>();
        row02.put("a", "value01");
        Map<String, Object> row03 = new HashMap<String, Object>();
        row03.put("a", "value02");
        
        Map[] obj = new Map[] {row, row02, row03};


        // テスト実施
        List<Map<String, Object>> actual = ConvertUtil.toListOfMap(obj);

        // 判定
        assertNotNull(actual);
        assertEquals(3, actual.size());
        assertEquals("value00", actual.get(0).get("a"));
        assertEquals("value01", actual.get(1).get("a"));
        assertEquals("value02", actual.get(2).get("a"));
    }
    
    /**
     * testToListOfMap06()
     * <br><br>
     * 
     * (正常系)
     * <br>
     * 観点：G
     * <br><br>
     * 入力値：(引数) obj:JavaBeanスタブインスタンス<br>
     *                ＊フィールドA="value00"<br>
     *         
     * <br>
     * 期待値：(戻り値) List<Map<String, Object>:
     *      1要素を持つList<Map<String, Object>>インスタンス<br>
     *                  <br>
     *                  要素0-=Map<String,Object>インスタンス<br>
     *                  ＊key=A,value="value00"<br>
     *         
     * <br>
     * 引数objがJavaBeanの場合、1つの要素を持つ
     * List<Map<String,Object>インスタンスが返ることを確認するテスト
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToListOfMap06() throws Exception {
        ConvertUtil_Stub01 obj = new ConvertUtil_Stub01();
        obj.setA("value00");

        // テスト実施
        List<Map<String, Object>> actual = ConvertUtil.toListOfMap(obj);

        // 判定
        assertNotNull(actual);
        assertEquals(1, actual.size());
        assertEquals("value00", actual.get(0).get("a"));
    }

    /**
     * testToListOfMap08()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：G
     * <br><br>
     * 入力値：(引数) obj:JavaBeanスタブインスタンス<br>
     *                ＊フィールドA="value00"<br>
     *         (状態) PropertyUtils#describeの実行結果:
     *                  InvocationTargetExceptionをスロー
     *                    ※JavaBeanのgetterでRuntimeExceptionをスロー<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    ラップされた例外：InvocationTargetException<br>
     *         
     * <br>
     * PropertyUtils#descriveでInvocationTargetExceptionがスローされた場合のテスト
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToListOfMap08() throws Exception {
        // 前処理
        ConvertUtil_Stub02 obj = new ConvertUtil_Stub02();
        obj.setA("value00");

        try {
            // テスト実施
            ConvertUtil.toListOfMap(obj);
            fail();
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertTrue(e.getCause() instanceof InvocationTargetException);
        }

    }

    /**
     * testToListOfMap09()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：G
     * <br><br>
     * 入力値：(引数) obj:JavaBeanスタブインスタンス<br>
     *                ＊フィールドA="value00"<br>
     *         (状態) PropertyUtils#describeの実行結果:
     *                  IllegalAccessExceptionをスロー
     *                    ※PropertyUtilsBeanのスタブでIllegalAccessExceptionをスロー<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    ラップされた例外：IllegalAccessException<br>
     *         
     * <br>
     * PropertyUtils#descriveでIllegalAccessExceptionがスローされた場合のテスト
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToListOfMap09() throws Exception {
        // 前処理
        List<ConvertUtil_Stub01> obj = new ArrayList<ConvertUtil_Stub01>();
        ConvertUtil_Stub01 bean = new ConvertUtil_Stub01();
        bean.setA("value00");
        obj.add(bean);
        BeanUtilsBean beanUtilsBean = BeanUtilsBean.getInstance();
        UTUtil.setPrivateField(beanUtilsBean, "propertyUtilsBean",
                new ConvertUtil_PropertyUtilsBeanStub01());
        
        try {
            // テスト実施
            ConvertUtil.toListOfMap(obj);
            fail();
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertTrue(e.getCause() instanceof IllegalAccessException);
        }

    }

    /**
     * testToListOfMap10()
     * <br><br>
     * 
     * (異常系)
     * <br>
     * 観点：G
     * <br><br>
     * 入力値：(引数) obj:JavaBeanスタブインスタンス<br>
     *                ＊フィールドA="value00"<br>
     *         (状態) PropertyUtils#describeの実行結果:
     *                  NoSuchMethodExceptionをスロー
     *                    ※PropertyUtilsBeanのスタブでNoSuchMethodExceptionをスロー<br>
     *         
     * <br>
     * 期待値：(状態変化) 例外:IllegalArgumentException<br>
     *                    ラップされた例外：NoSuchMethodException<br>
     *         
     * <br>
     * PropertyUtils#descriveでNoSuchMethodExceptionがスローされた場合のテスト
     * <br>
     * 
     * @throws Exception このメソッドで発生した例外
     */
    public void testToListOfMap10() throws Exception {
        // 前処理
        List<ConvertUtil_Stub01> obj = new ArrayList<ConvertUtil_Stub01>();
        ConvertUtil_Stub01 bean = new ConvertUtil_Stub01();
        bean.setA("value00");
        obj.add(bean);
        BeanUtilsBean beanUtilsBean = BeanUtilsBean.getInstance();
        UTUtil.setPrivateField(beanUtilsBean, "propertyUtilsBean",
                new ConvertUtil_PropertyUtilsBeanStub02());
        
        try {
            // テスト実施
            ConvertUtil.toListOfMap(obj);
            fail();
        } catch (IllegalArgumentException e) {
            // 判定
            assertEquals(IllegalArgumentException.class.getName(),
                    e.getClass().getName());
            assertTrue(e.getCause() instanceof NoSuchMethodException);
        }

    }
}
