チェンジセット 221

差分発生行の前後
無視リスト:
コミット日時:
2008/04/14 21:31:14 (14 年前)
コミッタ:
shinomiya
ログメッセージ:
  • ImJson#toJSONString?(value, true)のJavaのクラス名表示形式を変更。

  • newInstanceFilledProperty()で生成されるサンプルデータを設定可能に変更。

  • テストケース作成完了
ファイル:

凡例:

変更無し
追加
削除
更新
コピー
移動
  • trunk/im-jssp/src/main/java/org/intra_mart/jssp/util/JavaScriptUtility.java

    r214 r221  
    88import java.lang.reflect.InvocationTargetException; 
    99import java.lang.reflect.Method; 
     10import java.util.ArrayList; 
    1011import java.util.Calendar; 
    1112import java.util.Date; 
    1213import java.util.Iterator; 
     14import java.util.List; 
    1315import java.util.Map; 
    1416import java.util.WeakHashMap; 
    1517 
     18import org.intra_mart.common.platform.log.Logger; 
    1619import org.intra_mart.jssp.script.ScriptScope; 
    1720import org.intra_mart.jssp.script.provider.ScriptScopeBuilder; 
     
    127130                        return beans; 
    128131                } 
     132                else if (beans instanceof Character) { 
     133                        return ((Character)beans).toString(); 
     134                } 
    129135                else if (targetType.equals(char.class)) { 
    130136                        // TODO AutoBoxingに頼っていいの? 
     
    132138                        return chars.toString(); 
    133139                } 
    134  
     140         
    135141                // 数値 
    136142                else if (beans instanceof Number) { 
     
    197203 
    198204                        // Javaのクラス名を格納(隠しプロパティ) 
    199                         setProperty4imJavaClassName(nativeArray, targetType.getComponentType()); 
     205                        setProperty4imJavaClassName(nativeArray, "", targetType.getComponentType()); 
    200206                        return nativeArray; 
    201207                } 
     
    206212                        ScriptableObject jsObject = new ValueObject(); 
    207213                         
     214                        Map<String, PropertyDescriptor> map = getBeansPropertyMap(targetType); 
     215                        Iterator<Map.Entry<String, PropertyDescriptor>> it = map.entrySet().iterator(); 
     216                         
     217                        while(it.hasNext()){ 
     218                                Map.Entry<String, PropertyDescriptor> entry = it.next(); 
     219                                PropertyDescriptor propDescriptor = entry.getValue(); 
     220                                 
     221                                String propName = propDescriptor.getName(); 
     222                                Method readMethod = propDescriptor.getReadMethod(); 
     223                                 
     224                                // ********* 再帰 ********* 
     225                                Object value4Java = readMethod.invoke(beans, new Object[0]);  
     226                                Object obj = convertJavaBeans2JsObject(value4Java); 
     227                                 
     228                                // JSオブジェクト に プロパティ を 設定 
     229                                ScriptableObject.putProperty(jsObject, propName, obj); 
     230                                 
     231                                // Javaのクラス名を格納(隠しプロパティ) 
     232                                setProperty4imJavaClassName(jsObject, propName, readMethod.getReturnType()); 
     233                        } 
     234                         
    208235                        // Javaのクラス名を格納(隠しプロパティ) 
    209                         setProperty4imJavaClassName(jsObject, targetType); 
    210  
    211                         BeanInfo info = Introspector.getBeanInfo(targetType); 
    212                         PropertyDescriptor[] propDiscriptorList = info.getPropertyDescriptors(); 
    213                          
    214                         for(PropertyDescriptor propDiscriptor : propDiscriptorList){ 
    215                                 Method readMethod = propDiscriptor.getReadMethod(); 
    216                                  
    217                                 // 引数なしのgetXXX,isXXX に対応。 
    218                                 Object value4Java = readMethod.invoke(beans, new Object[0]);  
    219                                 String propName = propDiscriptor.getName(); 
    220                                  
    221                                 // Object#getClass()以外 
    222                                 if(readMethod.getName().equals("getClass") && readMethod.getReturnType().equals(Class.class)){ 
    223                                         continue; 
    224                                 } 
    225                                 else{ 
    226                                         // ********* 再帰 ********* 
    227                                         Object obj = convertJavaBeans2JsObject(value4Java); 
    228                                          
    229                                         // JSオブジェクト に プロパティ を 設定 
    230                                         ScriptableObject.putProperty(jsObject, propName, obj); 
    231                                          
    232                                 } 
    233                         } 
     236                        setProperty4imJavaClassName(jsObject, "", targetType); 
    234237                         
    235238                        return jsObject; 
     
    242245                                                         "getSimpleName"); 
    243246 
    244         private static void setProperty4imJavaClassName(ScriptableObject jsObject, Class<?> targetType) { 
     247        private static void setProperty4imJavaClassName(ScriptableObject jsObject, String propName, Class<?> targetType) { 
    245248                Object typeName = Undefined.instance; 
    246249                 
     
    255258                } 
    256259                 
    257                 jsObject.defineProperty("__javaClassName__", typeName, ScriptableObject.DONTENUM); 
     260                jsObject.defineProperty("__javaClassName_" + propName + "__", typeName, ScriptableObject.DONTENUM); 
    258261        } 
    259262         
     
    265268        public static Object convertJsObject2JavaBeans(Object jsObject, String type, ClassLoader classLoader) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, InstantiationException, ClassNotFoundException, IntrospectionException{ 
    266269 
    267                 if(type.equals("char")) { 
    268                         return ((Character)jsObject).charValue(); 
     270                if(jsObject == null){ 
     271                        return null; 
     272                } 
     273                else if(type.equals("char")) { 
     274                        return jsObject.toString().charAt(0); 
    269275                } 
    270276                else if(type.equals("double")) { 
    271                         return ((Double)jsObject).doubleValue(); 
     277                        return new Double(jsObject.toString()); 
    272278                } 
    273279                else if(type.equals("float")) { 
    274                         return ((Float)jsObject).floatValue(); 
     280                        return new Float(jsObject.toString()); 
    275281                } 
    276282                else if(type.equals("long")) { 
    277                         return ((Long)jsObject).longValue(); 
     283                        return new Long(jsObject.toString()); 
    278284                } 
    279285                else if(type.equals("int")) { 
    280                         return ((Integer)jsObject).intValue(); 
     286                        return new Integer(jsObject.toString()); 
    281287                } 
    282288                else if(type.equals("short")) { 
    283                         return ((Short)jsObject).shortValue(); 
     289                        return new Short(jsObject.toString()); 
    284290                } 
    285291                else if(type.equals("byte")) { 
    286                         return ((Byte)jsObject).byteValue(); 
     292                        return new Byte(jsObject.toString()); 
    287293                } 
    288294                else if(type.equals("boolean")) { 
    289                         return ((Boolean)jsObject).booleanValue(); 
     295                        return new Boolean(jsObject.toString()); 
    290296                } 
    291297                else{ 
     
    439445                                         
    440446                                        for(PropertyDescriptor propDiscriptor : propDiscriptorList){ 
    441                                                 map.put(propDiscriptor.getName(), propDiscriptor); 
     447                                                // Getter/Setterが両方あること。(それ以外はこのメソッドではプロパティとみなさない) 
     448                                                if(propDiscriptor.getReadMethod() != null  
     449                                                   && 
     450                                                   propDiscriptor.getWriteMethod() != null 
     451                                                ){ 
     452                                                        map.put(propDiscriptor.getName(), propDiscriptor); 
     453                                                } 
    442454                                        } 
    443455                                         
     
    500512                                                        throws IntrospectionException, IllegalArgumentException,  
    501513                                                                        IllegalAccessException, InvocationTargetException, InstantiationException{ 
    502                 return newInstanceFilledProperty(beanType, defaultValue, false); 
    503         } 
    504  
     514                 
     515                try{ 
     516                        threadLocal4newInstanceFilledProperty.set(new ArrayList<Class<?>>()); 
     517                         
     518                        return newInstanceFilledProperty(beanType, defaultValue, false); 
     519                } 
     520                finally{ 
     521                        threadLocal4newInstanceFilledProperty.remove(); 
     522                } 
     523        } 
     524         
     525        private static ThreadLocal<List<Class<?>>> threadLocal4newInstanceFilledProperty = new ThreadLocal<List<Class<?>>>(); 
     526 
     527        private static Logger _logger4newInstance =  
     528                Logger.getLogger(JavaScriptUtility.class.getName() + ".newInstanceFilledProperty"); 
     529         
    505530        // TODO 配列要素数を設定可能に 
    506531        private static int _sampleDataArrayLength = 1; // 配列要素数 
    507532         
    508         private static Object newInstanceFilledProperty(Class<?> beanType, String defaultValue, boolean isLast)  
     533        private static Object newInstanceFilledProperty(final Class<?> beanType, 
     534                                                                                                        final String defaultValue, 
     535                                                                                                        final boolean isLast)  
    509536                                                        throws IntrospectionException, IllegalArgumentException,  
    510537                                                                        IllegalAccessException, InvocationTargetException, InstantiationException{ 
    511538                 
     539                _logger4newInstance.trace("------------"); 
     540                _logger4newInstance.trace("isLast: {}", isLast); 
     541                _logger4newInstance.trace("beanType: {}", beanType); 
     542                _logger4newInstance.trace("defaultValue: {}", defaultValue); 
     543                _logger4newInstance.trace("------------"); 
     544 
    512545                Object beanInstance = generatePrimitiveOrWrapperInstance(beanType, defaultValue); 
    513                  
     546 
    514547                if(beanInstance != null){ 
    515548                        Object primitiveOrWrapperInstance = beanInstance; 
     549                        _logger4newInstance.trace("primitiveOrWrapperInstance: {}", primitiveOrWrapperInstance); 
     550                         
    516551                        return primitiveOrWrapperInstance; 
    517552                } 
    518                 else{ 
    519                         beanInstance = beanType.newInstance(); 
    520                 } 
     553 
     554                // 走査済みクラスとして設定 
     555                setScannedClass(beanType); 
     556                _logger4newInstance.trace("[execute] setScannedClass(): {}", beanType); 
     557 
     558                beanInstance = beanType.newInstance(); 
    521559                 
    522560                Map<String, PropertyDescriptor> map = getBeansPropertyMap(beanType); 
    523561                Iterator<Map.Entry<String, PropertyDescriptor>> it = map.entrySet().iterator(); 
     562                 
     563                _logger4newInstance.trace("↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓"); 
    524564                while(it.hasNext()){ 
    525565                        Map.Entry<String, PropertyDescriptor> entry = it.next(); 
     
    531571                        } 
    532572 
     573                        _logger4newInstance.trace("========================="); 
    533574                        Class<?> propType = propDescriptor.getPropertyType(); 
    534575                        String propName = propDescriptor.getName(); 
    535576                        String newDefaultValue = "prop_" + propName; 
    536577                         
     578                        _logger4newInstance.trace("----"); 
     579                        _logger4newInstance.trace("propName: {}", propName); 
     580                        _logger4newInstance.trace("newDefaultValue: {}", newDefaultValue); 
     581                        _logger4newInstance.trace("----"); 
     582                        _logger4newInstance.trace("isLast: {}", isLast); 
     583                        _logger4newInstance.trace("beanType: {}", beanType); 
     584                        _logger4newInstance.trace("propType: {}", propType); 
     585                         
    537586                        Object data; 
     587                         
     588                        // 通常のオブジェクトの場合 
    538589                        if(!propType.isArray()){ 
    539                                 if(isLast){ 
     590                                boolean isRecursive = isRecursive(isLast, beanType, propType); 
     591                                _logger4newInstance.trace("--OBJECT-- isRecursive: {}", isRecursive); 
     592                                 
     593                                if(isRecursive){ 
     594                                        // 再帰 
     595                                        _logger4newInstance.trace("--OBJECT-- [RECURSIVE] newInstanceFilledProperty()"); 
     596                                        data = newInstanceFilledProperty(propType, newDefaultValue, isLast); 
     597                                } 
     598                                else{ 
     599                                        _logger4newInstance.trace("--OBJECT-- [execute] generatePrimitiveOrWrapperInstance()"); 
    540600                                        data = generatePrimitiveOrWrapperInstance(propType, newDefaultValue); 
    541601                                } 
    542                                 else{ 
    543                                         if(propType.equals(beanType)){ 
    544                                                 isLast = true; // 次で終わり 
    545                                         } 
    546                                          
    547                                         // 再帰 
    548                                         data = newInstanceFilledProperty(propType, newDefaultValue, isLast); 
    549                                 } 
    550                         } 
     602                        } 
     603                         
    551604                        // 配列の場合 
    552605                        else{ 
    553606                                Class<?> componentType = propType.getComponentType(); 
    554                                 if(isLast){ 
    555                                         data = Array.newInstance(componentType, 0); // 空の配列 
    556                                 } 
    557                                 else { 
     607 
     608                                boolean isRecursive = isRecursive(isLast, beanType, componentType); 
     609                                 
     610                                _logger4newInstance.trace("--ARRAY-- componentType: {}", componentType); 
     611                                _logger4newInstance.trace("--ARRAY-- isRecursive: {}", isRecursive); 
     612 
     613                                if(isRecursive){ 
    558614                                        data = Array.newInstance(componentType, _sampleDataArrayLength); 
    559615                                        for(int idx = 0; idx < _sampleDataArrayLength; idx++){ 
    560                                                 isLast = true; // 次で終わり 
    561                                                  
    562616                                                // 再帰 
     617                                                _logger4newInstance.trace("--ARRAY-- [RECURSIVE] newInstanceFilledProperty()"); 
    563618                                                Object dataElem = newInstanceFilledProperty(componentType, newDefaultValue, isLast); 
    564619                                                Array.set(data, idx, dataElem); 
    565620                                        } 
    566621                                } 
    567                         } 
     622                                else { 
     623                                        _logger4newInstance.trace("--ARRAY-- [execute] generateEmptyArray()"); 
     624                                        data = Array.newInstance(componentType, 0); // 空の配列 
     625                                } 
     626                        } 
     627                         
    568628                        setter.invoke(beanInstance, data); 
    569                 } 
    570                  
     629                        _logger4newInstance.trace("========================="); 
     630                         
     631                } 
     632                _logger4newInstance.trace("↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑"); 
     633 
    571634                return beanInstance; 
    572635        } 
    573                  
    574  
    575         private static Object generatePrimitiveOrWrapperInstance(Class<?> type, String defaultValue) { 
    576  
    577                 defaultValue = (defaultValue == null) ? "__default___" : defaultValue; 
    578                  
     636 
     637 
     638        private static boolean isRecursive(final boolean isLast, final Class<?> beanType, final Class<?> propType) { 
     639                return !isLast 
     640                           && 
     641                           !beanType.getName().equals(propType.getName()) 
     642                           && 
     643                           !isScannedClass(propType); 
     644                 
     645        } 
     646 
     647        private static void setScannedClass(final Class<?> beanType) { 
     648                List<Class<?>> list = threadLocal4newInstanceFilledProperty.get(); 
     649                list.add(beanType); 
     650                threadLocal4newInstanceFilledProperty.set(list); 
     651        } 
     652                 
     653        private static boolean isScannedClass(final Class<?> beanType) { 
     654                List<Class<?>> list = threadLocal4newInstanceFilledProperty.get(); 
     655                return list.contains(beanType); 
     656        } 
     657 
     658        private static Object generatePrimitiveOrWrapperInstance(final Class<?> type, final String defaultValue) { 
     659 
     660                String def = defaultValue; 
     661                if(def == null || def.length() == 0) { 
     662                        def = SAMPLE_DATA_FOR_STRING; 
     663                } 
     664                 
     665                // =================== 
     666                // 文字列 
     667                // =================== 
    579668                if(type.equals(java.lang.String.class)){ 
    580                         return new String(defaultValue); 
    581                 } 
    582                  
    583                 else if(type.equals(char.class)) { 
    584                         char ch = defaultValue.charAt(0); 
    585                         return ch; 
    586                 } 
    587                  
     669                        return new String(def); 
     670                } 
     671                 
     672                else if(type.equals(java.lang.Character.class) 
     673                                || 
     674                                type.equals(char.class)) { 
     675                        char ch = def.charAt(0); 
     676                        return new Character(ch); 
     677                } 
     678                 
     679                // =================== 
     680                // 数値 
     681                // =================== 
    588682                else if(type.equals(java.lang.Number.class) 
    589683                                || 
    590                                 type.equals(double.class) 
     684                                type.equals(java.lang.Double.class) 
    591685                                || 
    592                                 type.equals(float.class) 
     686                                type.equals(double.class)){ 
     687                        return SAMPLE_DATA_FOR_NUMBER.doubleValue(); 
     688                } 
     689                 
     690                else if(type.equals(java.lang.Float.class) 
    593691                                || 
    594                                 type.equals(long.class) 
     692                                type.equals(float.class)){ 
     693                        return SAMPLE_DATA_FOR_NUMBER.floatValue(); 
     694                } 
     695                else if(type.equals(java.lang.Long.class) 
    595696                                || 
    596                                 type.equals(int.class) 
     697                                type.equals(long.class)){ 
     698                        return SAMPLE_DATA_FOR_NUMBER.longValue(); 
     699                } 
     700 
     701                else if(type.equals(java.lang.Integer.class) 
    597702                                || 
    598                                 type.equals(short.class) 
     703                                type.equals(int.class)){ 
     704                        return SAMPLE_DATA_FOR_NUMBER.intValue(); 
     705                } 
     706 
     707                else if(type.equals(java.lang.Short.class) 
     708                                || 
     709                                type.equals(short.class)){ 
     710                        return SAMPLE_DATA_FOR_NUMBER.shortValue(); 
     711                } 
     712                 
     713                else if(type.equals(java.lang.Byte.class) 
    599714                                || 
    600715                                type.equals(byte.class)){ 
    601                          
    602                         int randomNumber = (int)(Math.random() * 10 + 1); 
    603                         return randomNumber; 
    604                 } 
    605                  
     716                        return SAMPLE_DATA_FOR_NUMBER.byteValue(); 
     717                } 
     718                 
     719                // =================== 
     720                // 真偽値 
     721                // =================== 
    606722                else if(type.equals(java.lang.Boolean.class) 
    607723                                || 
    608724                                type.equals(boolean.class)){ 
    609725                         
    610                         int randomNumber = (int)(Math.random() * 10 + 1); 
    611                         if(randomNumber % 2 == 0){ 
    612                                 return true; 
    613                         } 
    614                         else{ 
    615                                 return false; 
    616                         } 
    617                 } 
    618                  
     726                        return SAMPLE_DATA_FOR_BOOLEAN; 
     727                } 
     728                 
     729                // =================== 
     730                // 日付 (Date) 
     731                // =================== 
    619732                else if(type.equals(java.util.Date.class)){ 
    620                         return Calendar.getInstance().getTime(); 
    621                 } 
    622                  
     733                        return SAMPLE_DATA_FOR_DATE; 
     734                } 
     735                 
     736                // =================== 
     737                // 日付 (Calendar) 
     738                // =================== 
    623739                else if(type.equals(java.util.Calendar.class)){ 
    624                         return Calendar.getInstance(); 
    625                 } 
    626                  
     740                        Calendar cal = Calendar.getInstance(); 
     741                        cal.setTime(SAMPLE_DATA_FOR_DATE); 
     742                         
     743                        return cal; 
     744                } 
     745                 
     746                // =================== 
    627747                // 上記以外 (≒ Primitive型、または、Wrapperクラスではない場合) 
     748                // =================== 
    628749                else{ 
    629750                        return null; 
    630751                } 
    631752        } 
     753         
     754        private static String SAMPLE_DATA_FOR_STRING; 
     755        private static Number SAMPLE_DATA_FOR_NUMBER; 
     756        private static Boolean SAMPLE_DATA_FOR_BOOLEAN; 
     757        private static Date SAMPLE_DATA_FOR_DATE; 
     758 
     759        static{ 
     760                initializeSampleData(null, null, null, null); 
     761        } 
     762         
     763         
     764        /** 
     765         * @param str 空文字設定不可 
     766         * @param num 
     767         * @param bool 
     768         * @param date 
     769         */ 
     770        public static void initializeSampleData(String str, Number num, Boolean bool, Date date){ 
     771 
     772                // String 
     773                if(str != null && str.length() != 0){ 
     774                        SAMPLE_DATA_FOR_STRING = str; 
     775                } 
     776                else { 
     777                        SAMPLE_DATA_FOR_STRING = "__default__"; 
     778                } 
     779                 
     780                // Number 
     781                if(num != null){ 
     782                        SAMPLE_DATA_FOR_NUMBER = num; 
     783                } 
     784                else{ 
     785                        SAMPLE_DATA_FOR_NUMBER = new Double(123); 
     786                } 
     787                 
     788                // Boolean 
     789                if(bool != null){ 
     790                        SAMPLE_DATA_FOR_BOOLEAN = bool; 
     791                } 
     792                else{ 
     793                        SAMPLE_DATA_FOR_BOOLEAN = Boolean.TRUE; 
     794                } 
     795                 
     796                // Calendar 
     797                if(date != null){ 
     798                        SAMPLE_DATA_FOR_DATE = date; 
     799                } 
     800                else{ 
     801                        SAMPLE_DATA_FOR_DATE = new Date(1213846496000L); // "Mon June 19 2008 12:34:56 GMT+0900 (JST)" 
     802                } 
     803        } 
     804         
    632805 
    633806} 
  • trunk/im-jssp/src/test/java/org/intra_mart/jssp/util/JavaScriptUtilityTest.java

    r217 r221  
    11package org.intra_mart.jssp.util; 
    22 
     3import java.beans.PropertyDescriptor; 
     4import java.util.ArrayList; 
     5import java.util.Calendar; 
     6import java.util.Date; 
     7import java.util.HashMap; 
     8import java.util.HashSet; 
     9import java.util.Iterator; 
     10import java.util.List; 
     11import java.util.Map; 
     12import java.util.Set; 
     13 
    314import junit.framework.TestCase; 
    415 
     16import org.mozilla.javascript.Context; 
     17import org.mozilla.javascript.NativeArray; 
    518import org.mozilla.javascript.ScriptRuntime; 
    619 
    720public class JavaScriptUtilityTest extends TestCase { 
    821 
     22         
     23        @Override 
     24        protected void setUp() throws Exception { 
     25                super.setUp(); 
     26 
     27                Context.enter(); 
     28                JavaScriptUtility.initializeSampleData(null, null, null, null); 
     29        } 
     30         
     31 
     32        @Override 
     33        protected void tearDown() throws Exception { 
     34                super.tearDown(); 
     35                 
     36                Context.exit(); 
     37        } 
     38 
     39 
    940        public void testExecuteVoidFunction() { 
    10                 fail("まだ実装されていません。"); 
     41                assertTrue("サーバサイドで実行する必要があるテストです", true); 
    1142        } 
    1243 
    1344        public void testExecuteFunction() { 
    14                 fail("まだ実装されていません。"); 
    15         } 
     45                assertTrue("サーバサイドで実行する必要があるテストです", true); 
     46        } 
     47 
    1648 
    1749        // TODO エスケープ文字 
     
    2860 
    2961                assertTrue(char.class != actual.getClass()); 
    30                 assertEquals(Character.class, actual.getClass()); 
    31                 assertEquals(value, actual); 
     62                assertEquals(String.class, actual.getClass()); 
     63                assertEquals((new Character(value)).toString(), actual); 
    3264        } 
    3365 
     
    108140                Object actual = JavaScriptUtility.convertJavaBeans2JsObject(value); 
    109141 
    110                 assertEquals(Character.class, actual.getClass()); 
    111                 assertEquals(value, actual); 
     142                assertEquals(String.class, actual.getClass()); 
     143                assertEquals((new Character(value)).toString(), actual); 
    112144        } 
    113145 
     
    226258        } 
    227259 
    228         public void testConvertJavaBeans2JsObject_JavaBeansではないクラス() throws Exception { 
    229                 fail("まだ実装されていません。"); 
    230         } 
    231          
    232         public void testConvertJavaBeans2JsObject_JavaBeans() throws Exception { 
    233                 fail("まだ実装されていません。"); 
    234         } 
    235  
    236         public void testConvertJsObject2JavaBeansObjectString() throws Exception { 
    237                 fail("まだ実装されていません。"); 
    238         } 
    239  
    240         public void testConvertJsObject2JavaBeansObjectStringClassLoader() throws Exception { 
    241                 fail("まだ実装されていません。"); 
    242         } 
    243  
    244         public void testConvertJsObject2JavaBeansObjectClassOfQ() throws Exception { 
    245                 fail("まだ実装されていません。"); 
    246         } 
    247  
    248         public void testGetBeansPropertyMap() throws Exception { 
    249                 fail("まだ実装されていません。"); 
     260        public void testConvertJavaBeans2JsObject_変換対象外なクラス_List() throws Exception { 
     261                List value = new ArrayList();  
     262                Object actual = JavaScriptUtility.convertJavaBeans2JsObject(value); 
     263                 
     264                assertEquals(ValueObject.class, actual.getClass()); 
     265                ValueObject actualValueObj = (ValueObject)actual; 
     266                 
     267                assertEquals(0, actualValueObj.getIds().length); 
     268        } 
     269         
     270        public void testConvertJavaBeans2JsObject_変換対象外なクラス_Map() throws Exception { 
     271                Map value = new HashMap();  
     272                Object actual = JavaScriptUtility.convertJavaBeans2JsObject(value); 
     273                 
     274                assertEquals(ValueObject.class, actual.getClass()); 
     275                ValueObject actualValueObj = (ValueObject)actual; 
     276                 
     277                assertEquals(0, actualValueObj.getIds().length); 
     278        } 
     279 
     280        public void testConvertJavaBeans2JsObject_変換対象外なクラス_Set() throws Exception { 
     281                Set value = new HashSet(); 
     282                Object actual = JavaScriptUtility.convertJavaBeans2JsObject(value); 
     283                 
     284                assertEquals(ValueObject.class, actual.getClass()); 
     285                ValueObject actualValueObj = (ValueObject)actual; 
     286                 
     287                assertEquals(0, actualValueObj.getIds().length); 
    250288        } 
    251289 
    252290        /** 
    253291         * <pre> 
    254          * A ・・・【1】 
    255          * ├─A  → (内部走査しない ∵自身) 
    256          * │ 
    257          * ├─B ・・・『2』 
    258          * │  │ 
    259          * │  ├─A  → (内部走査しない ∵既に【1】で走査済み) 
    260          * │  │ 
    261          * │  ├─B  → (内部走査しない ∵自身) 
    262          * │  │ 
    263          * │  ├─C ・・・《3》 
    264          * │  │  │ 
    265          * │  │  ├─A    → (内部走査しない ∵既に【1】で走査済み) 
    266          * │  │  │ 
    267          * │  │  ├─B    → (内部走査しない ∵既に『2』で走査済み) 
    268          * │  │  │ 
    269          * │  │  ├─C    → (内部走査しない ∵自身) 
    270          * │  │  │ 
    271          * │  │  ├─Wrap → (内部走査終了可能) 
    272          * │  │  │ 
    273          * │  │  ├─A[]  → (内部走査しない ∵既に【1】で走査済み) 
    274          * │  │  │ 
    275          * │  │  ├─B[]  → (内部走査しない ∵既に『2』で走査済み) 
    276          * │  │  │ 
    277          * │  │  └─C[]  → (内部走査しない ∵既に《3》で走査済み) 
    278          * │  │ 
    279          * │  ├─A[] → (内部走査しない ∵既に【1】で走査済み) 
    280          * │  │ 
    281          * │  ├─B[] → (内部走査しない ∵既に『2』で走査済み) 
    282          * │  │ 
    283          * │  └─C[] → (内部走査しない ∵既に《3》で走査済み) 
    284          * │ 
    285          * ├─A[] → (内部走査しない ∵既に【1】で走査済み) 
    286          * │ 
    287          * └─B[] → (内部走査しない ∵既に『2』で走査済み) 
     292         * function createTestData(){ 
     293         *     load('jssp/script/api/soap_client_helper'); 
     294         *  
     295         *     var beanType = "org.intra_mart.jssp.util.JavaScriptUtilityTestModelA"; 
     296         *     var bean = Packages.org.intra_mart.jssp.util.JavaScriptUtility.newInstanceFilledProperty(beanType, "hoge"); 
     297         *     var obj = Packages.org.intra_mart.jssp.util.JavaScriptUtility.convertJavaBeans2JsObject(bean); 
     298         *         obj = normalize(obj);         
     299         *     Debug.console(obj); 
     300         * } 
     301         * </pre> 
     302         *  
     303         * <pre> 
     304         *   0: ========== 1 ========== 
     305         *   1: /&#42; Object &lt;JavaScriptUtilityTestModelA&gt; &#42;/ 
     306         *   2: { 
     307         *   3:     /&#42; Null &lt;JavaScriptUtilityTestModelA&gt; &#42;/ 
     308         *   4:     "modelA" : null,  
     309         *   5:  
     310         *   6:     /&#42; Object &lt;JavaScriptUtilityTestModelB&gt; &#42;/ 
     311         *   7:     "modelB" : { 
     312         *   8:         /&#42; Null &lt;JavaScriptUtilityTestModelA&gt; &#42;/ 
     313         *   9:         "modelA" : null,  
     314         *  10:  
     315         *  11:         /&#42; Null &lt;JavaScriptUtilityTestModelB&gt; &#42;/ 
     316         *  12:         "modelB" : null,  
     317         *  13:  
     318         *  14:         /&#42; Object &lt;JavaScriptUtilityTestModelC&gt; &#42;/ 
     319         *  15:         "modelC" : { 
     320         *  16:             /&#42; Null &lt;JavaScriptUtilityTestModelA&gt; &#42;/ 
     321         *  17:             "modelA" : null,  
     322         *  18:  
     323         *  19:             /&#42; Number &#42;/ 
     324         *  20:             "valueWrapperNumberModelC" : 123,  
     325         *  21:  
     326         *  22:             /&#42; Null &lt;JavaScriptUtilityTestModelB&gt; &#42;/ 
     327         *  23:             "modelB" : null,  
     328         *  24:  
     329         *  25:             /&#42; Null &lt;JavaScriptUtilityTestModelC&gt; &#42;/ 
     330         *  26:             "modelC" : null,  
     331         *  27:  
     332         *  28:             /&#42; Array &lt;JavaScriptUtilityTestModelA[]&gt; &#42;/ 
     333         *  29:             "modelArrayA" : [ 
     334         *  30:                  
     335         *  31:             ],  
     336         *  32:  
     337         *  33:             /&#42; Array &lt;JavaScriptUtilityTestModelB[]&gt; &#42;/ 
     338         *  34:             "modelArrayB" : [ 
     339         *  35:                  
     340         *  36:             ],  
     341         *  37:  
     342         *  38:             /&#42; Boolean &#42;/ 
     343         *  39:             "valueWrapperBooleanModelC" : true,  
     344         *  40:  
     345         *  41:             /&#42; Array &lt;JavaScriptUtilityTestModelC[]&gt; &#42;/ 
     346         *  42:             "modelArrayC" : [ 
     347         *  43:                  
     348         *  44:             ],  
     349         *  45:  
     350         *  46:             /&#42; String &#42;/ 
     351         *  47:             "valueWrapperStringModelC" : "prop_valueWrapperStringModelC",  
     352         *  48:  
     353         *  49:             /&#42; Date  // Thu Jun 19 2008 12:34:56 GMT+0900 (JST) &#42;/ 
     354         *  50:             "valueWrapperDateModelC" : new Date(1213846496000) 
     355         *  51:         },  
     356         *  52:  
     357         *  53:         /&#42; Array &lt;JavaScriptUtilityTestModelA[]&gt; &#42;/ 
     358         *  54:         "modelArrayA" : [ 
     359         *  55:              
     360         *  56:         ],  
     361         *  57:  
     362         *  58:         /&#42; Array &lt;JavaScriptUtilityTestModelB[]&gt; &#42;/ 
     363         *  59:         "modelArrayB" : [ 
     364         *  60:              
     365         *  61:         ],  
     366         *  62:  
     367         *  63:         /&#42; Boolean &#42;/ 
     368         *  64:         "valueWrapperBooleanModelB" : true,  
     369         *  65:  
     370         *  66:         /&#42; Array &lt;JavaScriptUtilityTestModelC[]&gt; &#42;/ 
     371         *  67:         "modelArrayC" : [ 
     372         *  68:              
     373         *  69:         ],  
     374         *  70:  
     375         *  71:         /&#42; String &#42;/ 
     376         *  72:         "valueWrapperStringModelB" : "prop_valueWrapperStringModelB",  
     377         *  73:  
     378         *  74:         /&#42; Date  // Thu Jun 19 2008 12:34:56 GMT+0900 (JST) &#42;/ 
     379         *  75:         "valueWrapperDateModelB" : new Date(1213846496000),  
     380         *  76:  
     381         *  77:         /&#42; Number &#42;/ 
     382         *  78:         "valueWrapperNumberModelB" : 123 
     383         *  79:     },  
     384         *  80:  
     385         *  81:     /&#42; Boolean &#42;/ 
     386         *  82:     "valueWrapperBooleanModelA" : true,  
     387         *  83:  
     388         *  84:     /&#42; Array &lt;JavaScriptUtilityTestModelA[]&gt; &#42;/ 
     389         *  85:     "modelArrayA" : [ 
     390         *  86:          
     391         *  87:     ],  
     392         *  88:  
     393         *  89:     /&#42; Array &lt;JavaScriptUtilityTestModelB[]&gt; &#42;/ 
     394         *  90:     "modelArrayB" : [ 
     395         *  91:          
     396         *  92:     ],  
     397         *  93:  
     398         *  94:     /&#42; String &#42;/ 
     399         *  95:     "valueWrapperStringModelA" : "prop_valueWrapperStringModelA",  
     400         *  96:  
     401         *  97:     /&#42; Date  // Thu Jun 19 2008 12:34:56 GMT+0900 (JST) &#42;/ 
     402         *  98:     "valueWrapperDateModelA" : new Date(1213846496000),  
     403         *  99:  
     404         * 100:     /&#42; Number &#42;/ 
     405         * 101:     "valueWrapperNumberModelA" : 123 
     406         * 102: } 
     407         * </pre> 
     408         *  
     409         * @throws Exception 
     410         */ 
     411        public void testConvertJavaBeans2JsObject_JavaBeans() throws Exception { 
     412                // 可逆性あり! 
     413                JavaScriptUtilityTestModelA testData =  
     414                        (JavaScriptUtilityTestModelA)JavaScriptUtility.newInstanceFilledProperty(JavaScriptUtilityTestModelA.class, null); 
     415 
     416                Object actual = JavaScriptUtility.convertJavaBeans2JsObject(testData); 
     417 
     418                assertEquals(ValueObject.class, actual.getClass()); 
     419                ValueObject jsObj = (ValueObject)actual; 
     420 
     421                String propName; 
     422                String expected; 
     423                String actualString; 
     424                Object actualValue; 
     425                 
     426 
     427                // 1行目 
     428                propName = ""; 
     429                expected = JavaScriptUtilityTestModelA.class.getSimpleName(); 
     430                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     431                assertEquals(expected, actualString); 
     432                 
     433                // 3行目 
     434                propName = "modelA"; 
     435                expected = JavaScriptUtilityTestModelA.class.getSimpleName(); 
     436                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     437                assertEquals(expected, actualString); 
     438 
     439                // 4行目 
     440                assertEquals(null, jsObj.get(propName, jsObj)); 
     441                 
     442                // 6行目 
     443                propName = "modelB"; 
     444                expected = JavaScriptUtilityTestModelB.class.getSimpleName(); 
     445                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     446                assertEquals(expected, actualString); 
     447 
     448                // 7行目 
     449                Object modelB = jsObj.get("modelB", jsObj); 
     450                assertNotNull(modelB); 
     451                assertEquals(ValueObject.class, modelB.getClass()); 
     452                ValueObject jsModelB = (ValueObject)modelB; 
     453                 
     454                // 8行目 
     455                propName = "modelA"; 
     456                expected = JavaScriptUtilityTestModelA.class.getSimpleName(); 
     457                actualString = (String) jsModelB.get("__javaClassName_" + propName + "__", jsModelB); 
     458                assertEquals(expected, actualString); 
     459                 
     460                // 9行目 
     461                assertEquals(null, jsModelB.get(propName, jsObj)); 
     462                         
     463                // 11行目 
     464                propName = "modelB"; 
     465                expected = JavaScriptUtilityTestModelB.class.getSimpleName(); 
     466                actualString = (String) jsModelB.get("__javaClassName_" + propName + "__", jsModelB); 
     467                assertEquals(expected, actualString); 
     468 
     469                // 12行目 
     470                assertEquals(null, jsModelB.get(propName, jsObj)); 
     471                 
     472                // 14行目 
     473                propName = "modelC"; 
     474                expected = JavaScriptUtilityTestModelC.class.getSimpleName(); 
     475                actualString = (String) jsModelB.get("__javaClassName_" + propName + "__", jsObj); 
     476                assertEquals(expected, actualString); 
     477 
     478                // 15行目 
     479                Object modelC = jsModelB.get("modelC", jsModelB); 
     480                assertNotNull(modelC); 
     481                assertEquals(ValueObject.class, modelC.getClass()); 
     482                ValueObject jsModelC = (ValueObject)modelC; 
     483                 
     484                // 16行目 
     485                propName = "modelA"; 
     486                expected = JavaScriptUtilityTestModelA.class.getSimpleName(); 
     487                actualString = (String) jsModelC.get("__javaClassName_" + propName + "__", jsModelC); 
     488                assertEquals(expected, actualString); 
     489                 
     490                // 17行目 
     491                assertEquals(null, jsModelC.get(propName, jsObj)); 
     492                         
     493                // 20行目 
     494                actualValue = jsModelC.get("valueWrapperNumberModelC", jsModelC); 
     495                assertEquals(Double.class, actualValue.getClass()); 
     496                assertEquals(new Double(123), actualValue); 
     497                 
     498                // 22行目 
     499                propName = "modelB"; 
     500                expected = JavaScriptUtilityTestModelB.class.getSimpleName(); 
     501                actualString = (String) jsModelC.get("__javaClassName_" + propName + "__", jsModelC); 
     502                assertEquals(expected, actualString); 
     503 
     504                // 23行目 
     505                assertEquals(null, jsModelC.get(propName, jsObj)); 
     506 
     507                // 25行目 
     508                propName = "modelC"; 
     509                expected = JavaScriptUtilityTestModelC.class.getSimpleName(); 
     510                actualString = (String) jsModelC.get("__javaClassName_" + propName + "__", jsModelC); 
     511                assertEquals(expected, actualString); 
     512 
     513                // 26行目 
     514                assertEquals(null, jsModelC.get(propName, jsObj)); 
     515                 
     516                // 28行目 
     517                propName = "modelArrayA"; 
     518                expected = JavaScriptUtilityTestModelA[].class.getSimpleName(); 
     519                actualString = (String) jsModelC.get("__javaClassName_" + propName + "__", jsModelC); 
     520                assertEquals(expected, actualString); 
     521                 
     522                // 29行目 
     523                Object modelArrayA = jsModelC.get("modelArrayA", jsModelC); 
     524                assertNotNull(modelArrayA); 
     525                assertEquals(NativeArray.class, modelArrayA.getClass()); 
     526                NativeArray jsModelArrayA = (NativeArray)modelArrayA; 
     527                assertEquals(0, jsModelArrayA.getLength()); 
     528 
     529                // 33行目 
     530                propName = "modelArrayB"; 
     531                expected = JavaScriptUtilityTestModelB[].class.getSimpleName(); 
     532                actualString = (String) jsModelC.get("__javaClassName_" + propName + "__", jsModelC); 
     533                assertEquals(expected, actualString); 
     534                 
     535                // 34行目 
     536                Object modelArrayB = jsModelC.get("modelArrayB", jsModelC); 
     537                assertNotNull(modelArrayB); 
     538                assertEquals(NativeArray.class, modelArrayB.getClass()); 
     539                NativeArray jsModelArrayB = (NativeArray)modelArrayB; 
     540                assertEquals(0, jsModelArrayB.getLength()); 
     541 
     542                // 39行目 
     543                Object valueWrapperBooleanModelC = jsModelC.get("valueWrapperBooleanModelC", jsModelC); 
     544                assertNotNull(valueWrapperBooleanModelC); 
     545                assertEquals(true, valueWrapperBooleanModelC); 
     546 
     547                // 41行目 
     548                propName = "modelArrayC"; 
     549                expected = JavaScriptUtilityTestModelC[].class.getSimpleName(); 
     550                actualString = (String) jsModelC.get("__javaClassName_" + propName + "__", jsModelC); 
     551                assertEquals(expected, actualString); 
     552                 
     553                // 42行目 
     554                Object modelArrayC = jsModelC.get("modelArrayC", jsModelC); 
     555                assertNotNull(modelArrayC); 
     556                assertEquals(NativeArray.class, modelArrayC.getClass()); 
     557                NativeArray jsModelArrayC = (NativeArray)modelArrayC; 
     558                assertEquals(0, jsModelArrayC.getLength()); 
     559                 
     560                // 47行目 
     561                Object valueWrapperStringModelC = jsModelC.get("valueWrapperStringModelC", jsModelC); 
     562                assertNotNull(valueWrapperStringModelC); 
     563                assertEquals("prop_valueWrapperStringModelC", valueWrapperStringModelC); 
     564 
     565                // 50行目 
     566                Object valueWrapperDateModelC = jsModelC.get("valueWrapperDateModelC", jsModelC); 
     567                assertNotNull(valueWrapperDateModelC); 
     568                Date date = (Date)Context.jsToJava(valueWrapperDateModelC, Date.class); 
     569                assertEquals(new Date(1213846496000L), date); // Thu Jun 19 2008 12:34:56 GMT+0900 (JST) */ 
     570                 
     571                // 53行目 
     572                propName = "modelArrayA"; 
     573                expected = JavaScriptUtilityTestModelA[].class.getSimpleName(); 
     574                actualString = (String) jsModelB.get("__javaClassName_" + propName + "__", jsModelB); 
     575                assertEquals(expected, actualString); 
     576 
     577                // 54行目 
     578                modelArrayA = jsModelB.get("modelArrayA", jsModelB); 
     579                assertNotNull(modelArrayA); 
     580                assertEquals(NativeArray.class, modelArrayA.getClass()); 
     581                jsModelArrayA = (NativeArray)modelArrayA; 
     582                assertEquals(0, jsModelArrayA.getLength()); 
     583 
     584                // 58行目 
     585                propName = "modelArrayB"; 
     586                expected = JavaScriptUtilityTestModelB[].class.getSimpleName(); 
     587                actualString = (String) jsModelB.get("__javaClassName_" + propName + "__", jsModelB); 
     588                assertEquals(expected, actualString); 
     589 
     590                // 59行目 
     591                modelArrayB = jsModelB.get("modelArrayB", jsModelB); 
     592                assertNotNull(modelArrayB); 
     593                assertEquals(NativeArray.class, modelArrayB.getClass()); 
     594                jsModelArrayB = (NativeArray)modelArrayB; 
     595                assertEquals(0, jsModelArrayB.getLength()); 
     596 
     597                // 63行目 
     598                Object valueWrapperBooleanModelB = jsModelB.get("valueWrapperBooleanModelB", jsModelB); 
     599                assertNotNull(valueWrapperBooleanModelB); 
     600                assertEquals(true, valueWrapperBooleanModelB); 
     601                 
     602                // 66行目 
     603                propName = "modelArrayC"; 
     604                expected = JavaScriptUtilityTestModelC[].class.getSimpleName(); 
     605                actualString = (String) jsModelB.get("__javaClassName_" + propName + "__", jsModelB); 
     606                assertEquals(expected, actualString); 
     607 
     608                // 67行目 
     609                modelArrayC = jsModelB.get("modelArrayC", jsModelB); 
     610                assertNotNull(modelArrayC); 
     611                assertEquals(NativeArray.class, modelArrayC.getClass()); 
     612                jsModelArrayC = (NativeArray)modelArrayC; 
     613                assertEquals(0, jsModelArrayC.getLength()); 
     614                 
     615                // 72行目 
     616                Object valueWrapperStringModelB = jsModelB.get("valueWrapperStringModelB", jsModelB); 
     617                assertNotNull(valueWrapperStringModelB); 
     618                assertEquals("prop_valueWrapperStringModelB", valueWrapperStringModelB); 
     619 
     620                // 75行目 
     621                Object valueWrapperDateModelB = jsModelB.get("valueWrapperDateModelB", jsModelB); 
     622                assertNotNull(valueWrapperDateModelB); 
     623                date = (Date)Context.jsToJava(valueWrapperDateModelB, Date.class); 
     624                assertEquals(new Date(1213846496000L), date); // Thu Jun 19 2008 12:34:56 GMT+0900 (JST) */ 
     625 
     626                // 78行目 
     627                Object valueWrapperNumberModelB = jsModelB.get("valueWrapperNumberModelB", jsModelB); 
     628                assertNotNull(valueWrapperNumberModelB); 
     629                assertEquals(Double.class, valueWrapperNumberModelB.getClass()); 
     630                assertEquals(new Double(123), valueWrapperNumberModelB); 
     631                 
     632                // 82行目 
     633                Object valueWrapperBooleanModelA = jsObj.get("valueWrapperBooleanModelA", jsObj); 
     634                assertNotNull(valueWrapperBooleanModelA); 
     635                assertEquals(true, valueWrapperBooleanModelA); 
     636                 
     637                // 84行目 
     638                propName = "modelArrayA"; 
     639                expected = JavaScriptUtilityTestModelA[].class.getSimpleName(); 
     640                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     641                assertEquals(expected, actualString); 
     642 
     643                // 85行目 
     644                modelArrayA = jsObj.get("modelArrayA", jsObj); 
     645                assertNotNull(modelArrayA); 
     646                assertEquals(NativeArray.class, modelArrayA.getClass()); 
     647                jsModelArrayA = (NativeArray)modelArrayA; 
     648                assertEquals(0, jsModelArrayA.getLength()); 
     649 
     650         
     651                // 89行目 
     652                propName = "modelArrayB"; 
     653                expected = JavaScriptUtilityTestModelB[].class.getSimpleName(); 
     654                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     655                assertEquals(expected, actualString); 
     656 
     657                // 90行目 
     658                modelArrayB = jsObj.get("modelArrayB", jsObj); 
     659                assertNotNull(modelArrayB); 
     660                assertEquals(NativeArray.class, modelArrayB.getClass()); 
     661                jsModelArrayB = (NativeArray)modelArrayB; 
     662                assertEquals(0, jsModelArrayB.getLength()); 
     663 
     664                // 95行目 
     665                Object valueWrapperStringModelA = jsObj.get("valueWrapperStringModelA", jsObj); 
     666                assertNotNull(valueWrapperStringModelA); 
     667                assertEquals("prop_valueWrapperStringModelA", valueWrapperStringModelA); 
     668 
     669                // 98行目 
     670                Object valueWrapperDateModelA = jsObj.get("valueWrapperDateModelA", jsObj); 
     671                assertNotNull(valueWrapperDateModelA); 
     672                Date dateValueWrapperDateModelA = (Date)Context.jsToJava(valueWrapperDateModelA, Date.class); 
     673                assertEquals(new Date(1213846496000L), dateValueWrapperDateModelA); // Thu Jun 19 2008 12:34:56 GMT+0900 (JST) */ 
     674 
     675                // 101行目 
     676                Object valueWrapperNumberModelA = jsObj.get("valueWrapperNumberModelA", jsObj); 
     677                assertNotNull(valueWrapperNumberModelA); 
     678                assertEquals(Double.class, valueWrapperNumberModelA.getClass()); 
     679                assertEquals(new Double(123), valueWrapperNumberModelA); 
     680        } 
     681 
     682        public void testConvertJsObject2JavaBeansObjectString_正常系_プリミティブ型_char() throws Exception { 
     683                String type = char.class.getName(); 
     684                Object actual = JavaScriptUtility.convertJsObject2JavaBeans("12345", type); 
     685                 
     686                assertEquals(Character.class, actual.getClass()); 
     687                assertEquals(new Character('1'), actual); 
     688        } 
     689 
     690        public void testConvertJsObject2JavaBeansObjectString_正常系_プリミティブ型_char_オブジェクトがNumber() throws Exception { 
     691                String type = char.class.getName(); 
     692 
     693                Object actual = JavaScriptUtility.convertJsObject2JavaBeans(new Double(54321), type); 
     694                assertEquals(Character.class, actual.getClass()); 
     695                assertEquals(new Character('5'), actual); 
     696        } 
     697 
     698        public void testConvertJsObject2JavaBeansObjectString_正常系_プリミティブ型_char_オブジェクトがBoolean() throws Exception { 
     699                String type = char.class.getName(); 
     700 
     701                Object actual = JavaScriptUtility.convertJsObject2JavaBeans(true, type); 
     702                assertEquals(Character.class, actual.getClass()); 
     703                assertEquals(new Character('t'), actual); 
     704        } 
     705         
     706        public void testConvertJsObject2JavaBeansObjectString_正常系_プリミティブ型_char_オブジェクトがnull() throws Exception { 
     707                String type = char.class.getName(); 
     708 
     709                Object actual = JavaScriptUtility.convertJsObject2JavaBeans(null, type); 
     710                assertNull(actual); 
     711        } 
     712 
     713        public void testConvertJsObject2JavaBeansObjectString_正常系_プリミティブ型_double() throws Exception { 
     714                String type = double.class.getName(); 
     715                Object actual = JavaScriptUtility.convertJsObject2JavaBeans(12345, type); 
     716                 
     717                assertEquals(Double.class, actual.getClass()); 
     718                assertEquals(new Double(12345), actual); 
     719        } 
     720 
     721        public void testConvertJsObject2JavaBeansObjectString_異常系_プリミティブ型_double() throws Exception { 
     722                String type = double.class.getName(); 
     723 
     724                try{ 
     725                        JavaScriptUtility.convertJsObject2JavaBeans("文字列です", type); 
     726                } 
     727                catch(NumberFormatException e){ 
     728                        assertTrue("NumberFormatExceptionが起こること", true); 
     729                        return; 
     730                } 
     731 
     732                fail("NumberFormatExceptionが起こっていません"); 
     733        } 
     734 
     735        public void testConvertJsObject2JavaBeansObjectString_正常系_プリミティブ型_float() throws Exception { 
     736                String type = float.class.getName(); 
     737                Object actual = JavaScriptUtility.convertJsObject2JavaBeans(12345, type); 
     738                 
     739                assertEquals(Float.class, actual.getClass()); 
     740                assertEquals(new Float(12345), actual); 
     741        } 
     742 
     743        public void testConvertJsObject2JavaBeansObjectString_異常系_プリミティブ型_float() throws Exception { 
     744                String type = float.class.getName(); 
     745 
     746                try{ 
     747                        JavaScriptUtility.convertJsObject2JavaBeans("文字列です", type); 
     748                } 
     749                catch(NumberFormatException e){ 
     750                        assertTrue("NumberFormatExceptionが起こること", true); 
     751                        return; 
     752                } 
     753 
     754                fail("NumberFormatExceptionが起こっていません"); 
     755        } 
     756         
     757        public void testConvertJsObject2JavaBeansObjectString_正常系_プリミティブ型_long() throws Exception { 
     758                String type = long.class.getName(); 
     759                Object actual = JavaScriptUtility.convertJsObject2JavaBeans(12345, type); 
     760                 
     761                assertEquals(Long.class, actual.getClass()); 
     762                assertEquals(new Long(12345), actual); 
     763        } 
     764 
     765        public void testConvertJsObject2JavaBeansObjectString_異常系_プリミティブ型_long() throws Exception { 
     766                String type = long.class.getName(); 
     767 
     768                try{ 
     769                        JavaScriptUtility.convertJsObject2JavaBeans("文字列です", type); 
     770                } 
     771                catch(NumberFormatException e){ 
     772                        assertTrue("NumberFormatExceptionが起こること", true); 
     773                        return; 
     774                } 
     775 
     776                fail("NumberFormatExceptionが起こっていません"); 
     777        } 
     778 
     779        public void testConvertJsObject2JavaBeansObjectString_正常系_プリミティブ型_int() throws Exception { 
     780                String type = int.class.getName(); 
     781                Object actual = JavaScriptUtility.convertJsObject2JavaBeans(12345, type); 
     782                 
     783                assertEquals(Integer.class, actual.getClass()); 
     784                assertEquals(new Integer(12345), actual); 
     785        } 
     786 
     787        public void testConvertJsObject2JavaBeansObjectString_異常系_プリミティブ型_int() throws Exception { 
     788                String type = int.class.getName(); 
     789 
     790                try{ 
     791                        JavaScriptUtility.convertJsObject2JavaBeans("文字列です", type); 
     792                } 
     793                catch(NumberFormatException e){ 
     794                        assertTrue("NumberFormatExceptionが起こること", true); 
     795                        return; 
     796                } 
     797 
     798                fail("NumberFormatExceptionが起こっていません"); 
     799        } 
     800         
     801        public void testConvertJsObject2JavaBeansObjectString_正常系_プリミティブ型_short() throws Exception { 
     802                String type = short.class.getName(); 
     803                Object actual = JavaScriptUtility.convertJsObject2JavaBeans(12345, type); 
     804                 
     805                assertEquals(Short.class, actual.getClass()); 
     806                assertEquals(new Short("12345"), actual); 
     807        } 
     808 
     809        public void testConvertJsObject2JavaBeansObjectString_異常系_プリミティブ型_short() throws Exception { 
     810                String type = short.class.getName(); 
     811 
     812                try{ 
     813                        JavaScriptUtility.convertJsObject2JavaBeans("文字列です", type); 
     814                } 
     815                catch(NumberFormatException e){ 
     816                        assertTrue("NumberFormatExceptionが起こること", true); 
     817                        return; 
     818                } 
     819 
     820                fail("NumberFormatExceptionが起こっていません"); 
     821        } 
     822         
     823        public void testConvertJsObject2JavaBeansObjectString_正常系_プリミティブ型_byte() throws Exception { 
     824                String type = byte.class.getName(); 
     825                Object actual = JavaScriptUtility.convertJsObject2JavaBeans(123, type); 
     826                 
     827                assertEquals(Byte.class, actual.getClass()); 
     828                assertEquals(new Byte("123"), actual); 
     829        } 
     830 
     831        public void testConvertJsObject2JavaBeansObjectString_異常系_プリミティブ型_byte() throws Exception { 
     832                String type = byte.class.getName(); 
     833 
     834                try{ 
     835                        JavaScriptUtility.convertJsObject2JavaBeans("文字列です", type); 
     836                } 
     837                catch(NumberFormatException e){ 
     838                        assertTrue("NumberFormatExceptionが起こること", true); 
     839                        return; 
     840                } 
     841 
     842                fail("NumberFormatExceptionが起こっていません"); 
     843        } 
     844         
     845         
     846        public void testConvertJsObject2JavaBeansObjectStringClassLoader() throws Exception { 
     847                assertTrue("JavaScriptUtility.convertJsObject2JavaBeans(Object, String)系のテストが通っていればOK", true); 
     848        } 
     849 
     850        public void testConvertJsObject2JavaBeansObjectClassOfQ() throws Exception { 
     851                // 可逆性あり! 
     852                JavaScriptUtilityTestModelA expected = (JavaScriptUtilityTestModelA)JavaScriptUtility.newInstanceFilledProperty(JavaScriptUtilityTestModelA.class, null); 
     853                Object jsObject = JavaScriptUtility.convertJavaBeans2JsObject(expected); 
     854                 
     855                Object actual = JavaScriptUtility.convertJsObject2JavaBeans(jsObject, JavaScriptUtilityTestModelA.class); 
     856                assertEquals(JavaScriptUtilityTestModelA.class, actual.getClass()); 
     857                 
     858                JavaScriptUtilityTestModelA actualModelA = (JavaScriptUtilityTestModelA) actual; 
     859 
     860                assertEquals(null, actualModelA.getModelA()); 
     861                assertEquals(          expected.getModelA(), 
     862                                   actualModelA.getModelA()); 
     863 
     864                assertEquals(null, actualModelA.getModelB().getModelA()); 
     865                assertEquals(          expected.getModelB().getModelA(), 
     866                                   actualModelA.getModelB().getModelA()); 
     867                 
     868                assertEquals(null, actualModelA.getModelB().getModelB()); 
     869                assertEquals(          expected.getModelB().getModelA(),  
     870                                           actualModelA.getModelB().getModelB()); 
     871                 
     872                assertEquals(null, actualModelA.getModelB().getModelC().getModelA()); 
     873                assertEquals(          expected.getModelB().getModelC().getModelA(), 
     874                                           actualModelA.getModelB().getModelC().getModelA()); 
     875                 
     876                assertEquals(new Double(123), actualModelA.getModelB().getModelC().getValueWrapperNumberModelC()); 
     877                assertEquals(                     expected.getModelB().getModelC().getValueWrapperNumberModelC(), 
     878                                                      actualModelA.getModelB().getModelC().getValueWrapperNumberModelC()); 
     879 
     880                assertEquals(null, actualModelA.getModelB().getModelC().getModelB()); 
     881                assertEquals(          expected.getModelB().getModelC().getModelB(), 
     882                                           actualModelA.getModelB().getModelC().getModelB()); 
     883                 
     884                assertEquals(null, actualModelA.getModelB().getModelC().getModelC()); 
     885                assertEquals(          expected.getModelB().getModelC().getModelC(), 
     886                                           actualModelA.getModelB().getModelC().getModelC()); 
     887                 
     888                assertEquals(0, actualModelA.getModelB().getModelC().getModelArrayA().length); 
     889                assertEquals(       expected.getModelB().getModelC().getModelArrayA().length, 
     890                                        actualModelA.getModelB().getModelC().getModelArrayA().length); 
     891                 
     892                assertEquals(0, actualModelA.getModelB().getModelC().getModelArrayB().length); 
     893                assertEquals(       expected.getModelB().getModelC().getModelArrayB().length, 
     894                                actualModelA.getModelB().getModelC().getModelArrayB().length); 
     895 
     896                assertEquals(Boolean.TRUE, actualModelA.getModelB().getModelC().getValueWrapperBooleanModelC()); 
     897                assertEquals(                  expected.getModelB().getModelC().getValueWrapperBooleanModelC(), 
     898                                                   actualModelA.getModelB().getModelC().getValueWrapperBooleanModelC()); 
     899 
     900                assertEquals(0, actualModelA.getModelB().getModelC().getModelArrayC().length); 
     901                assertEquals(       expected.getModelB().getModelC().getModelArrayC().length, 
     902                                        actualModelA.getModelB().getModelC().getModelArrayC().length); 
     903                 
     904                assertEquals("prop_valueWrapperStringModelC", actualModelA.getModelB().getModelC().getValueWrapperStringModelC()); 
     905                assertEquals(                                     expected.getModelB().getModelC().getValueWrapperStringModelC(),  
     906                                                                      actualModelA.getModelB().getModelC().getValueWrapperStringModelC()); 
     907 
     908                assertEquals(new Date(1213846496000L), actualModelA.getModelB().getModelC().getValueWrapperDateModelC()); 
     909                assertEquals(                              expected.getModelB().getModelC().getValueWrapperDateModelC(), 
     910                                                               actualModelA.getModelB().getModelC().getValueWrapperDateModelC()); 
     911                 
     912                assertEquals(0, actualModelA.getModelB().getModelArrayA().length); 
     913                assertEquals(       expected.getModelB().getModelArrayA().length, 
     914                                        actualModelA.getModelB().getModelArrayA().length); 
     915                 
     916                assertEquals(0, actualModelA.getModelB().getModelArrayB().length); 
     917                assertEquals(       expected.getModelB().getModelArrayB().length, 
     918                                        actualModelA.getModelB().getModelArrayB().length); 
     919 
     920                assertEquals(Boolean.TRUE, actualModelA.getModelB().getValueWrapperBooleanModelB()); 
     921                assertEquals(                  expected.getModelB().getValueWrapperBooleanModelB(), 
     922                                                   actualModelA.getModelB().getValueWrapperBooleanModelB()); 
     923         
     924                assertEquals(0, actualModelA.getModelB().getModelArrayC().length); 
     925                assertEquals(       expected.getModelB().getModelArrayC().length, 
     926                                        actualModelA.getModelB().getModelArrayC().length); 
     927         
     928                assertEquals("prop_valueWrapperStringModelB", actualModelA.getModelB().getValueWrapperStringModelB()); 
     929                assertEquals(                                     expected.getModelB().getValueWrapperStringModelB(), 
     930                                                                      actualModelA.getModelB().getValueWrapperStringModelB()); 
     931         
     932                assertEquals(new Date(1213846496000L), actualModelA.getModelB().getValueWrapperDateModelB()); 
     933                assertEquals(                              expected.getModelB().getValueWrapperDateModelB(), 
     934                                                               actualModelA.getModelB().getValueWrapperDateModelB()); 
     935         
     936                assertEquals(new Double(123), actualModelA.getModelB().getValueWrapperNumberModelB()); 
     937                assertEquals(                     expected.getModelB().getValueWrapperNumberModelB(), 
     938                                                      actualModelA.getModelB().getValueWrapperNumberModelB()); 
     939 
     940                assertEquals(Boolean.TRUE, actualModelA.getValueWrapperBooleanModelA()); 
     941                assertEquals(                  expected.getValueWrapperBooleanModelA(), 
     942                                                   actualModelA.getValueWrapperBooleanModelA()); 
     943 
     944                assertEquals(0, actualModelA.getModelArrayA().length); 
     945                assertEquals(       expected.getModelArrayA().length, 
     946                                        actualModelA.getModelArrayA().length); 
     947 
     948                assertEquals(0, actualModelA.getModelArrayB().length); 
     949                assertEquals(       expected.getModelArrayB().length, 
     950                                        actualModelA.getModelArrayB().length); 
     951 
     952                assertEquals("prop_valueWrapperStringModelA", actualModelA.getValueWrapperStringModelA()); 
     953                assertEquals(                                     expected.getValueWrapperStringModelA(), 
     954                                                                      actualModelA.getValueWrapperStringModelA()); 
     955 
     956                assertEquals(new Date(1213846496000L), actualModelA.getValueWrapperDateModelA()); 
     957                assertEquals(                              expected.getValueWrapperDateModelA(), 
     958                                                               actualModelA.getValueWrapperDateModelA()); 
     959                 
     960                assertEquals(new Double(123), actualModelA.getValueWrapperNumberModelA()); 
     961                assertEquals(                     expected.getValueWrapperNumberModelA(), 
     962                                                      actualModelA.getValueWrapperNumberModelA()); 
     963                 
     964        } 
     965         
     966 
     967        public void testGetBeansPropertyMap_対象外_List() throws Exception { 
     968                Class beanType = List.class; 
     969                Map<String, PropertyDescriptor> actual = JavaScriptUtility.getBeansPropertyMap(beanType); 
     970 
     971                assertEquals(0, actual.size()); 
     972        } 
     973         
     974        public void testGetBeansPropertyMap_対象外_Map() throws Exception { 
     975                Class beanType = Map.class; 
     976                Map<String, PropertyDescriptor> actual = JavaScriptUtility.getBeansPropertyMap(beanType); 
     977 
     978                assertEquals(0, actual.size()); 
     979        } 
     980 
     981        public void testGetBeansPropertyMap_対象外_Set() throws Exception { 
     982                Class beanType = Set.class; 
     983                Map<String, PropertyDescriptor> actual = JavaScriptUtility.getBeansPropertyMap(beanType); 
     984 
     985                assertEquals(0, actual.size()); 
     986        } 
     987 
     988        public void testGetBeansPropertyMap_対象外_Object() throws Exception { 
     989                Class beanType = Object.class; 
     990                Map<String, PropertyDescriptor> actual = JavaScriptUtility.getBeansPropertyMap(beanType); 
     991 
     992                assertEquals(0, actual.size()); 
     993        } 
     994 
     995        public void testGetBeansPropertyMap_対象クラス_JavaScriptUtilityTestModelA() throws Exception { 
     996                Class beanType = JavaScriptUtilityTestModelA.class; 
     997                Map<String, PropertyDescriptor> actual = JavaScriptUtility.getBeansPropertyMap(beanType); 
     998 
     999                assertEquals(8, actual.size()); 
     1000                assertNotNull(actual.get("modelA")); 
     1001                assertNotNull(actual.get("modelArrayA")); 
     1002                assertNotNull(actual.get("modelArrayB")); 
     1003                assertNotNull(actual.get("valueWrapperStringModelA")); 
     1004                assertNotNull(actual.get("valueWrapperNumberModelA")); 
     1005                assertNotNull(actual.get("valueWrapperBooleanModelA")); 
     1006                assertNotNull(actual.get("valueWrapperDateModelA")); 
     1007        } 
     1008         
     1009         
     1010        public void testNewInstanceFilledPropertyStringString_プリミティブ型_char_初期値_null() throws Exception { 
     1011                String beanClassName = char.class.getName(); 
     1012                String defaultValue = null; 
     1013                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1014 
     1015                assertEquals(Character.class, actual.getClass()); 
     1016                assertEquals('_', actual); 
     1017        } 
     1018 
     1019        public void testNewInstanceFilledPropertyStringString_プリミティブ型_char_初期値_空文字() throws Exception { 
     1020                String beanClassName = char.class.getName(); 
     1021                String defaultValue = ""; 
     1022                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1023 
     1024                assertEquals(Character.class, actual.getClass()); 
     1025                assertEquals('_', actual); 
     1026        } 
     1027 
     1028        public void testNewInstanceFilledPropertyStringString_プリミティブ型_char_初期値_任意() throws Exception { 
     1029                String beanClassName = char.class.getName(); 
     1030                String defaultValue = "任意の文字列"; 
     1031                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1032 
     1033                assertEquals(Character.class, actual.getClass()); 
     1034                assertEquals('任', actual); 
     1035        } 
     1036 
     1037        public void testNewInstanceFilledPropertyStringString_プリミティブ型_char_initializeあり_初期値_null() throws Exception { 
     1038                JavaScriptUtility.initializeSampleData("テストです。", null, null, null); 
     1039                 
     1040                String beanClassName = char.class.getName(); 
     1041                String defaultValue = null; 
     1042                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1043 
     1044                assertEquals(Character.class, actual.getClass()); 
     1045                assertEquals('テ', actual); 
     1046        } 
     1047 
     1048        public void testNewInstanceFilledPropertyStringString_プリミティブ型_double() throws Exception { 
     1049                String beanClassName = double.class.getName(); 
     1050                String defaultValue = null; 
     1051                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1052 
     1053                assertEquals(Double.class, actual.getClass()); 
     1054                assertEquals(new Double(123), actual); 
     1055        } 
     1056 
     1057        public void testNewInstanceFilledPropertyStringString_プリミティブ型_double_initializeあり() throws Exception { 
     1058                Double expected = new Double(567.89); 
     1059                JavaScriptUtility.initializeSampleData(null, expected, null, null); 
     1060                 
     1061                String beanClassName = double.class.getName(); 
     1062                String defaultValue = null; 
     1063                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1064 
     1065                assertEquals(Double.class, actual.getClass()); 
     1066                assertEquals(expected, actual); 
     1067        } 
     1068 
     1069        public void testNewInstanceFilledPropertyStringString_プリミティブ型_float() throws Exception { 
     1070                String beanClassName = float.class.getName(); 
     1071                String defaultValue = null; 
     1072                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1073 
     1074                assertEquals(Float.class, actual.getClass()); 
     1075                assertEquals(new Float(123), actual); 
     1076        } 
     1077 
     1078        public void testNewInstanceFilledPropertyStringString_プリミティブ型_float_initializeあり() throws Exception { 
     1079                Float expected = new Float(111.222); 
     1080                JavaScriptUtility.initializeSampleData(null, expected, null, null); 
     1081 
     1082                String beanClassName = float.class.getName(); 
     1083                String defaultValue = null; 
     1084                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1085 
     1086                assertEquals(Float.class, actual.getClass()); 
     1087                assertEquals(expected, actual); 
     1088        } 
     1089 
     1090        public void testNewInstanceFilledPropertyStringString_プリミティブ型_long() throws Exception { 
     1091                String beanClassName = long.class.getName(); 
     1092                String defaultValue = null; 
     1093                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1094 
     1095                assertEquals(Long.class, actual.getClass()); 
     1096                assertEquals(new Long(123), actual); 
     1097        } 
     1098 
     1099        public void testNewInstanceFilledPropertyStringString_プリミティブ型_long_initializeあり() throws Exception { 
     1100                Long expected = new Long(123456789011L); 
     1101                JavaScriptUtility.initializeSampleData(null, expected, null, null); 
     1102 
     1103                String beanClassName = long.class.getName(); 
     1104                String defaultValue = null; 
     1105                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1106 
     1107                assertEquals(Long.class, actual.getClass()); 
     1108                assertEquals(expected, actual); 
     1109        } 
     1110 
     1111        public void testNewInstanceFilledPropertyStringString_プリミティブ型_int() throws Exception { 
     1112                String beanClassName = int.class.getName(); 
     1113                String defaultValue = null; 
     1114                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1115 
     1116                assertEquals(Integer.class, actual.getClass()); 
     1117                assertEquals(new Integer(123), actual); 
     1118        } 
     1119 
     1120        public void testNewInstanceFilledPropertyStringString_プリミティブ型_int_initializeあり() throws Exception { 
     1121                Integer expected = new Integer(8786543); 
     1122                JavaScriptUtility.initializeSampleData(null, expected, null, null); 
     1123 
     1124                String beanClassName = int.class.getName(); 
     1125                String defaultValue = null; 
     1126                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1127 
     1128                assertEquals(Integer.class, actual.getClass()); 
     1129                assertEquals(expected, actual); 
     1130        } 
     1131 
     1132        public void testNewInstanceFilledPropertyStringString_プリミティブ型_short() throws Exception { 
     1133                String beanClassName = short.class.getName(); 
     1134                String defaultValue = null; 
     1135                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1136 
     1137                assertEquals(Short.class, actual.getClass()); 
     1138                assertEquals(new Short("123"), actual); 
     1139        } 
     1140 
     1141        public void testNewInstanceFilledPropertyStringString_プリミティブ型_short_initializeあり() throws Exception { 
     1142                Short expected = new Short("345"); 
     1143                JavaScriptUtility.initializeSampleData(null, expected, null, null); 
     1144 
     1145                String beanClassName = short.class.getName(); 
     1146                String defaultValue = null; 
     1147                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1148 
     1149                assertEquals(Short.class, actual.getClass()); 
     1150                assertEquals(expected, actual); 
     1151        } 
     1152 
     1153        public void testNewInstanceFilledPropertyStringString_プリミティブ型_byte() throws Exception { 
     1154                String beanClassName = byte.class.getName(); 
     1155                String defaultValue = null; 
     1156                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1157 
     1158                assertEquals(Byte.class, actual.getClass()); 
     1159                assertEquals(new Byte("123"), actual); 
     1160        } 
     1161 
     1162        public void testNewInstanceFilledPropertyStringString_プリミティブ型_byte_initializeあり() throws Exception { 
     1163                Byte expected = new Byte("16"); 
     1164                JavaScriptUtility.initializeSampleData(null, expected, null, null); 
     1165 
     1166                String beanClassName = byte.class.getName(); 
     1167                String defaultValue = null; 
     1168                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1169 
     1170                assertEquals(Byte.class, actual.getClass()); 
     1171                assertEquals(expected, actual); 
     1172        } 
     1173 
     1174        public void testNewInstanceFilledPropertyStringString_プリミティブ型_boolean() throws Exception { 
     1175                String beanClassName = boolean.class.getName(); 
     1176                String defaultValue = null; 
     1177                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1178 
     1179                assertEquals(Boolean.class, actual.getClass()); 
     1180                assertEquals(Boolean.TRUE, actual); 
     1181        } 
     1182 
     1183        public void testNewInstanceFilledPropertyStringString_プリミティブ型_initializeあり() throws Exception { 
     1184                Boolean expected = Boolean.FALSE; 
     1185                JavaScriptUtility.initializeSampleData(null, null, expected, null); 
     1186 
     1187                String beanClassName = boolean.class.getName(); 
     1188                String defaultValue = null; 
     1189                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1190 
     1191                assertEquals(Boolean.class, actual.getClass()); 
     1192                assertEquals(expected, actual); 
     1193        } 
     1194         
     1195         
     1196        public void testNewInstanceFilledPropertyStringString_ラッパークラス_String() throws Exception { 
     1197                String beanClassName = String.class.getName(); 
     1198                String defaultValue = null; 
     1199                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1200 
     1201                assertEquals(String.class, actual.getClass()); 
     1202                assertEquals("__default__", actual); 
     1203        } 
     1204 
     1205        public void testNewInstanceFilledPropertyStringString_ラッパークラス_String_initializeあり() throws Exception { 
     1206                String expected = new String("テストしています。"); 
     1207                JavaScriptUtility.initializeSampleData(expected, null, null, null); 
     1208 
     1209                String beanClassName = String.class.getName(); 
     1210                String defaultValue = null; 
     1211                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1212 
     1213                assertEquals(String.class, actual.getClass()); 
     1214                assertEquals(expected, actual); 
     1215        } 
     1216 
     1217        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Character() throws Exception { 
     1218                String beanClassName = Character.class.getName(); 
     1219                String defaultValue = null; 
     1220                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1221 
     1222                assertEquals(Character.class, actual.getClass()); 
     1223                assertEquals('_', actual); 
     1224        } 
     1225 
     1226        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Character_initializeあり() throws Exception { 
     1227                String expected = new String("はひふへほ"); 
     1228                JavaScriptUtility.initializeSampleData(expected, null, null, null); 
     1229 
     1230                String beanClassName = Character.class.getName(); 
     1231                String defaultValue = null; 
     1232                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1233 
     1234                assertEquals(Character.class, actual.getClass()); 
     1235                assertEquals(expected.charAt(0), actual); 
     1236        } 
     1237 
     1238        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Double() throws Exception { 
     1239                String beanClassName = Double.class.getName(); 
     1240                String defaultValue = null; 
     1241                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1242 
     1243                assertEquals(Double.class, actual.getClass()); 
     1244                assertEquals(new Double(123), actual); 
     1245        } 
     1246 
     1247        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Double_initializeあり() throws Exception { 
     1248                Double expected = new Double(123); 
     1249                JavaScriptUtility.initializeSampleData(null, expected, null, null); 
     1250 
     1251                String beanClassName = Double.class.getName(); 
     1252                String defaultValue = null; 
     1253                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1254 
     1255                assertEquals(Double.class, actual.getClass()); 
     1256                assertEquals(expected, actual); 
     1257        } 
     1258 
     1259        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Float() throws Exception { 
     1260                String beanClassName = Float.class.getName(); 
     1261                String defaultValue = null; 
     1262                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1263 
     1264                assertEquals(Float.class, actual.getClass()); 
     1265                assertEquals(new Float(123), actual); 
     1266        } 
     1267 
     1268        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Float_initializeあり() throws Exception { 
     1269                Float expected = new Float(123.456); 
     1270                JavaScriptUtility.initializeSampleData(null, expected, null, null); 
     1271 
     1272                String beanClassName = Float.class.getName(); 
     1273                String defaultValue = null; 
     1274                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1275 
     1276                assertEquals(Float.class, actual.getClass()); 
     1277                assertEquals(expected, actual); 
     1278        } 
     1279 
     1280        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Long() throws Exception { 
     1281                String beanClassName = Long.class.getName(); 
     1282                String defaultValue = null; 
     1283                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1284 
     1285                assertEquals(Long.class, actual.getClass()); 
     1286                assertEquals(new Long(123), actual); 
     1287        } 
     1288 
     1289        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Long_initializeあり() throws Exception { 
     1290                Long expected = new Long(9876543210L); 
     1291                JavaScriptUtility.initializeSampleData(null, expected, null, null); 
     1292 
     1293                String beanClassName = Long.class.getName(); 
     1294                String defaultValue = null; 
     1295                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1296 
     1297                assertEquals(Long.class, actual.getClass()); 
     1298                assertEquals(expected, actual); 
     1299        } 
     1300 
     1301        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Integer() throws Exception { 
     1302                String beanClassName = Integer.class.getName(); 
     1303                String defaultValue = null; 
     1304                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1305 
     1306                assertEquals(Integer.class, actual.getClass()); 
     1307                assertEquals(new Integer(123), actual); 
     1308        } 
     1309 
     1310        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Integer_initializeあり() throws Exception { 
     1311                Integer expected = new Integer(7684657); 
     1312                JavaScriptUtility.initializeSampleData(null, expected, null, null); 
     1313 
     1314                String beanClassName = Integer.class.getName(); 
     1315                String defaultValue = null; 
     1316                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1317 
     1318                assertEquals(Integer.class, actual.getClass()); 
     1319                assertEquals(expected, actual); 
     1320        } 
     1321 
     1322        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Short() throws Exception { 
     1323                String beanClassName = Short.class.getName(); 
     1324                String defaultValue = null; 
     1325                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1326 
     1327                assertEquals(Short.class, actual.getClass()); 
     1328                assertEquals(new Short("123"), actual); 
     1329        } 
     1330 
     1331        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Short_initializeあり() throws Exception { 
     1332                Short expected = new Short("456"); 
     1333                JavaScriptUtility.initializeSampleData(null, expected, null, null); 
     1334 
     1335                String beanClassName = Short.class.getName(); 
     1336                String defaultValue = null; 
     1337                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1338 
     1339                assertEquals(Short.class, actual.getClass()); 
     1340                assertEquals(expected, actual); 
     1341        } 
     1342 
     1343        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Byte() throws Exception { 
     1344                String beanClassName = Byte.class.getName(); 
     1345                String defaultValue = null; 
     1346                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1347 
     1348                assertEquals(Byte.class, actual.getClass()); 
     1349                assertEquals(new Byte("123"), actual); 
     1350        } 
     1351 
     1352        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Byte_initializeあり() throws Exception { 
     1353                Byte expected = new Byte("23"); 
     1354                JavaScriptUtility.initializeSampleData(null, expected, null, null); 
     1355 
     1356                String beanClassName = Byte.class.getName(); 
     1357                String defaultValue = null; 
     1358                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1359 
     1360                assertEquals(Byte.class, actual.getClass()); 
     1361                assertEquals(expected, actual); 
     1362        } 
     1363 
     1364        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Boolean() throws Exception { 
     1365                String beanClassName = Boolean.class.getName(); 
     1366                String defaultValue = null; 
     1367                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1368 
     1369                assertEquals(Boolean.class, actual.getClass()); 
     1370                assertEquals(Boolean.TRUE, actual); 
     1371        } 
     1372 
     1373        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Boolean_initializeあり() throws Exception { 
     1374                Boolean expected = Boolean.FALSE; 
     1375                JavaScriptUtility.initializeSampleData(null, null, expected, null); 
     1376 
     1377                String beanClassName = Boolean.class.getName(); 
     1378                String defaultValue = null; 
     1379                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1380 
     1381                assertEquals(Boolean.class, actual.getClass()); 
     1382                assertEquals(expected, actual); 
     1383        } 
     1384 
     1385        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Date() throws Exception { 
     1386                String beanClassName = Date.class.getName(); 
     1387                String defaultValue = null; 
     1388                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1389 
     1390                assertEquals(Date.class, actual.getClass()); 
     1391                assertEquals(new Date(1213846496000L), actual); // "Mon June 19 2008 12:34:56 GMT+0900 (JST)" 
     1392        } 
     1393 
     1394        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Date_initializeあり() throws Exception { 
     1395                Date expected = new Date(); 
     1396                JavaScriptUtility.initializeSampleData(null, null, null, expected); 
     1397 
     1398                String beanClassName = Date.class.getName(); 
     1399                String defaultValue = null; 
     1400                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1401 
     1402                assertEquals(Date.class, actual.getClass()); 
     1403                assertEquals(expected, actual); 
     1404        } 
     1405 
     1406        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Calendar() throws Exception { 
     1407                Calendar expected = Calendar.getInstance(); 
     1408                expected.setTime(new Date(1213846496000L)); // "Mon June 19 2008 12:34:56 GMT+0900 (JST)" 
     1409 
     1410                String beanClassName = Calendar.class.getName(); 
     1411                String defaultValue = null; 
     1412                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1413 
     1414                assertTrue(actual instanceof Calendar); 
     1415                assertEquals(expected, actual); 
     1416        } 
     1417 
     1418        public void testNewInstanceFilledPropertyStringString_ラッパークラス_Calendar_initializeあり() throws Exception { 
     1419                Date date = new Date(); 
     1420                JavaScriptUtility.initializeSampleData(null, null, null, date); 
     1421 
     1422                Calendar expected = Calendar.getInstance(); 
     1423                expected.setTime(date); 
     1424 
     1425                String beanClassName = Calendar.class.getName(); 
     1426                String defaultValue = null; 
     1427                Object actual = JavaScriptUtility.newInstanceFilledProperty(beanClassName, defaultValue); 
     1428 
     1429                assertTrue(actual instanceof Calendar); 
     1430                assertEquals(expected, actual); 
     1431        } 
     1432         
     1433        public void testNewInstanceFilledPropertyStringClassLoaderString() throws Exception { 
     1434                assertTrue("JavaScriptUtility.newInstanceFilledProperty(String, String)系のテストが通っていればOK", true); 
     1435        } 
     1436 
     1437        /** 
     1438         * <pre> 
     1439         *  1: A ・・・① 
     1440         *  2: ├─A  → (内部走査しない ∵自身) 
     1441         *  3: │ 
     1442         *  4: ├─B ・・・② 
     1443         *  5: │  │ 
     1444         *  6: │  ├─A  → (内部走査しない ∵既に①で走査済み) 
     1445         *  7: │  │ 
     1446         *  8: │  ├─B  → (内部走査しない ∵自身) 
     1447         *  9: │  │ 
     1448         * 10: │  ├─C ・・・③ 
     1449         * 11: │  │  │ 
     1450         * 12: │  │  ├─A    → (内部走査しない ∵既に①で走査済み) 
     1451         * 13: │  │  │ 
     1452         * 14: │  │  ├─B    → (内部走査しない ∵既に②で走査済み) 
     1453         * 15: │  │  │ 
     1454         * 16: │  │  ├─C    → (内部走査しない ∵自身) 
     1455         * 17: │  │  │ 
     1456         * 18: │  │  ├─Wrap → (内部走査終了可能) 
     1457         * 19: │  │  │ 
     1458         * 20: │  │  ├─A[]  → (内部走査しない ∵既に①で走査済み) 
     1459         * 21: │  │  │ 
     1460         * 22: │  │  ├─B[]  → (内部走査しない ∵既に②で走査済み) 
     1461         * 23: │  │  │ 
     1462         * 24: │  │  └─C[]  → (内部走査しない ∵既に③で走査済み) 
     1463         * 25: │  │ 
     1464         * 26: │  ├─Wrap → (内部走査終了可能) 
     1465         * 27: │  │ 
     1466         * 28: │  ├─A[] → (内部走査しない ∵既に①で走査済み) 
     1467         * 29: │  │ 
     1468         * 30: │  ├─B[] → (内部走査しない ∵既に②で走査済み) 
     1469         * 31: │  │ 
     1470         * 32: │  └─C[] → (内部走査しない ∵既に③で走査済み) 
     1471         * 33: │ 
     1472         * 34: ├─Wrap → (内部走査終了可能) 
     1473         * 35: │ 
     1474         * 36: ├─A[] → (内部走査しない ∵既に①で走査済み) 
     1475         * 37: │ 
     1476         * 38: └─B[] → (内部走査しない ∵既に②で走査済み) 
    2881477         * </pre> 
    2891478         * @throws Exception 
    2901479         */ 
    291         public void testNewInstanceFilledPropertyStringString() throws Exception { 
    292                 fail("まだ実装されていません。"); 
    293         } 
    294  
    295         public void testNewInstanceFilledPropertyStringClassLoaderString() throws Exception { 
    296                 fail("まだ実装されていません。"); 
    297         } 
    298  
    299         public void testNewInstanceFilledPropertyClassOfQString() throws Exception { 
    300                 fail("まだ実装されていません。"); 
     1480        public void testNewInstanceFilledPropertyClassOfQString_3つのクラスによる包含関係() throws Exception { 
     1481                Class expectedClass = JavaScriptUtilityTestModelA.class; 
     1482                Object actual = JavaScriptUtility.newInstanceFilledProperty(expectedClass, null); 
     1483                 
     1484                assertEquals(expectedClass, actual.getClass()); 
     1485                JavaScriptUtilityTestModelA actualObj = (JavaScriptUtilityTestModelA) actual; 
     1486 
     1487                //  2行目 
     1488                assertNull(actualObj.getModelA()); 
     1489 
     1490                //  4行目 
     1491                assertNotNull(actualObj.getModelB()); 
     1492 
     1493                //  6行目 
     1494                assertNull(actualObj.getModelB().getModelA()); 
     1495                 
     1496                //  8行目  
     1497                assertNull(actualObj.getModelB().getModelB()); 
     1498 
     1499                // 10行目  
     1500                assertNotNull(actualObj.getModelB().getModelC()); 
     1501 
     1502                // 12行目 
     1503                assertNull(actualObj.getModelB().getModelC().getModelA()); 
     1504                 
     1505                // 14行目 
     1506                assertNull(actualObj.getModelB().getModelC().getModelB()); 
     1507 
     1508                // 16行目 
     1509                assertNull(actualObj.getModelB().getModelC().getModelC()); 
     1510 
     1511                // 18行目 
     1512                assertEquals("prop_valueWrapperStringModelC", actualObj.getModelB().getModelC().getValueWrapperStringModelC()); 
     1513                assertEquals(new Double(123),            actualObj.getModelB().getModelC().getValueWrapperNumberModelC()); 
     1514                assertEquals(Boolean.TRUE,               actualObj.getModelB().getModelC().getValueWrapperBooleanModelC()); 
     1515                assertEquals(new Date(1213846496000L),   actualObj.getModelB().getModelC().getValueWrapperDateModelC()); // "Mon June 19 2008 12:34:56 GMT+0900 (JST)" 
     1516 
     1517                // 20行目 
     1518                assertNotNull(  actualObj.getModelB().getModelC().getModelArrayA()); 
     1519                assertEquals(0, actualObj.getModelB().getModelC().getModelArrayA().length); 
     1520                 
     1521                // 22行目 
     1522                assertNotNull(  actualObj.getModelB().getModelC().getModelArrayB()); 
     1523                assertEquals(0, actualObj.getModelB().getModelC().getModelArrayB().length); 
     1524                 
     1525                // 24行目 
     1526                assertNotNull(  actualObj.getModelB().getModelC().getModelArrayC()); 
     1527                assertEquals(0, actualObj.getModelB().getModelC().getModelArrayC().length); 
     1528 
     1529                // 26行目 
     1530                assertEquals("prop_valueWrapperStringModelB", actualObj.getModelB().getValueWrapperStringModelB()); 
     1531                assertEquals(new Double(123),            actualObj.getModelB().getValueWrapperNumberModelB()); 
     1532                assertEquals(Boolean.TRUE,               actualObj.getModelB().getValueWrapperBooleanModelB()); 
     1533                assertEquals(new Date(1213846496000L),   actualObj.getModelB().getValueWrapperDateModelB()); // "Mon June 19 2008 12:34:56 GMT+0900 (JST)" 
     1534 
     1535                // 28行目 
     1536                assertNotNull(  actualObj.getModelB().getModelArrayA()); 
     1537                assertEquals(0, actualObj.getModelB().getModelArrayA().length); 
     1538 
     1539                // 30行目 
     1540                assertNotNull(  actualObj.getModelB().getModelArrayB()); 
     1541                assertEquals(0, actualObj.getModelB().getModelArrayB().length); 
     1542 
     1543                // 32行目 
     1544                assertNotNull(  actualObj.getModelB().getModelArrayC()); 
     1545                assertEquals(0, actualObj.getModelB().getModelArrayC().length); 
     1546                 
     1547                // 34行目 
     1548                assertEquals("prop_valueWrapperStringModelA", actualObj.getValueWrapperStringModelA()); 
     1549                assertEquals(new Double(123),                     actualObj.getValueWrapperNumberModelA()); 
     1550                assertEquals(Boolean.TRUE,                        actualObj.getValueWrapperBooleanModelA()); 
     1551                assertEquals(new Date(1213846496000L),            actualObj.getValueWrapperDateModelA()); // "Mon June 19 2008 12:34:56 GMT+0900 (JST)" 
     1552 
     1553 
     1554                // 36行目 
     1555                assertNotNull(  actualObj.getModelArrayA()); 
     1556                assertEquals(0, actualObj.getModelArrayA().length); 
     1557 
     1558                // 38行目 
     1559                assertNotNull(  actualObj.getModelArrayB()); 
     1560                assertEquals(0, actualObj.getModelArrayB().length); 
     1561 
     1562        } 
     1563         
     1564         
     1565         
     1566        public void testNewInstanceFilledPropertyClassOfQString_プロパティがプリミティブやラッパークラスのみ() throws Exception { 
     1567                Class expectedClass = JavaScriptUtilityTestModel4PrimitiveAndWrapperProperty.class; 
     1568                Object actual = JavaScriptUtility.newInstanceFilledProperty(expectedClass, null); 
     1569 
     1570                assertEquals(expectedClass, actual.getClass()); 
     1571 
     1572                JavaScriptUtilityTestModel4PrimitiveAndWrapperProperty actualObj =  
     1573                                (JavaScriptUtilityTestModel4PrimitiveAndWrapperProperty) actual; 
     1574                 
     1575                assertEquals('p', actualObj.getValuePrimitiveChar()); 
     1576                assertEquals((new Double(123)).doubleValue(), actualObj.getValuePrimitiveDouble()); 
     1577                assertEquals((new Float(123)).floatValue(), actualObj.getValuePrimitiveFloat()); 
     1578                assertEquals((new Long(123)).longValue(), actualObj.getValuePrimitiveLong()); 
     1579                assertEquals((new Integer(123)).intValue(), actualObj.getValuePrimitiveInt()); 
     1580                assertEquals((new Short("123")).shortValue(), actualObj.getValuePrimitiveShort()); 
     1581                assertEquals((new Byte("123")).byteValue(), actualObj.getValuePrimitiveByte()); 
     1582                assertEquals(Boolean.TRUE.booleanValue(), actualObj.isValuePrimitiveBoolean()); 
     1583                 
     1584                assertEquals(1, actualObj.getValuePrimitiveArrayChar().length); 
     1585                assertEquals('p', actualObj.getValuePrimitiveArrayChar()[0]); 
     1586                assertEquals(1, actualObj.getValuePrimitiveArrayDouble().length); 
     1587                assertEquals((new Double(123)).doubleValue(), actualObj.getValuePrimitiveArrayDouble()[0]); 
     1588                assertEquals(1, actualObj.getValuePrimitiveArrayFloat().length); 
     1589                assertEquals((new Float(123)).floatValue(), actualObj.getValuePrimitiveArrayFloat()[0]); 
     1590                assertEquals(1, actualObj.getValuePrimitiveArrayLong().length); 
     1591                assertEquals((new Long(123)).longValue(), actualObj.getValuePrimitiveArrayLong()[0]); 
     1592                assertEquals(1, actualObj.getValuePrimitiveArrayInt().length); 
     1593                assertEquals((new Integer(123)).intValue(), actualObj.getValuePrimitiveArrayInt()[0]); 
     1594                assertEquals(1, actualObj.getValuePrimitiveArrayShort().length); 
     1595                assertEquals((new Short("123")).shortValue(), actualObj.getValuePrimitiveArrayShort()[0]); 
     1596                assertEquals(1, actualObj.getValuePrimitiveArrayByte().length); 
     1597                assertEquals((new Byte("123")).byteValue(), actualObj.getValuePrimitiveArrayByte()[0]); 
     1598                assertEquals(1, actualObj.getValuePrimitiveArrayBoolean().length); 
     1599                assertEquals(Boolean.TRUE.booleanValue(), actualObj.getValuePrimitiveArrayBoolean()[0]); 
     1600 
     1601                assertEquals("prop_valueWrapperString", actualObj.getValueWrapperString()); 
     1602                assertEquals(new Character('p'), actualObj.getValueWrapperCharacter()); 
     1603                assertEquals(new Double(123), actualObj.getValueWrapperDouble()); 
     1604                assertEquals(new Double(123), actualObj.getValueWrapperDouble_MAX()); 
     1605                assertEquals(new Double(123), actualObj.getValueWrapperDouble_MIN()); 
     1606                assertEquals(new Double(123), actualObj.getValueWrapperDouble_NaN()); 
     1607                assertEquals(new Double(123), actualObj.getValueWrapperDouble_NEGA_INF()); 
     1608                assertEquals(new Double(123), actualObj.getValueWrapperDouble_POSI_INF()); 
     1609                assertEquals(new Float(123), actualObj.getValueWrapperFloat()); 
     1610                assertEquals(new Long(123), actualObj.getValueWrapperLong()); 
     1611                assertEquals(new Long(123), actualObj.getValueWrapperLong_MAX()); 
     1612                assertEquals(new Long(123), actualObj.getValueWrapperLong_MIN()); 
     1613                assertEquals(new Integer(123), actualObj.getValueWrapperInteger()); 
     1614                assertEquals(new Short("123"), actualObj.getValueWrapperShort()); 
     1615                assertEquals(new Byte("123"), actualObj.getValueWrapperByte()); 
     1616                assertEquals(Boolean.TRUE, actualObj.getValueWrapperBoolean()); 
     1617                 
     1618                 
     1619                assertEquals(1, actualObj.getValueWrapperArrayString().length); 
     1620                assertEquals("prop_valueWrapperArrayString", actualObj.getValueWrapperArrayString()[0]); 
     1621                assertEquals(1, actualObj.getValueWrapperArrayCharacter().length); 
     1622                assertEquals(new Character('p'), actualObj.getValueWrapperArrayCharacter()[0]); 
     1623                assertEquals(1, actualObj.getValueWrapperArrayDouble().length); 
     1624                assertEquals(new Double(123), actualObj.getValueWrapperArrayDouble()[0]); 
     1625                assertEquals(1, actualObj.getValueWrapperArrayFloat().length); 
     1626                assertEquals(new Float(123), actualObj.getValueWrapperArrayFloat()[0]); 
     1627                assertEquals(1, actualObj.getValueWrapperArrayLong().length); 
     1628                assertEquals(new Long(123), actualObj.getValueWrapperArrayLong()[0]); 
     1629                assertEquals(1, actualObj.getValueWrapperArrayInteger().length); 
     1630                assertEquals(new Integer(123), actualObj.getValueWrapperArrayInteger()[0]); 
     1631                assertEquals(1, actualObj.getValueWrapperArrayShort().length); 
     1632                assertEquals(new Short("123"), actualObj.getValueWrapperArrayShort()[0]); 
     1633                assertEquals(1, actualObj.getValueWrapperArrayByte().length); 
     1634                assertEquals(new Byte("123"), actualObj.getValueWrapperArrayByte()[0]); 
     1635                assertEquals(1, actualObj.getValueWrapperArrayBoolean().length); 
     1636                assertEquals(Boolean.TRUE, actualObj.getValueWrapperArrayBoolean()[0]); 
    3011637        } 
    3021638 
  • trunk/im-jssp/src/test/java/org/intra_mart/jssp/util/JavaScriptUtilityTestModelA.java

    r217 r221  
    11package org.intra_mart.jssp.util; 
    22 
    3 public class JavaScriptUtilityTestBeansParent { 
     3import java.util.Date; 
     4 
     5// TODO Number 対応 
     6// TODO Calendar対応 
     7 
     8public class JavaScriptUtilityTestModelA { 
    49         
    5         char valuePrimitiveChar = 'ん'; 
    6         double valuePrimitiveDouble = 12.34; 
    7         float valuePrimitiveFloat = 56.78F; 
    8         long valuePrimitiveLong = 91011L; 
    9         int valuePrimitiveInt = 121314; 
    10         short valuePrimitiveShort = 456; 
    11         byte valuePrimitiveByte = 123; 
    12         boolean valuePrimitiveBoolean = true; 
     10        private JavaScriptUtilityTestModelA modelA; 
     11        private JavaScriptUtilityTestModelA[] modelArrayA; 
    1312 
    14         char[] valuePrimitiveArrayChar = {'わ', 'を', 'ん'}; 
    15         double[] valuePrimitiveArrayDouble = {12.34, 56.78, 910.1112}; 
    16         float[] valuePrimitiveArrayFloat = {56.78F, 910.1112F, 1314.1516F}; 
    17         long[] valuePrimitiveArrayLong = {91011L, 121314L, 151617L}; 
    18         int[] valuePrimitiveArrayInt = {121314, 1516, 1718}; 
    19         short[] valuePrimitiveArrayShort = {456, 789, 1011}; 
    20         byte[] valuePrimitiveArrayByte = {123, 124, 125}; 
    21         boolean[] valuePrimitiveArrayBoolean = {true, false, false}; 
     13        private JavaScriptUtilityTestModelB modelB; 
     14        private JavaScriptUtilityTestModelB[] modelArrayB; 
    2215 
    23         String valueWrapperString = "藍上尾"; 
    24         Character valueWrapperCharacter = new Character('や'); 
    25         Double valueWrapperDouble = new Double(141312); 
    26         Double valueWrapperDouble_MAX = Double.MAX_VALUE; 
    27         Double valueWrapperDouble_MIN = Double.MIN_VALUE; 
    28         Double valueWrapperDouble_NaN = Double.NaN; 
    29         Double valueWrapperDouble_NEGA_INF = Double.NEGATIVE_INFINITY; 
    30         Double valueWrapperDouble_POSI_INF = Double.POSITIVE_INFINITY; 
    31         Float valueWrapperFloat = new Float(11.109F); 
    32         Long valueWrapperLong = new Long(8765L); 
    33         Long valueWrapperLong_MAX = Long.MAX_VALUE; 
    34         Long valueWrapperLong_MIN = Long.MIN_VALUE; 
    35         Integer valueWrapperInteger = new Integer(4321); 
    36         Short valueWrapperShort = new Short("34"); 
    37         Byte valueWrapperByte = new Byte("12"); 
    38         Boolean valueWrapperBoolean = Boolean.TRUE; 
     16        private String valueWrapperStringModelA = "モデルA"; 
     17        private Number valueWrapperNumberModelA = new Double(394.859); 
     18        private Boolean valueWrapperBooleanModelA = Boolean.FALSE; 
     19        private Date valueWrapperDateModelA = new Date(1209612896000L); // Mon May 1 2008 12:34:56 GMT+0900 (JST) 
    3920         
    40         String[] valueWrapperArrayString = {"藍上尾", "書きくけ子", "さしすせそ"}; 
    41         Character[] valueWrapperArrayCharacter = {new Character('や'), new Character('ゆ'), new Character('よ')}; 
    42         Double[] valueWrapperArrayDouble = { 
    43                                 new Double(141312), 
    44                                 new Double(Double.MAX_VALUE), 
    45                                 new Double(Double.MIN_VALUE), 
    46                                 new Double(Double.NaN), 
    47                                 new Double(Double.NEGATIVE_INFINITY), 
    48                                 new Double(Double.POSITIVE_INFINITY)  
    49                         }; 
    50  
    51         Float[] valueWrapperArrayFloat = { 
    52                                 new Float(11.109F), 
    53                                 new Float(Float.MAX_VALUE), 
    54                                 new Float(Float.MIN_VALUE),  
    55                                 new Float(Float.NaN),  
    56                                 new Float(Float.NEGATIVE_INFINITY),  
    57                                 new Float(Float.POSITIVE_INFINITY) 
    58                         }; 
    59  
    60         Long[] valueWrapperArrayLong = { 
    61                                 new Long(8765L), 
    62                                 new Long(Long.MAX_VALUE), 
    63                                 new Long(Long.MIN_VALUE) 
    64                         }; 
    65  
    66         Integer[] valueWrapperArrayInteger = { 
    67                                 new Integer(4321),  
    68                                 new Integer(Integer.MAX_VALUE), 
    69                                 new Integer(Integer.MIN_VALUE) 
    70                         }; 
    71         Short[] valueWrapperArrayShort = { 
    72                                 new Short("34"), 
    73                                 new Short(Short.MAX_VALUE), 
    74                                 new Short(Short.MIN_VALUE) 
    75                         }; 
    7621         
    77         Byte[] valueWrapperArrayByte = { 
    78                                 new Byte("12"), 
    79                                 new Byte(Byte.MAX_VALUE), 
    80                                 new Byte(Byte.MIN_VALUE) 
    81                         }; 
    82  
    83         Boolean[] valueWrapperArrayBoolean = { 
    84                                 Boolean.FALSE, 
    85                                 Boolean.FALSE, 
    86                                 Boolean.TRUE 
    87                 }; 
     22        public JavaScriptUtilityTestModelA getModelA() { 
     23                return modelA; 
    8824        } 
     25        public void setModelA(JavaScriptUtilityTestModelA modelA) { 
     26                this.modelA = modelA; 
     27        } 
     28        public JavaScriptUtilityTestModelA[] getModelArrayA() { 
     29                return modelArrayA; 
     30        } 
     31        public void setModelArrayA(JavaScriptUtilityTestModelA[] modelArrayA) { 
     32                this.modelArrayA = modelArrayA; 
     33        } 
     34        public JavaScriptUtilityTestModelB getModelB() { 
     35                return modelB; 
     36        } 
     37        public void setModelB(JavaScriptUtilityTestModelB modelB) { 
     38                this.modelB = modelB; 
     39        } 
     40        public JavaScriptUtilityTestModelB[] getModelArrayB() { 
     41                return modelArrayB; 
     42        } 
     43        public void setModelArrayB(JavaScriptUtilityTestModelB[] modelArrayB) { 
     44                this.modelArrayB = modelArrayB; 
     45        } 
     46        public String getValueWrapperStringModelA() { 
     47                return valueWrapperStringModelA; 
     48        } 
     49        public void setValueWrapperStringModelA(String valueWrapperStringModelA) { 
     50                this.valueWrapperStringModelA = valueWrapperStringModelA; 
     51        } 
     52        public Number getValueWrapperNumberModelA() { 
     53                return valueWrapperNumberModelA; 
     54        } 
     55        public void setValueWrapperNumberModelA(Number valueWrapperNumberModelA) { 
     56                this.valueWrapperNumberModelA = valueWrapperNumberModelA; 
     57        } 
     58        public Boolean getValueWrapperBooleanModelA() { 
     59                return valueWrapperBooleanModelA; 
     60        } 
     61        public void setValueWrapperBooleanModelA(Boolean valueWrapperBooleanModelA) { 
     62                this.valueWrapperBooleanModelA = valueWrapperBooleanModelA; 
     63        } 
     64        public Date getValueWrapperDateModelA() { 
     65                return valueWrapperDateModelA; 
     66        } 
     67        public void setValueWrapperDateModelA(Date valueWrapperDateModelA) { 
     68                this.valueWrapperDateModelA = valueWrapperDateModelA; 
     69        } 
     70}