チェンジセット 302

差分発生行の前後
無視リスト:
コミット日時:
2008/07/21 02:18:01 (14 年前)
コミッタ:
shinomiya
ログメッセージ:

#43 JavaScriptUtility?の追加

ファイル:

凡例:

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

    r299 r302  
    55import java.beans.Introspector; 
    66import java.beans.PropertyDescriptor; 
     7import java.io.ByteArrayOutputStream; 
     8import java.io.IOException; 
     9import java.io.InputStream; 
     10import java.io.UnsupportedEncodingException; 
    711import java.lang.reflect.Array; 
     12import java.lang.reflect.Field; 
    813import java.lang.reflect.InvocationTargetException; 
    914import java.lang.reflect.Method; 
     15import java.lang.reflect.Modifier; 
    1016import java.util.ArrayList; 
    1117import java.util.Calendar; 
     
    1622import java.util.WeakHashMap; 
    1723 
     24import javax.activation.DataHandler; 
     25import javax.activation.DataSource; 
     26import javax.mail.util.ByteArrayDataSource; 
     27 
    1828import org.intra_mart.common.platform.log.Logger; 
    1929import org.intra_mart.jssp.exception.IllegalConversionException; 
     30import org.intra_mart.jssp.page.JSSPQuery; 
     31import org.intra_mart.jssp.page.JSSPQueryManager; 
    2032import org.intra_mart.jssp.script.ScriptScope; 
    2133import org.intra_mart.jssp.script.provider.ScriptScopeBuilder; 
     
    2638import org.mozilla.javascript.ScriptableObject; 
    2739import org.mozilla.javascript.Undefined; 
     40import org.mozilla.javascript.WrappedException; 
    2841import org.mozilla.javascript.Wrapper; 
    2942 
     
    3245 */ 
    3346public class JavaScriptUtility { 
     47 
     48        /** 文字コード変換を行わずに、バイト配列を扱う為の文字コード */ 
     49        public static final String NON_CONVERT_CHARSET = "ISO-8859-1"; 
    3450         
    3551        private static Logger _logger = Logger.getLogger(); 
     
    5268         * @param args 関数の引数 
    5369         * @throws IllegalConversionException Java形式からJavaScript形式への変換に失敗した場合。 
     70         * @throws Exception JavaScript関数の実行時にエラーが発生した場合。 
    5471         *  
    5572         * @see #executeFunction(String, String, Class, Object...) 
     
    5875                                                                                   final String functionName,  
    5976                                                                                   final Object... args) 
    60                                                                         throws IllegalConversionException
     77                                                                        throws IllegalConversionException, Exception
    6178                executeFunction(pagePath, functionName, void.class, args); 
    6279        } 
     
    88105         * @throws IllegalConversionException Java形式 から JavaScript形式への変換、または、 
    89106         *                                                                        JavaScript形式 から Java形式への変換に失敗した場合。 
     107         * @throws Exception JavaScript関数の実行時にエラーが発生した場合。 
    90108         */ 
    91109        public static Object executeFunction(final String pagePath,  
     
    93111                                                                                 final Class<?> returnType, 
    94112                                                                                 final Object... args) 
    95                                                                         throws IllegalConversionException
     113                                                                        throws IllegalConversionException, Exception
    96114 
    97115                // ===================== 
     
    109127                } 
    110128                 
     129                // JSSPQueryの設定 
     130                JSSPQuery currentJsspQuery = JSSPQueryManager.currentJSSPQuery(); 
     131                JSSPQuery newJsspQuery = (currentJsspQuery != null) ?  
     132                                                                        JSSPQueryManager.createJSSPQuery(pagePath, currentJsspQuery.getFromPagePath()) :  
     133                                                                        JSSPQueryManager.createJSSPQuery(pagePath); 
     134                JSSPQueryManager.entry(newJsspQuery); 
     135 
    111136                // ===================== 
    112137                // JS実行 
     
    119144                                new ScriptScope(Thread.currentThread().getName().concat(String.valueOf(System.currentTimeMillis())));            
    120145                         
     146                        // スコープ生成 
    121147                        ScriptScopeBuilder builder = ScriptScopeBuilderManager.getBuilder(); 
    122148                        ScriptScope scriptScope = builder.getScriptScope(pagePath); 
     149 
     150                        // 実行 
    123151                        jsResult = scriptScope.call(cx, functionName, args4JS, parentScope); 
    124152                } 
    125                 catch (Exception e) { 
    126                         throw new IllegalStateException(e); 
     153                catch (WrappedException we) { 
     154                        Throwable t = we.getWrappedException(); 
     155                        if(t instanceof Error){ 
     156                                throw (Error) t; 
     157                        } 
     158                        else{ 
     159                                throw (Exception) t; 
     160                        } 
     161                } 
     162                catch(Exception e){ 
     163                        throw e; 
    127164                } 
    128165                finally{ 
     166                        JSSPQueryManager.entry(currentJsspQuery); 
    129167                        Context.exit(); 
    130168                } 
     
    153191        // PLAN Map対応(ValueObjectにて対応=1階層か?) 
    154192        // PLAN List対応 
     193        private static Logger _logger4javaBeanToJS = Logger.getLogger(JavaScriptUtility.class.getName() + ".javaBeanToJS"); 
    155194         
    156195        /** 
     
    162201         * 引数に<a href="http://java.sun.com/j2se/1.5.0/ja/docs/ja/guide/beans/index.html">JavaBean</a> 
    163202         * 形式のインスタンスが渡された場合、そのプロパティを<a href="#MappingTable4JavaBeanToJS">対応表</a>に基づいて変換します。<br/> 
     203         * (Publicフィールドも変換されます。その際のJavaScriptプロパティ名は、Publicフィールド名です。)<br/> 
    164204         * プロパティの値がJavaBean形式のインスタンスである場合、さらにそのプロパティの変換を試みます。<br/> 
    165205         * これを繰りかえし、最終的に、<b>null</b>, <b>String</b>, <b>Number</b>, 
     
    203243         *  </tr> 
    204244         *  <tr> 
     245         *      <td>byte[]</td> 
     246         *      <td rowspan="2">→</td> 
     247         *      <td rowspan="2">String (バイナリ)</td> 
     248         *  </tr> 
     249         *  <tr> 
     250         *      <td>javax.activation.DataHandler</td> 
     251         *  </tr> 
     252         *  <tr> 
    205253         *      <td>配列</td> 
    206254         *      <td>→</td> 
     
    209257         * </table> 
    210258         * <br/> 
     259         *  
    211260         * 上記以外のクラスは変換対象外です。(例えば、List, Map, Setを変換することはできません。)<br/> 
    212          * 変換対象外のインスタンスが指定された場合は、IllegalArgumentException をスローします。<br/> 
     261         * 変換対象外のインスタンスが指定された場合は、プロパティを一つも持たないJavaScriptオブジェクトが返却されます。<br/> 
    213262         * <br/> 
    214263         * 引数にJavaBean形式のインスタンスが渡された場合、GetterとSetterが両方存在するプロパティを変換します。<br/> 
    215264         * GetterとSetterのどちらか一方しかないプロパティは変換されません。<br/> 
    216          * また、プロパティの存在しないJavaBeanが渡された場合は、IllegalArgumentExceptionをスローします。<br/> 
     265         * また、プロパティの存在しないJavaBeanが渡された場合は、プロパティを一つも持たないJavaScriptオブジェクトを返却します。<br/> 
    217266         * 同様に、GetterとSetterのどちらか一方しかないプロパティだけで構成されるJavaBeanの場合も、 
    218          * IllegalArgumentExceptionをスローします。<br/> 
     267         * プロパティを一つも持たないJavaScriptオブジェクトを返却します。<br/> 
    219268         * <br/> 
    220269         *  
     
    222271         * @return 変換後のJavaScriptオブジェクト 
    223272         *  
    224          * @throws IllegalArgumentException プロパティの存在しないJavaBeanが渡された場合 
    225273         * @throws IntrospectionException イントロスペクション中に例外が発生した場合 
    226274         * @throws IllegalAccessException 引数に渡されたJavaBeanのGetterにアクセスできない場合 
    227275         * @throws InvocationTargetException 引数に渡されたJavaBeanのGetterが例外をスローする場合 
     276         * @throws IOException バイナリデータの変換に失敗した場合 
    228277         */ 
    229278        public static Object javaBeanToJS(final Object bean) 
    230                                                         throws IllegalArgumentException, IntrospectionException,  
     279                                                        throws IntrospectionException, IOException, 
    231280                                                                   IllegalAccessException, InvocationTargetException { 
    232  
     281         
     282                _logger4javaBeanToJS.trace("bean: {}", bean); 
     283                 
    233284                // NOTE プリミティブ型は受け取りません。 
    234285                // ∵本メソッドの引数はObject型で定義されているので、 
     
    237288                // null 
    238289                if(bean == null){ 
     290                        _logger4javaBeanToJS.trace("========== null =========="); 
    239291                        return bean; 
    240292                } 
    241293 
    242294                Class<?> targetType = bean.getClass(); 
    243  
     295                _logger4javaBeanToJS.trace("targetType: {}", targetType); 
    244296 
    245297                // 文字列 
    246298                if (bean instanceof String) { 
     299                        _logger4javaBeanToJS.trace("========== String =========="); 
    247300                        return bean; 
    248301                } 
    249302                else if (bean instanceof Character) { 
     303                        _logger4javaBeanToJS.trace("========== Character =========="); 
    250304                        return ((Character)bean).toString(); 
    251305                } 
     
    253307                // 数値 
    254308                else if (bean instanceof Number) { 
     309                        _logger4javaBeanToJS.trace("========== Number =========="); 
    255310                        double doubleValue = ((Number)bean).doubleValue(); 
    256311                        return new Double(doubleValue); 
     
    259314                // 真偽値 
    260315                else if (bean instanceof Boolean) { 
     316                        _logger4javaBeanToJS.trace("========== Boolean =========="); 
    261317                        return bean; 
    262318                } 
     
    264320                // 日付 
    265321                else if (bean instanceof Date) { 
     322                        _logger4javaBeanToJS.trace("========== Date =========="); 
    266323                        Date date = (Date) bean; 
    267324                         
     
    270327                } 
    271328                else if (bean instanceof Calendar) { 
     329                        _logger4javaBeanToJS.trace("========== Calendar =========="); 
    272330                        Calendar cal = (Calendar) bean; 
    273331                        Date date = cal.getTime(); 
     332                        _logger4javaBeanToJS.trace("date: {}", date); 
    274333                         
    275334                        Scriptable nativeDate = RuntimeObject.newDate(date.getTime()); 
     
    277336                } 
    278337 
     338                // バイナリ (バイト配列) 
     339                else if(targetType.equals(byte[].class)){ 
     340                        _logger4javaBeanToJS.trace("========== byte[] =========="); 
     341                        return new String((byte[])bean, NON_CONVERT_CHARSET); 
     342                } 
     343                 
     344                // バイナリ (DataHandler) 
     345                else if(bean instanceof javax.activation.DataHandler){ 
     346                        _logger4javaBeanToJS.trace("========== javax.activation.DataHandler =========="); 
     347                         
     348                        javax.activation.DataHandler dataHandler = (javax.activation.DataHandler) bean; 
     349 
     350                        InputStream in = dataHandler.getInputStream(); 
     351                        ByteArrayOutputStream out = new ByteArrayOutputStream(); 
     352                         
     353                        try{ 
     354                                byte[] buf = new byte[1024]; 
     355                                 
     356                                while(true){ 
     357                                        int len = in.read(buf); 
     358                                         
     359                                        if(len != -1) { 
     360                                                out.write(buf, 0, len); 
     361                                        } 
     362                                        else { 
     363                                                break; 
     364                                        } 
     365                                } 
     366 
     367                                return out.toString(NON_CONVERT_CHARSET); 
     368                        } 
     369                        finally { 
     370                                if(in != null)  in.close(); 
     371                                if(out != null) out.close(); 
     372                        } 
     373                } 
     374                 
    279375                // 配列 
    280376                else if(targetType.isArray()){ 
     377                        Class<?> componentType = targetType.getComponentType(); 
     378                        _logger4javaBeanToJS.trace("========== Array =========="); 
     379                        _logger4javaBeanToJS.trace("componentType: {}", componentType); 
    281380 
    282381                        int length = Array.getLength(bean); 
    283382                        Object[] list = new Object[length]; 
    284383                         
     384                        _logger4javaBeanToJS.trace("---- Array (Start) ----"); 
    285385                        for(int idx = 0; idx < length; idx++){ 
    286386                                Object value4Java = Array.get(bean, idx); 
     387                                _logger4javaBeanToJS.trace("value4Java[{}]: {}", idx, value4Java); 
    287388 
    288389                                // ********* 再帰 ********* 
    289390                                list[idx] = javaBeanToJS(value4Java); 
    290391                        } 
     392                        _logger4javaBeanToJS.trace("---- Array (Start) ----"); 
    291393                         
    292394                        NativeArray nativeArray = RuntimeObject.newArrayInstance(list); 
    293395 
    294396                        // Javaのクラス名を格納(隠しプロパティ) 
    295                         setProperty4imJavaClassName(nativeArray, "", targetType.getComponentType()); 
     397                        setProperty4imJavaClassName(nativeArray, "", componentType); 
    296398                        return nativeArray; 
     399                } 
     400                 
     401                // java.lang.Object 
     402                else if(targetType.equals(java.lang.Object.class)){ 
     403                        _logger4javaBeanToJS.trace("========== java.lang.Object =========="); 
     404                        return bean; 
    297405                } 
    298406 
    299407                // 上記以外は、JavaBeanとして扱う 
    300408                else{ 
     409                        _logger4javaBeanToJS.trace("========== JavaBean =========="); 
    301410                        ScriptableObject jsObject = new ValueObject(); 
    302                          
    303                         Map<String, PropertyDescriptor> map = getBeanPropertyMap(targetType); 
    304                         Iterator<Map.Entry<String, PropertyDescriptor>> it = map.entrySet().iterator(); 
    305                          
    306                         while(it.hasNext()){ 
    307                                 Map.Entry<String, PropertyDescriptor> entry = it.next(); 
    308                                 PropertyDescriptor propDescriptor = entry.getValue(); 
     411 
     412                        // Publicフィールド 
     413                        Map<String, Field> pubFieldMap = getPublicFieldMap(targetType); 
     414                        if(pubFieldMap != null){ 
     415                                Iterator<Map.Entry<String, Field>> it = pubFieldMap.entrySet().iterator(); 
     416 
     417                                _logger4javaBeanToJS.trace("---- PublicField (Start) ----"); 
     418                                while(it.hasNext()){ 
     419                                        Map.Entry<String, Field> entry = it.next(); 
     420                                         
     421                                        String propName = entry.getKey(); 
     422                                        Field field     = entry.getValue(); 
     423                                         
     424                                        _logger4javaBeanToJS.trace("--------"); 
     425                                        _logger4javaBeanToJS.trace("propName: {}", propName); 
     426                                        _logger4javaBeanToJS.trace("field: {}", field); 
     427                                        _logger4javaBeanToJS.trace("----"); 
     428                                         
     429                                        // ********* 再帰 ********* 
     430                                        Object value4Java = field.get(bean); 
     431                                        _logger4javaBeanToJS.trace("value4Java: {}", value4Java); 
     432                                        _logger4javaBeanToJS.trace("--------"); 
     433                                         
     434                                        Object obj = javaBeanToJS(value4Java); 
     435                                         
     436                                        // JSオブジェクト に プロパティ を 設定 
     437                                        ScriptableObject.putProperty(jsObject, propName, obj); 
     438                                         
     439                                        // Javaのクラス名を格納(隠しプロパティ) 
     440                                        setProperty4imJavaClassName(jsObject, propName, field.getType()); 
     441                                } 
     442                                _logger4javaBeanToJS.trace("---- PublicField (End) ----"); 
    309443                                 
    310                                 String propName = propDescriptor.getName(); 
    311                                 Method readMethod = propDescriptor.getReadMethod(); 
     444                        } 
     445                         
     446                        // JavaBeans 
     447                        Map<String, PropertyDescriptor> beanPropMap = getBeanPropertyMap(targetType); 
     448                        if(beanPropMap != null){ 
     449                                Iterator<Map.Entry<String, PropertyDescriptor>> it = beanPropMap.entrySet().iterator(); 
    312450                                 
    313                                 // ********* 再帰 ********* 
    314                                 Object value4Java = readMethod.invoke(bean, new Object[0]);  
    315                                 Object obj = javaBeanToJS(value4Java); 
    316                                  
    317                                 // JSオブジェクト に プロパティ を 設定 
    318                                 ScriptableObject.putProperty(jsObject, propName, obj); 
    319                                  
    320                                 // Javaのクラス名を格納(隠しプロパティ) 
    321                                 setProperty4imJavaClassName(jsObject, propName, readMethod.getReturnType()); 
     451                                _logger4javaBeanToJS.trace("---- JavaBeans (Start) ----"); 
     452                                while(it.hasNext()){ 
     453                                        Map.Entry<String, PropertyDescriptor> entry = it.next(); 
     454                                        PropertyDescriptor propDescriptor = entry.getValue(); 
     455                                         
     456                                        String propName = propDescriptor.getName(); 
     457                                        Method readMethod = propDescriptor.getReadMethod(); 
     458 
     459                                        _logger4javaBeanToJS.trace("--------"); 
     460                                        _logger4javaBeanToJS.trace("propName: {}", propName); 
     461                                        _logger4javaBeanToJS.trace("readMethod", readMethod); 
     462                                        _logger4javaBeanToJS.trace("----"); 
     463                                         
     464                                        // ********* 再帰 ********* 
     465                                        Object value4Java = readMethod.invoke(bean, new Object[0]);  
     466                                        _logger4javaBeanToJS.trace("value4Java: {}", value4Java); 
     467                                        _logger4javaBeanToJS.trace("--------"); 
     468 
     469                                        Object obj = javaBeanToJS(value4Java); 
     470                                         
     471                                        // JSオブジェクト に プロパティ を 設定 
     472                                        ScriptableObject.putProperty(jsObject, propName, obj); 
     473                                         
     474                                        // Javaのクラス名を格納(隠しプロパティ) 
     475                                        setProperty4imJavaClassName(jsObject, propName, readMethod.getReturnType()); 
     476                                } 
     477                                _logger4javaBeanToJS.trace("---- JavaBeans (End) ----"); 
    322478                        } 
    323479                         
     
    370526         *  
    371527         * @throws IllegalConversionException 変換処理に失敗した場合 
    372          * @throws IllegalArgumentException 変換対象外のクラスが指定された場合 
    373528         * @throws InstantiationException 指定された変換後のJavaクラスが、抽象クラス、インタフェース、配列クラス、プリミティブ型、または void を表す場合。または、指定された変換後のJavaクラスが無引数コンストラクタを保持しない場合、あるいはインスタンスの生成がほかの理由で失敗した場合 
    374529         * @throws IllegalAccessException 指定された変換後のJavaクラス、またはその無引数コンストラクタにアクセスできない場合。または、JavaBeanプロパティのSetterメソッドにアクセスできない場合。 
    375530         * @throws IntrospectionException イントロスペクション中に例外が発生した場合 
    376531         * @throws ClassNotFoundException 指定された変換後のJavaクラスが見つからなかった場合 
     532         * @throws IOException バイナリデータの変換に失敗した場合 
    377533         *  
    378534         * @see #jsToJavaBean(Object, String, ClassLoader) 
     
    380536         */ 
    381537        public static Object jsToJavaBean(final Object jsObject, final String beanClassName)  
    382                                                         throws IllegalConversionException, IllegalArgumentException, 
     538                                                        throws IllegalConversionException, IOException, 
    383539                                                                   InstantiationException, IllegalAccessException,  
    384540                                                                   IntrospectionException, ClassNotFoundException { 
     
    400556         *  
    401557         * @throws IllegalConversionException 変換処理に失敗した場合 
    402          * @throws IllegalArgumentException 変換対象外のクラスが指定された場合 
    403558         * @throws InstantiationException 指定された変換後のJavaクラスが、抽象クラス、インタフェース、配列クラス、プリミティブ型、または void を表す場合。または、指定された変換後のJavaクラスが無引数コンストラクタを保持しない場合、あるいはインスタンスの生成がほかの理由で失敗した場合 
    404559         * @throws IllegalAccessException 指定された変換後のJavaクラス、またはその無引数コンストラクタにアクセスできない場合。または、JavaBeanプロパティのSetterメソッドにアクセスできない場合。 
    405560         * @throws IntrospectionException イントロスペクション中に例外が発生した場合 
    406561         * @throws ClassNotFoundException 指定された変換後のJavaクラスが見つからなかった場合 
     562         * @throws IOException バイナリデータの変換に失敗した場合 
    407563         *  
    408564         * @see #jsToJavaBean(Object, Class) 
     
    411567                                                                          final String beanClassName,  
    412568                                                                          final ClassLoader classLoader)  
    413                                                         throws IllegalConversionException, IllegalArgumentException, 
     569                                                        throws IllegalConversionException, IOException, 
    414570                                                                   InstantiationException, IllegalAccessException,  
    415571                                                                   IntrospectionException, ClassNotFoundException { 
     
    428584        } 
    429585 
     586        private static Logger _logger4jsToJavaBean = Logger.getLogger(JavaScriptUtility.class.getName() + ".jsToJavaBean"); 
     587         
    430588        /** 
    431589         * JavaScriptオブジェクトをJavaオブジェクトに変換します。<br/> 
     
    440598         * (JavaBeanの同名プロパティが無い場合、JavaScriptオブジェクトのプロパティは変換されません)<br/> 
    441599         * <br/> 
     600         * 同様に、変換後のJavaクラス内にPublicフィールドが定義されている場合、 
     601         * JavaScriptオブジェクトのプロパティを、同名のPublicフィールドに設定します。<br/> 
     602         * (同名のPublicフィールドがない場合、JavaScriptオブジェクトのプロパティは変換されません)<br/> 
     603         * <br/> 
    442604         * JavaBeanの同名プロパティの型がJavaBean形式クラスの場合、さらにそのプロパティの変換を試みます。<br/> 
    443605         * これを繰り返し、最終的にラッパークラス、または、JavaBean形式のインスタンスに変換します。<br/> 
     
    470632         *      <td>java.lang.Character</td> 
    471633         *      <td>先頭1文字をCharacterに変換します。</td> 
     634         *  </tr> 
     635         *  <tr> 
     636         *      <td rowspan="2">String (バイナリ)</td> 
     637         *      <td rowspan="2">→</td> 
     638         *      <td>byte[]</td> 
     639         *      <td rowspan="2"> 
     640         *              「String (バイナリ)」とは、<br/> 
     641         *              JavaScriptAPIの「Fileオブジェクト」や「VirtualFileオブジェクト」の「load()関数」などで<br/> 
     642         *              取得できるファイルデータ(バイナリ)の事を意味します。<br/> 
     643         *      </td> 
     644         *  </tr> 
     645         *  <tr> 
     646         *      <td>javax.activation.DataHandler</td> 
    472647         *  </tr> 
    473648         *  <tr> 
     
    529704         * <br/> 
    530705         * 上記以外は変換対象外です。(List, Map, Setには変換できません)<br/> 
    531          * 変換対象外のクラスが指定された場合は、IllegalArgumentException をスローします。<br/> 
     706         * 変換対象外のクラスが指定された場合は、 JavaScriptオブジェクトのプロパティは変換されません。<br/> 
    532707         * <br/> 
    533708         * なお、このメソッドは、GetterとSetterが両方存在するJavaBeanのプロパティに対して、 
    534709         * JavaScriptオブジェクトのプロパティをマッピングします。<br/> 
    535710         * GetterとSetterのどちらか一方しかないJavaBeanのプロパティへのマッピングはおこないません。<br/> 
    536          * また、プロパティの存在しないJavaBean形式のクラスを指定した場合は、IllegalArgumentExceptionをスローします。<br/> 
     711         * また、プロパティの存在しないJavaBean形式のクラスを指定した場合は、JavaScriptオブジェクトのプロパティは変換されません。<br/> 
    537712         * 同様に、GetterとSetterのどちらか一方しかないプロパティだけで構成されるJavaBeanの場合も、 
    538          * IllegalArgumentExceptionをスローします。<br/> 
     713         * JavaScriptオブジェクトのプロパティは変換されません。<br/> 
    539714         *   
    540715         * @param jsObject 変換対象のJavaScriptオブジェクト 
     
    543718         *  
    544719         * @throws IllegalConversionException 変換処理に失敗した場合 
    545          * @throws IllegalArgumentException 変換対象外のクラスが指定された場合 
    546720         * @throws InstantiationException 指定された変換後のJavaクラスが、抽象クラス、インタフェース、配列クラス、プリミティブ型、または void を表す場合。または、指定された変換後のJavaクラスが無引数コンストラクタを保持しない場合、あるいはインスタンスの生成がほかの理由で失敗した場合 
    547721         * @throws IllegalAccessException 指定された変換後のJavaクラス、またはその無引数コンストラクタにアクセスできない場合。または、JavaBeanプロパティのSetterメソッドにアクセスできない場合。 
    548722         * @throws IntrospectionException イントロスペクション中に例外が発生した場合 
     723         * @throws IOException バイナリデータの変換に失敗した場合 
    549724         */ 
    550725        public static Object jsToJavaBean(final Object jsObject, final Class<?> beanType) 
    551                                                         throws IllegalConversionException, IllegalArgumentException, 
     726                                                        throws IllegalConversionException, IOException, 
    552727                                                                   InstantiationException, IllegalAccessException,  
    553728                                                                   IntrospectionException { 
     729                 
     730                _logger4jsToJavaBean.trace("*************** jsToJavaBean() ******************"); 
     731                _logger4jsToJavaBean.trace("jsObject: {}", jsObject); 
     732                _logger4jsToJavaBean.trace("beanType: {}", beanType); 
    554733 
    555734                if(jsObject == null){ 
     
    559738                Object wapper = checkPrimitiveAndWrapper(jsObject, beanType.getName()); 
    560739                if(wapper != null){ 
     740                        _logger4jsToJavaBean.trace("========== null =========="); 
    561741                        return wapper; 
    562742                } 
    563743 
    564                 if (jsObject instanceof String 
     744                // バイナリ (バイト配列) 
     745                if(jsObject instanceof String && beanType.equals(byte[].class)){ 
     746                        _logger4jsToJavaBean.trace("========== byte[] =========="); 
     747 
     748                        try { 
     749                                return jsObject.toString().getBytes(NON_CONVERT_CHARSET); 
     750                        } 
     751                        catch (UnsupportedEncodingException e) { 
     752                                throw new IllegalStateException(e); 
     753                        } 
     754                } 
     755 
     756                // バイナリ (DataHandler) 
     757                else if(jsObject instanceof String && beanType.equals(javax.activation.DataHandler.class)){ 
     758                        _logger4jsToJavaBean.trace("========== javax.activation.DataHandler =========="); 
     759 
     760                        byte[] bytes = jsObject.toString().getBytes(NON_CONVERT_CHARSET); 
     761                        DataSource ds = new ByteArrayDataSource(bytes, "application/octet-stream"); 
     762                        DataHandler dh = new DataHandler(ds); 
     763                        _logger4jsToJavaBean.debug("Content-Type: {}", dh.getContentType()); 
     764                         
     765                        return dh; 
     766                } 
     767                                 
     768                // そのまま返却する場合 
     769                else if (jsObject instanceof String 
    565770                        || 
    566771                        // NaN含む  ScriptRuntime → public static final Double NaNobj = new Double(NaN); 
     
    571776                        beanType.equals(jsObject.getClass())) { 
    572777 
     778                        _logger4jsToJavaBean.trace("========== String || Number || Boolean || beanType =========="); 
    573779                        return jsObject; 
    574780                } 
     
    576782                // Date型 
    577783                else if (JsUtil.isDate(jsObject)) { 
     784                        _logger4jsToJavaBean.trace("========== NativeDate =========="); 
     785 
    578786                        Date date = (Date) Context.jsToJava(jsObject, Date.class); 
     787                        _logger4jsToJavaBean.trace("jsObject[Date]: {}", date); 
    579788                         
    580789                        if(beanType.equals(Calendar.class)){ 
     790                                _logger4jsToJavaBean.trace("----- Calendar -----"); 
    581791                                Calendar cal = Calendar.getInstance(); 
    582792                                cal.setTimeInMillis(date.getTime()); 
     
    584794                        } 
    585795                        else{ 
     796                                _logger4jsToJavaBean.trace("----- Date -----"); 
    586797                                return date; 
    587798                        } 
    588799                } 
    589                  
     800 
    590801                // Array型 
    591802                else if(jsObject instanceof NativeArray){ 
     803                        _logger4jsToJavaBean.trace("========== NativeArray =========="); 
    592804                         
    593805                        // 配列のコンポーネント型を表す Class 
    594806                        Class<?> componentType = beanType.getComponentType(); 
     807                        _logger4jsToJavaBean.trace("componentType: {}", componentType); 
    595808 
    596809                        NativeArray jsArray = (NativeArray) jsObject; 
    597810                        int maxLength = (int)jsArray.getLength(); 
    598                         Object returnObj = Array.newInstance(componentType, maxLength); 
    599  
     811                         
     812                        Object returnObj; 
     813                        try { 
     814                                returnObj = Array.newInstance(componentType, maxLength); 
     815                        } 
     816                        catch (Exception e) { 
     817                                String beanTypeName = beanType.getName(); 
     818                                String msg = "Cannot convert 'JavaScript NativeArray' into 'Java class <" + beanTypeName + ">'. "; 
     819                                       msg += "(<" + beanTypeName + "> may not be declared as an array)"; 
     820                                 
     821                                throw new IllegalConversionException(msg, e); 
     822                        } 
     823 
     824                        _logger4jsToJavaBean.trace("---- NativeArray (Start) ----"); 
    600825                        for(int idx = 0; idx < maxLength; idx++){ 
    601826                                Object propValue = jsArray.get(idx, jsArray); 
     
    603828                                // ********* 再帰 ********* 
    604829                                Object javaValue = jsToJavaBean(propValue, componentType); 
     830                                _logger4jsToJavaBean.trace("javaValue[{}]: {}", idx, javaValue); 
    605831                                 
    606832                                // オブジェクト配列に値を設定 
    607                                 Array.set(returnObj, idx, javaValue); 
    608                         } 
     833                                try{ 
     834                                        Array.set(returnObj, idx, javaValue); 
     835                                } 
     836                                catch(Exception e){ 
     837                                        String msg = "Cannot convert '" + propValue + "' into <" + componentType.getName() + ">." +  
     838                                                                 " (beanType: " + beanType.getName() + ", index: "+ idx +")";  
     839                                        throw new IllegalConversionException(msg, e); 
     840                                } 
     841                                         
     842                        } 
     843                        _logger4jsToJavaBean.trace("---- NativeArray (End) ----"); 
    609844                         
    610845                        return returnObj; 
     
    613848                // Wrapper型 
    614849                else if(jsObject instanceof Wrapper){ 
     850                        _logger4jsToJavaBean.trace("========== Wrapper =========="); 
     851 
    615852                        Wrapper wrapper = (Wrapper)jsObject; 
    616853                        Object wrappedValue = wrapper.unwrap(); 
    617854                         
    618855                        if(beanType.isInstance(wrappedValue)){ 
     856                                _logger4jsToJavaBean.trace("jsObject[Wrapper]: {}", wrappedValue); 
    619857                                return wrappedValue; 
    620858                        } 
    621859                        else{ 
     860                                _logger4jsToJavaBean.trace("jsObject[Wrapper]: null"); 
    622861                                return null; 
    623862                        } 
     
    626865                // Object型 
    627866                else if(jsObject instanceof Scriptable){ 
     867                        _logger4jsToJavaBean.trace("========== Scriptable =========="); 
     868 
    628869                        Object returnObj = beanType.newInstance(); 
    629870 
     
    631872                        Object[] ids = scriptable.getIds(); 
    632873                         
     874                        _logger4jsToJavaBean.trace("---- Scriptable (Start) ----"); 
    633875                        for(Object id : ids){ 
    634876                                if(id instanceof String){ 
    635877                                        String propName = (String)id; 
    636                                         Map<String, PropertyDescriptor> map = getBeanPropertyMap(beanType); 
    637                                         PropertyDescriptor propDescriptor = map.get(propName); 
    638                                          
    639                                         if(propDescriptor == null){ 
    640                                                 // プロパティ名がPascal形式の場合(.Net対応) 
    641                                                 String propName4LowerCamel = propName.substring(0, 1).toLowerCase(); 
    642                                                 if(propName.length() > 1){ 
    643                                                         propName4LowerCamel = propName4LowerCamel.concat(propName.substring(1)); 
     878                                        _logger4jsToJavaBean.trace("propName: {}", propName); 
     879 
     880                                        // JSオブジェクトよりプロパティ値を取得 
     881                                        Object propValue = scriptable.get(propName, scriptable); 
     882                                         
     883                                        // Publicフィールド 
     884                                        Map<String, Field> pubFieldMap = getPublicFieldMap(beanType); 
     885                                        if(pubFieldMap != null){ 
     886                                                _logger4jsToJavaBean.trace("---- PublicField ----"); 
     887                                                Field publicField = pubFieldMap.get(propName); 
     888                                                 
     889                                                if(publicField == null){ 
     890                                                        // プロパティ名がPascal形式の場合(.Net対応) 
     891                                                        String propName4LowerCamel = conv2FirstCharLowerCase(propName); 
     892                                                        publicField = pubFieldMap.get(propName4LowerCamel); 
     893 
     894                                                        _logger4jsToJavaBean.trace("propName4LowerCamel: {}", propName4LowerCamel); 
    644895                                                } 
    645                                                 propDescriptor = map.get(propName4LowerCamel); 
     896                                                 
     897                                                if(publicField != null){ 
     898                                                        Class<?> propType = publicField.getType(); 
     899         
     900                                                        // ********* 再帰 ********* 
     901                                                        Object javaValue = jsToJavaBean(propValue, propType); 
     902                                                        _logger4jsToJavaBean.trace("javaValue: {}", javaValue); 
     903                 
     904                                                        try{ 
     905                                                                // JavaBeanに値を設定(javaValueが) 
     906                                                                publicField.set(returnObj, javaValue); 
     907                                                                continue; 
     908                                                        } 
     909                                                        catch(Exception e){ 
     910                                                                String msg = "Cannot convert '" + propValue + "' into <" + propType.getName() + ">." +  
     911                                                                                         " (beanType: " + beanType.getName() + ", property: "+ propName +")";  
     912                                                                throw new IllegalConversionException(msg, e); 
     913                                                        } 
     914                                                } 
     915                                        } 
     916                                         
     917                                        // JavaBeanのプロパティ 
     918                                        Map<String, PropertyDescriptor> beanPropMap = getBeanPropertyMap(beanType); 
     919                                        if(beanPropMap != null){ 
     920                                                _logger4jsToJavaBean.trace("---- JavaBean ----"); 
     921                                                PropertyDescriptor propDescriptor = beanPropMap.get(propName); 
    646922                                                 
    647923                                                if(propDescriptor == null){ 
    648                                                         // JSには存在するが、Beanには存在しないプロパティの場合 
    649                                                         continue; 
     924                                                        // プロパティ名がPascal形式の場合(.Net対応) 
     925                                                        String propName4LowerCamel = conv2FirstCharLowerCase(propName); 
     926                                                        _logger4jsToJavaBean.trace("propName4LowerCamel: {}", propName4LowerCamel); 
     927 
     928                                                        propDescriptor = beanPropMap.get(propName4LowerCamel); 
     929                                                        if(propDescriptor == null){ 
     930                                                                // JSには存在するが、Beanには存在しないプロパティの場合 
     931                                                                _logger4jsToJavaBean.trace("Property '{}': Exist on JS. But, Not exist on JavaBean.", propName4LowerCamel); 
     932                                                                continue; 
     933                                                        } 
     934                                                } 
     935                                                 
     936                                                Method writeMethod = propDescriptor.getWriteMethod(); 
     937         
     938                                                // WriteMethodのパラメータが複数あった場合は考慮しない。 
     939                                                // ちなみに、パラメータが0個ということはありえない(∵Setterだから) 
     940                                                Class<?>[] parameterTypes = writeMethod.getParameterTypes(); 
     941                                                _logger4jsToJavaBean.trace("parameterTypes: {}", (Object[])parameterTypes); 
     942                                                 
     943                                                Class<?> propType = parameterTypes[0]; 
     944                                                _logger4jsToJavaBean.trace("propType: {}", propType); 
     945                                                 
     946                                                // ********* 再帰 ********* 
     947                                                Object javaValue = jsToJavaBean(propValue, propType); 
     948                                                _logger4jsToJavaBean.trace("javaValue: {}", javaValue); 
     949 
     950                                                try{ 
     951                                                        // JavaBeanに値を設定(javaValueが) 
     952                                                        Object[] args = { javaValue }; 
     953                                                        writeMethod.invoke(returnObj, args); 
     954                                                } 
     955                                                catch(Exception e){ 
     956                                                        String msg = "Cannot convert '" + propValue + "' into <" + propType.getName() + ">." +  
     957                                                                                 " (beanType: " + beanType.getName() + ", property: "+ propName +")";  
     958                                                        throw new IllegalConversionException(msg, e); 
    650959                                                } 
    651960                                        } 
    652                                          
    653                                         Method writeMethod = propDescriptor.getWriteMethod(); 
    654  
    655                                         // JSオブジェクトよりプロパティ値を取得 
    656                                         Object propValue = scriptable.get(propName, scriptable); 
    657                                          
    658                                         // WriteMethodのパラメータが複数あった場合は考慮しない。 
    659                                         // ちなみに、パラメータが0個ということはありえない(∵Setterだから) 
    660                                         Class<?>[] parameterTypes = writeMethod.getParameterTypes(); 
    661                                         Class<?> propType = parameterTypes[0]; 
    662                                          
    663                                         // ********* 再帰 ********* 
    664                                         Object javaValue = jsToJavaBean(propValue, propType); 
    665  
    666                                         try{ 
    667                                                 // JavaBeanに値を設定(javaValueが) 
    668                                                 Object[] args = { javaValue }; 
    669                                                 writeMethod.invoke(returnObj, args); 
    670                                         } 
    671                                         catch(Exception e){ 
    672                                                 String msg = "Cannot convert '" + propValue + "' into <" + propType.getName() + ">." +  
    673                                                                          " (beanType: " + beanType.getName() + ", property: "+ propName +")";  
    674                                                 throw new IllegalConversionException(msg, e); 
    675                                         } 
    676  
    677961                                } 
    678962                                else if(id instanceof Number){ 
    679963                                        // 【対象外】JSオブジェクトのプロパティ名が数値の場合 
    680964                                         
    681                                         if(_logger.isTraceEnabled()){ 
    682                                                 _logger.trace("==== jsToJavaBean(Object, Class<?>) : js property id is Number. ===="); 
    683                                                 _logger.trace("scriptable[{}] => {}", id, scriptable.get(((Number)id).intValue(), scriptable)); 
     965                                        if(_logger4jsToJavaBean.isTraceEnabled()){ 
     966                                                _logger4jsToJavaBean.trace("==== jsToJavaBean(Object, Class<?>) : js property id is Number. ===="); 
     967                                                _logger4jsToJavaBean.trace("scriptable[{}] => {}", id, scriptable.get(((Number)id).intValue(), scriptable)); 
    684968                                        } 
    685969                                } 
    686970                        } 
    687                          
     971                        _logger4jsToJavaBean.trace("---- Scriptable (End) ----"); 
     972                         
     973                        _logger4jsToJavaBean.trace("returnObj: {}", returnObj); 
    688974                        return returnObj; 
    689975                } 
     
    691977                // Undefined は nullに変換 
    692978                else if(jsObject instanceof Undefined){ 
     979                        _logger4jsToJavaBean.trace("========== Undefined =========="); 
    693980                        return null; 
    694981                } 
     
    696983                // 上記以外は変換対象外 → nullを返却 
    697984                else{ 
     985                        _logger4jsToJavaBean.trace("========== NOT TARGET =========="); 
    698986                        return null; 
    699987                } 
     988        } 
     989         
     990        /** 
     991         * 引数で与えられた文字列の先頭一文字を小文字に変換して返却します。 
     992         * @param value 変換対象文字列 
     993         * @return 先頭の文字を小文字に変換した文字列。 
     994         */ 
     995        private static String conv2FirstCharLowerCase(final String value) { 
     996                String lowered = value.substring(0, 1).toLowerCase(); 
     997                if(value.length() > 1){ 
     998                        lowered = lowered.concat(value.substring(1)); 
     999                } 
     1000                return lowered; 
    7001001        } 
    7011002         
     
    8161117         * <a href="http://java.sun.com/j2se/1.5.0/ja/docs/ja/guide/beans/index.html">JavaBean</a>クラスのプロパティ情報を取得します。<br/> 
    8171118         * 引数で指定されたクラスのプロパティに関する情報を格納したMapを返却します。 
    818          * 返却されるMapの形式は、キーにプロパティ名、値に{@link PropertyDescriptor} です。<br/> 
    819          *  
    820          * 指定されたクラスに、GetterとSetterが両方あるプロパティが一つも無かった場合、IllegalArgumentExceptionがスローされます。 
     1119         * 返却されるMapの形式は、キーが「プロパティ名」、値が「{@link PropertyDescriptor}」 の形式です。<br/> 
     1120         *  
     1121         * 指定されたクラスに、GetterとSetterが両方あるプロパティが一つも無かった場合、nullを返却します。 
    8211122         *  
    8221123         * @param beanClass JavaBeanクラス 
    823          * @return プロパティ情報を格納したMap。(Mapの形式は、キーに「プロパティ名」、値に「{@link PropertyDescriptor}」) 
     1124         * @return プロパティ情報を格納したMap。(Mapの形式は、キーが「プロパティ名」、値が「{@link PropertyDescriptor}」の形式) 
    8241125         * @throws IntrospectionException イントロスペクション中に例外が発生した場合 
    825          * @throws IllegalArgumentException GetterとSetterが両方あるプロパティが一つも無かった場合 
    8261126         */ 
    8271127        public static Map<String, PropertyDescriptor> getBeanPropertyMap(final Class<?> beanClass)  
    828                                                                                                                 throws IntrospectionException, IllegalArgumentException
     1128                                                                                                                throws IntrospectionException
    8291129                 
    8301130                if(BEAN_PROP_INFO_MAP.get(beanClass) == null){ 
     
    8381138                                        PropertyDescriptor[] propDiscriptorList = info.getPropertyDescriptors(); 
    8391139                                         
     1140                                        _logger.trace("---- propDiscriptorList (Start) ----"); 
    8401141                                        for(PropertyDescriptor propDiscriptor : propDiscriptorList){ 
     1142                                                _logger.trace("propDiscriptor: {}", propDiscriptor); 
     1143                                                 
    8411144                                                // Getter/Setterが両方あること。(それ以外はこのメソッドではプロパティとみなさない) 
    8421145                                                if(propDiscriptor.getReadMethod() != null  
     
    8441147                                                   propDiscriptor.getWriteMethod() != null 
    8451148                                                ){ 
    846                                                         map.put(propDiscriptor.getName(), propDiscriptor); 
     1149                                                        String propName = propDiscriptor.getName(); 
     1150                                                        map.put(propName, propDiscriptor); 
     1151                                                        _logger.trace("propName: {}", propName); 
    8471152                                                } 
    8481153                                        } 
    849                                          
    850                                         if(map.size() == 0){ 
    851                                                String msg = "TargetType '" + beanClass.getName() + "' must have one or more properties with getter & setter."; 
    852                                                 throw new IllegalArgumentException(msg); 
     1154                                        _logger.trace("---- propDiscriptorList (End) ----"); 
     1155                                         
     1156                                        if(!map.isEmpty()){ 
     1157                                                BEAN_PROP_INFO_MAP.put(beanClass, map); 
    8531158                                        } 
    854                                          
    855                                         BEAN_PROP_INFO_MAP.put(beanClass, map); 
    8561159                                } 
    8571160                        } 
     
    8641167        private static Map<Class<?>, Map<String, PropertyDescriptor>> BEAN_PROP_INFO_MAP = new WeakHashMap<Class<?>, Map<String, PropertyDescriptor>>(); 
    8651168        private static Object BEAN_PROP_INFO_MONITOR = new Object(); 
     1169 
     1170         
     1171         
     1172        /** 
     1173         * 引数で指定されたクラスのPublicフィールドに関する情報を格納したMapを返却します。 
     1174         * 返却されるMapの形式は、キーにPublicフィールド名、値に{@link Field} です。<br/> 
     1175         *  
     1176         * Publicフィールドが存在しないクラスの場合、nullを返却します。 
     1177         *  
     1178         * @param clazz 対象クラス 
     1179         * @return Publicフィールドに関する情報を格納したMap。(Mapの形式は、キーが「Publicフィールド名」、値が「{@link Field}」の形式)<br/> 
     1180         *                      Publicフィールドが存在しないクラスの場合、nullを返却します。 
     1181         */ 
     1182        public static Map<String, Field> getPublicFieldMap(final Class<?> clazz){ 
     1183                 
     1184                if(PUBLIC_FIELD_INFO_MAP.get(clazz) == null){ 
     1185                        synchronized(PUBLIC_FIELD_INFO_MONITOR){ 
     1186                                if(PUBLIC_FIELD_INFO_MAP.get(clazz) == null){ 
     1187                                         
     1188                                        // クラスのPublicフィールドに関するMapを作成(key = propName, value = Field) 
     1189                                        Map<String, Field> map = new WeakHashMap<String, Field>(); 
     1190                                         
     1191                                        Field[] fields = clazz.getFields(); 
     1192                                         
     1193                                        _logger.trace("---- fields (Start) ----"); 
     1194                                        for(Field f : fields){ 
     1195                                                _logger.trace("f: {}", f); 
     1196                                                 
     1197                                                // finalではないフィールドを追加 
     1198                                                if(Modifier.isFinal(f.getModifiers()) == false){ 
     1199                                                        String fieldName = f.getName(); 
     1200                                                        map.put(fieldName, f); 
     1201                                                        _logger.trace("fieldName: {}", fieldName); 
     1202                                                } 
     1203                                        } 
     1204                                        _logger.trace("---- fields (End) ----"); 
     1205 
     1206                                        if(!map.isEmpty()){ 
     1207                                                PUBLIC_FIELD_INFO_MAP.put(clazz, map); 
     1208                                        } 
     1209                                } 
     1210                        } 
     1211                } 
     1212                return PUBLIC_FIELD_INFO_MAP.get(clazz); 
     1213        } 
     1214 
     1215        // クラスのPublicフィールドに関するMapを格納するMap(上記の#getPublicFieldMap()経由で取得すること) 
     1216        private static Map<Class<?>, Map<String, Field>> PUBLIC_FIELD_INFO_MAP = new WeakHashMap<Class<?>, Map<String, Field>>(); 
     1217        private static Object PUBLIC_FIELD_INFO_MONITOR = new Object(); 
     1218         
    8661219         
    8671220        /** 
     
    8771230         * @return 指定されたクラスのサンプルデータ設定済みインスタンス 
    8781231         *  
    879          * @throws IllegalArgumentException サンプルデータ生成対象外のクラスが指定された場合 
    8801232         * @throws IntrospectionException イントロスペクション中に例外が発生した場合 
    8811233         * @throws IllegalAccessException 指定されたクラス、またはその無引数コンストラクタにアクセスできない場合。または、JavaBeanプロパティのSetterメソッドにアクセスできない場合 
    8821234         * @throws InvocationTargetException JavaBeanのSetterが例外をスローする場合 
    883          * @throws InstantiationException  指定されたクラスが、抽象クラス、インタフェース、配列クラス、プリミティブ型、または void を表す場合。または、指定されたクラスが無引数コンストラクタを保持しない場合、あるいはインスタンスの生成がほかの理由で失敗した場合 
    8841235         * @throws ClassNotFoundException 指定されたクラスが見つからなかった場合  
    8851236         *  
     
    8881239        public static Object newInstanceFilledSampleData(final String beanClassName,  
    8891240                                                                                                   final String sampleValue)  
    890                                                         throws IllegalArgumentException, IntrospectionException, 
     1241                                                        throws IntrospectionException, 
    8911242                                                                   IllegalAccessException, InvocationTargetException,  
    892                                                                    InstantiationException, ClassNotFoundException{ 
     1243                                                                   ClassNotFoundException{ 
    8931244                return newInstanceFilledSampleData(beanClassName, Thread.currentThread().getContextClassLoader(), sampleValue); 
    8941245        } 
     
    9071258         * @return 指定されたクラスのサンプルデータ設定済みインスタンス 
    9081259         *  
    909          * @throws IllegalArgumentException サンプルデータ生成対象外のクラスが指定された場合 
    9101260         * @throws IntrospectionException イントロスペクション中に例外が発生した場合 
    9111261         * @throws IllegalAccessException 指定されたクラス、またはその無引数コンストラクタにアクセスできない場合。または、JavaBeanプロパティのSetterメソッドにアクセスできない場合 
    9121262         * @throws InvocationTargetException JavaBeanのSetterが例外をスローする場合 
    913          * @throws InstantiationException  指定されたクラスが、抽象クラス、インタフェース、配列クラス、プリミティブ型、または void を表す場合。または、指定されたクラスが無引数コンストラクタを保持しない場合、あるいはインスタンスの生成がほかの理由で失敗した場合 
    9141263         * @throws ClassNotFoundException 指定されたクラスが見つからなかった場合  
    9151264         *  
     
    9191268                                                                                                   final ClassLoader classLoader,  
    9201269                                                                                                   final String sampleValue)  
    921                                                         throws IllegalArgumentException, IntrospectionException, 
     1270                                                        throws IntrospectionException, 
    9221271                                                                   IllegalAccessException, InvocationTargetException,  
    923                                                                    InstantiationException, ClassNotFoundException{ 
     1272                                                                   ClassNotFoundException{ 
    9241273                 
    9251274                if(beanClassName.equals("char")) { 
     
    10521401         * <br/> 
    10531402         * 上記以外のクラスはサンプルデータ生成対象外です。(例えば、List, Map, Setは対象外です。)<br/> 
    1054          * サンプルデータ生成対象外のクラスが指定された場合は、IllegalArgumentException をスローします。<br/> 
     1403         * サンプルデータ生成対象外のクラスが指定された場合は、サンプルデータの設定を行いません。<br/> 
    10551404         *  
    10561405         * <h3>例</h3> 
     
    11161465         * @return 指定されたクラスのサンプルデータ設定済みインスタンス 
    11171466         *  
    1118          * @throws IllegalArgumentException サンプルデータ生成対象外のクラスが指定された場合 
    11191467         * @throws IntrospectionException イントロスペクション中に例外が発生した場合 
    11201468         * @throws IllegalAccessException 指定されたクラス、またはその無引数コンストラクタにアクセスできない場合。または、JavaBeanプロパティのSetterメソッドにアクセスできない場合 
    11211469         * @throws InvocationTargetException JavaBeanのSetterが例外をスローする場合 
    1122          * @throws InstantiationException  指定されたクラスが、抽象クラス、インタフェース、配列クラス、プリミティブ型、または void を表す場合。または、指定されたクラスが無引数コンストラクタを保持しない場合、あるいはインスタンスの生成がほかの理由で失敗した場合 
    11231470         *  
    11241471         * @see #initializeSampleData(String, Number, Boolean, Date, int) 
     
    11261473        public static Object newInstanceFilledSampleData(final Class<?> beanType,  
    11271474                                                                                                         final String sampleValue)  
    1128                                                         throws IllegalArgumentException, IntrospectionException,  
    1129                                                                    IllegalAccessException, InvocationTargetException,  
    1130                                                                    InstantiationException{ 
     1475                                                        throws IntrospectionException,  
     1476                                                                   IllegalAccessException, InvocationTargetException { 
    11311477                 
    11321478                try{ 
     
    11401486        } 
    11411487         
     1488        private static List<Class<?>> excludeClassList4newInstanceFilledSampleData = new ArrayList<Class<?>>(); 
     1489 
     1490        /** 
     1491         * {@link #newInstanceFilledSampleData(Class, String)}等のメソッドで、 
     1492         * サンプルデータ設定済みインスタンスの生成を行わないようするクラスを追加します。 
     1493         *  
     1494         * @param excludeClassList4newInstanceFilledSampleData サンプルデータ設定済みインスタンスの生成を行わないようするクラス 
     1495         * @see {@link JavaScriptUtility#newInstanceFilledSampleData(Class, String)} 
     1496         * @see {@link JavaScriptUtility#newInstanceFilledSampleData(String, String)} 
     1497         * @see {@link JavaScriptUtility#newInstanceFilledSampleData(String, ClassLoader, String)} 
     1498         */ 
     1499        public static void addExcludeClass4newInstanceFilledSampleData(Class<?> excludeConvertClass) { 
     1500                JavaScriptUtility.excludeClassList4newInstanceFilledSampleData.add(excludeConvertClass); 
     1501                _logger.debug("excludeConvertClassList: {}", excludeClassList4newInstanceFilledSampleData); 
     1502        } 
     1503         
     1504 
    11421505        private static ThreadLocal<List<Class<?>>> threadLocal4newInstanceFilledSampleData = new ThreadLocal<List<Class<?>>>(); 
    11431506 
     
    11511514                                                                                                          final String sampleValue, 
    11521515                                                                                                          final boolean isLast)  
    1153                                                         throws IntrospectionException, IllegalArgumentException,  
    1154                                                                    IllegalAccessException, InvocationTargetException, 
    1155                                                                    InstantiationException{ 
     1516                                                        throws IntrospectionException,   
     1517                                                                   IllegalAccessException, InvocationTargetException { 
    11561518                 
    11571519                _logger4newInstance.trace("------------"); 
     
    11611523                _logger4newInstance.trace("------------"); 
    11621524 
     1525                // =================== 
     1526                // 変換対象外の場合はnullを返却。(設定する値の形式が決まっているクラスは変換対象外とすることを想定) 
     1527                // 例:org.apache.axis2.databinding.types.URI#setQueryString() 
     1528                // =================== 
     1529                if(excludeClassList4newInstanceFilledSampleData.contains(beanType)){ 
     1530                        return null; 
     1531                } 
     1532                 
    11631533                Object beanInstance = generatePrimitiveOrWrapperInstance(beanType, sampleValue); 
    11641534 
     
    11741544                _logger4newInstance.trace("[execute] setScannedClass(): {}", beanType); 
    11751545 
    1176                 beanInstance = beanType.newInstance(); 
    1177                  
    1178                 Map<String, PropertyDescriptor> map = getBeanPropertyMap(beanType); 
    1179                 Iterator<Map.Entry<String, PropertyDescriptor>> it = map.entrySet().iterator(); 
    1180                  
    11811546                _logger4newInstance.trace("↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓"); 
    1182                 while(it.hasNext()){ 
    1183                         Map.Entry<String, PropertyDescriptor> entry = it.next(); 
    1184                         PropertyDescriptor propDescriptor = entry.getValue(); 
    1185  
    1186                         Method setter = propDescriptor.getWriteMethod(); 
    1187                         if(setter == null){ 
    1188                                 continue; 
    1189                         } 
    1190  
    1191                         _logger4newInstance.trace("========================="); 
    1192                         Class<?> propType = propDescriptor.getPropertyType(); 
    1193                         String propName = propDescriptor.getName(); 
    1194                         String newSampleValue = "prop_" + propName; 
    1195                          
    1196                         _logger4newInstance.trace("----"); 
    1197                         _logger4newInstance.trace("propName: {}", propName); 
    1198                         _logger4newInstance.trace("newsampleValue: {}", newSampleValue); 
    1199                         _logger4newInstance.trace("----"); 
    1200                         _logger4newInstance.trace("isLast: {}", isLast); 
    1201                         _logger4newInstance.trace("beanType: {}", beanType); 
    1202                         _logger4newInstance.trace("propType: {}", propType); 
    1203                          
    1204                         Object data; 
    1205                          
    1206                         // 通常のオブジェクトの場合 
    1207                         if(!propType.isArray()){ 
    1208                                 boolean isRecursive = isRecursive(isLast, beanType, propType); 
    1209                                 _logger4newInstance.trace("--OBJECT-- isRecursive: {}", isRecursive); 
     1547 
     1548                try { 
     1549                        beanInstance = beanType.newInstance(); 
     1550                } 
     1551                catch (InstantiationException e) { 
     1552                        _logger4newInstance.trace("interface or Abstract class", e); 
     1553                        return generatePrimitiveOrWrapperInstance(String.class, beanType.getName()); 
     1554                } 
     1555 
     1556                // Publicフィールド 
     1557                Map<String, Field> pubFieldMap = getPublicFieldMap(beanType); 
     1558                if(pubFieldMap != null){ 
     1559                         
     1560                        Iterator<Map.Entry<String, Field>> it = pubFieldMap.entrySet().iterator(); 
     1561                        while(it.hasNext()){ 
     1562                                Map.Entry<String, Field> entry = it.next(); 
    12101563                                 
    1211                                 if(isRecursive){ 
     1564                                String propName = entry.getKey(); 
     1565                                Field field     = entry.getValue(); 
     1566                                Class<?> propType = field.getType(); 
     1567                                String newSampleValue = "prop_" + propName; 
     1568                                 
     1569                                _logger4newInstance.trace("========================="); 
     1570                                _logger4newInstance.trace("----"); 
     1571                                _logger4newInstance.trace("propName: {}", propName); 
     1572                                _logger4newInstance.trace("newsampleValue: {}", newSampleValue); 
     1573                                _logger4newInstance.trace("----"); 
     1574                                _logger4newInstance.trace("isLast: {}", isLast); 
     1575                                _logger4newInstance.trace("beanType: {}", beanType); 
     1576                                _logger4newInstance.trace("propType: {}", propType); 
     1577 
     1578                                // 再帰チェック 
     1579                                Object data = newInstanceFilledSampleDataRecursive(beanType, isLast, propType, newSampleValue); 
     1580                                 
     1581                                try{ 
     1582                                        field.set(beanInstance, data); 
     1583                                } 
     1584                                catch (Exception e) { 
     1585                                        // プロパティ値を設定せずに、処理続行! 
     1586                                        // XMLスキーマの「restriction」や引数ミスマッチ発生時を想定 (∵interface or Abstractの場合のサンプルデータは、その型名(=String)であるため) 
     1587                                        _logger4newInstance.trace("[Case of Public Field] " + e.getMessage(), e); 
     1588                                } 
     1589                                         
     1590                                _logger4newInstance.trace("========================="); 
     1591                                 
     1592                        } 
     1593                } 
     1594 
     1595                // JavaBeanの場合 
     1596                Map<String, PropertyDescriptor> beanPropMap = getBeanPropertyMap(beanType); 
     1597                if(beanPropMap != null){ 
     1598                        Iterator<Map.Entry<String, PropertyDescriptor>> it = beanPropMap.entrySet().iterator(); 
     1599                         
     1600                        while(it.hasNext()){ 
     1601                                Map.Entry<String, PropertyDescriptor> entry = it.next(); 
     1602                                PropertyDescriptor propDescriptor = entry.getValue(); 
     1603         
     1604                                Method setter = propDescriptor.getWriteMethod(); 
     1605                                if(setter == null){ 
     1606                                        continue; 
     1607                                } 
     1608         
     1609                                _logger4newInstance.trace("========================="); 
     1610                                Class<?> propType = propDescriptor.getPropertyType(); 
     1611                                String propName = propDescriptor.getName(); 
     1612                                String newSampleValue = "prop_" + propName; 
     1613                                 
     1614                                _logger4newInstance.trace("----"); 
     1615                                _logger4newInstance.trace("propName: {}", propName); 
     1616                                _logger4newInstance.trace("newsampleValue: {}", newSampleValue); 
     1617                                _logger4newInstance.trace("----"); 
     1618                                _logger4newInstance.trace("isLast: {}", isLast); 
     1619                                _logger4newInstance.trace("beanType: {}", beanType); 
     1620                                _logger4newInstance.trace("propType: {}", propType); 
     1621                                 
     1622                                // 再帰チェック 
     1623                                Object data = newInstanceFilledSampleDataRecursive(beanType, isLast, propType, newSampleValue); 
     1624                                 
     1625                                try { 
     1626                                        setter.invoke(beanInstance, data); 
     1627                                } 
     1628                                catch (Exception e) { 
     1629                                        // プロパティ値を設定せずに、処理続行! 
     1630                                        // XMLスキーマの「restriction」や引数ミスマッチ発生時を想定 (∵interface or Abstractの場合のサンプルデータは、その型名(=String)であるため) 
     1631                                        _logger4newInstance.trace("[Case of JavaBean] " + e.getMessage(), e); 
     1632                                } 
     1633                                 
     1634                                _logger4newInstance.trace("========================="); 
     1635                                 
     1636                        } 
     1637                } 
     1638                _logger4newInstance.trace("↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑"); 
     1639 
     1640                return beanInstance; 
     1641        } 
     1642 
     1643        /** 
     1644         * @param beanType 
     1645         * @param isLast 
     1646         * @param propType 
     1647         * @param newSampleValue 
     1648         * @return 
     1649         * @throws IntrospectionException 
     1650         * @throws IllegalAccessException 
     1651         * @throws InvocationTargetException 
     1652         */ 
     1653        private static Object newInstanceFilledSampleDataRecursive( 
     1654                                                                                                final Class<?> beanType,  
     1655                                                                                                final boolean isLast, 
     1656                                                                                                final Class<?> propType, 
     1657                                                                                                final String newSampleValue) 
     1658         
     1659                                                        throws IntrospectionException, IllegalAccessException,  
     1660                                                                   InvocationTargetException { 
     1661 
     1662                Object data; 
     1663                 
     1664                // 通常のオブジェクトの場合 
     1665                if(!propType.isArray()){ 
     1666                        boolean isRecursive = isRecursive(isLast, beanType, propType); 
     1667                        _logger4newInstance.trace("--OBJECT-- isRecursive: {}", isRecursive); 
     1668                         
     1669                        if(isRecursive){ 
     1670                                // 再帰 
     1671                                _logger4newInstance.trace("--OBJECT-- [RECURSIVE] newInstanceFilledSampleData()"); 
     1672                                data = newInstanceFilledSampleData(propType, newSampleValue, isLast); 
     1673                        } 
     1674                        else{ 
     1675                                _logger4newInstance.trace("--OBJECT-- [execute] generatePrimitiveOrWrapperInstance()"); 
     1676                                data = generatePrimitiveOrWrapperInstance(propType, newSampleValue); 
     1677                        } 
     1678                } 
     1679                 
     1680                // 配列の場合 
     1681                else{ 
     1682                        Class<?> componentType = propType.getComponentType(); 
     1683 
     1684                        boolean isRecursive = isRecursive(isLast, beanType, componentType); 
     1685                         
     1686                        _logger4newInstance.trace("--ARRAY-- componentType: {}", componentType); 
     1687                        _logger4newInstance.trace("--ARRAY-- isRecursive: {}", isRecursive); 
     1688 
     1689                        if(isRecursive){ 
     1690                                data = Array.newInstance(componentType, SAMPLE_DATA_ARRAY_LENGTH); 
     1691                                for(int idx = 0; idx < SAMPLE_DATA_ARRAY_LENGTH; idx++){ 
    12121692                                        // 再帰 
    1213                                         _logger4newInstance.trace("--OBJECT-- [RECURSIVE] newInstanceFilledSampleData()"); 
    1214                                         data = newInstanceFilledSampleData(propType, newSampleValue, isLast); 
     1693                                        _logger4newInstance.trace("--ARRAY-- [RECURSIVE] newInstanceFilledSampleData()"); 
     1694                                        Object dataElem = newInstanceFilledSampleData(componentType, newSampleValue, isLast); 
     1695                                        Array.set(data, idx, dataElem); 
    12151696                                } 
    1216                                 else{ 
    1217                                         _logger4newInstance.trace("--OBJECT-- [execute] generatePrimitiveOrWrapperInstance()"); 
    1218                                         data = generatePrimitiveOrWrapperInstance(propType, newSampleValue); 
    1219                                 } 
    1220                         } 
    1221                          
    1222                         // 配列の場合 
    1223                         else{ 
    1224                                 Class<?> componentType = propType.getComponentType(); 
    1225  
    1226                                 boolean isRecursive = isRecursive(isLast, beanType, componentType); 
    1227                                  
    1228                                 _logger4newInstance.trace("--ARRAY-- componentType: {}", componentType); 
    1229                                 _logger4newInstance.trace("--ARRAY-- isRecursive: {}", isRecursive); 
    1230  
    1231                                 if(isRecursive){ 
    1232                                         data = Array.newInstance(componentType, SAMPLE_DATA_ARRAY_LENGTH); 
    1233                                         for(int idx = 0; idx < SAMPLE_DATA_ARRAY_LENGTH; idx++){ 
    1234                                                 // 再帰 
    1235                                                 _logger4newInstance.trace("--ARRAY-- [RECURSIVE] newInstanceFilledSampleData()"); 
    1236                                                 Object dataElem = newInstanceFilledSampleData(componentType, newSampleValue, isLast); 
    1237                                                 Array.set(data, idx, dataElem); 
    1238                                         } 
    1239                                 } 
    1240                                 else { 
    1241                                         _logger4newInstance.trace("--ARRAY-- [execute] generateEmptyArray()"); 
    1242                                         data = Array.newInstance(componentType, 0); // 空の配列 
    1243                                 } 
    1244                         } 
    1245                          
    1246                         setter.invoke(beanInstance, data); 
    1247                         _logger4newInstance.trace("========================="); 
    1248                          
    1249                 } 
    1250                 _logger4newInstance.trace("↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑"); 
    1251  
    1252                 return beanInstance; 
     1697                        } 
     1698                        else { 
     1699                                _logger4newInstance.trace("--ARRAY-- [execute] generateEmptyArray()"); 
     1700                                data = Array.newInstance(componentType, 0); // 空の配列 
     1701                        } 
     1702                } 
     1703                return data; 
    12531704        } 
    12541705 
     
    13831834                 
    13841835                // =================== 
    1385                 // 上記以外 (≒ Primitive型、または、Wrapperクラスではない場合) 
     1836                // java.lang.Object 
     1837                // =================== 
     1838                else if(type.equals(java.lang.Object.class)){ 
     1839                        return def; 
     1840                } 
     1841                 
     1842                // =================== 
     1843                // 上記以外 (≒ Primitive型、Wrapperクラス、および、java.lang.Objectクラスではない場合) 
    13861844                // =================== 
    13871845                else{ 
     
    14651923        } 
    14661924         
    1467  
    14681925} 
  • trunk/im-jssp/src/main/java/org/intra_mart/jssp/util/ValueObject.java

    r4 r302  
    66import java.util.logging.Level; 
    77 
     8import org.mozilla.javascript.ScriptRuntime; 
     9import org.mozilla.javascript.Scriptable; 
    810import org.mozilla.javascript.ScriptableObject; 
    911 
     
    1921                // 基本メソッドの登録 
    2022                try{ 
    21                         String[] names = {"toString","valueOf"}; 
     23                        String[] names = {"toString","valueOf","hasOwnProperty"}; 
    2224                        this.defineFunctionProperties(names, ValueObject.class, ScriptableObject.DONTENUM); 
    2325                } 
     
    5355        } 
    5456 
     57        private String className = "anonymous-Object"; 
    5558 
    5659        /** 
     
    5962         */ 
    6063        public String getClassName() { 
    61                 return "anonymous-Object"; 
     64                return this.className; 
     65        } 
     66 
     67        /** 
     68         * JavaScript 実行環境上での名称を設定します。 
     69         * @param classNameJavaScript 実行環境上での名称 
     70         */ 
     71        public void setClassName(String className) { 
     72                this.className = className; 
    6273        } 
    6374 
     
    7788                return Double.NaN; 
    7889        } 
     90         
     91        /** 
     92         * 指定した名前のプロパティがオブジェクトにあるかどうかを表す真偽値値を返します 
     93         * @param scriptable 
     94         * @return 指定した名前のプロパティがオブジェクトにある場合は true、それ以外は false。 
     95         */ 
     96        public boolean hasOwnProperty(Scriptable scriptable){ 
     97        String property = ScriptRuntime.toString(scriptable); 
     98        if (this.has(property, this)){ 
     99            return true; 
     100        } 
     101        else{ 
     102                return false; 
     103        } 
     104        }         
    79105} 
  • trunk/im-jssp/src/test/java/org/intra_mart/jssp/util/JavaScriptUtilityTest.java

    r299 r302  
    66import java.io.Reader; 
    77import java.lang.reflect.Array; 
     8import java.lang.reflect.Field; 
    89import java.util.ArrayList; 
    910import java.util.Calendar; 
     
    2930import org.mozilla.javascript.Undefined; 
    3031 
     32 
    3133public class JavaScriptUtilityTest extends TestCase { 
    3234 
     
    268270        } 
    269271 
     272        public void testConvertJavaBeans2JsObject_javaLangObject() throws Exception { 
     273                Object value = new Object(); 
     274                Object actual = JavaScriptUtility.javaBeanToJS(value); 
     275 
     276                assertEquals(Object.class, actual.getClass()); 
     277                assertEquals("そのままが返却されること", value, actual); 
     278        } 
     279 
     280        public void testConvertJavaBeans2JsObject_BeanのプロパティがjavaLangObject() throws Exception { 
     281                Object expected = new Object(); 
     282                 
     283                JavaScriptUtilityTestModelA value = new JavaScriptUtilityTestModelA(); 
     284                value.setPlainObject(expected); 
     285                 
     286                Object actual = JavaScriptUtility.javaBeanToJS(value); 
     287 
     288                assertEquals(ValueObject.class, actual.getClass()); 
     289                ValueObject jsObject = (ValueObject)actual; 
     290                 
     291                assertEquals(Object.class, jsObject.get("plainObject", jsObject).getClass()); 
     292                assertEquals("そのままが返却されること", expected, jsObject.get("plainObject", jsObject)); 
     293        } 
    270294         
    271295        public void testConvertJavaBeans2JsObject_DateCalendar含むラッパークラスとプリミティブ型が定義されたJavaBeans() throws Exception { 
     
    323347                assertEquals((new Short("1011")).doubleValue(), ((NativeArray)jsObject.get("valuePrimitiveArrayShort", jsObject)).get(2, jsObject)); 
    324348 
    325                 assertEquals(NativeArray.class, jsObject.get("valuePrimitiveArrayByte", jsObject).getClass()); 
    326                 assertEquals(3, ((NativeArray)jsObject.get("valuePrimitiveArrayByte", jsObject)).getLength()); 
    327                 assertEquals((new Byte("123")).doubleValue(), ((NativeArray)jsObject.get("valuePrimitiveArrayByte", jsObject)).get(0, jsObject)); 
    328                 assertEquals((new Byte("124")).doubleValue(), ((NativeArray)jsObject.get("valuePrimitiveArrayByte", jsObject)).get(1, jsObject)); 
    329                 assertEquals((new Byte("125")).doubleValue(), ((NativeArray)jsObject.get("valuePrimitiveArrayByte", jsObject)).get(2, jsObject)); 
     349                // byte[]はStringに変換されます。 
     350                byte[] bytes = new byte[3]; 
     351                bytes[0] = 123; 
     352                bytes[1] = 124; 
     353                bytes[2] = 125; 
     354                assertEquals(String.class, jsObject.get("valuePrimitiveArrayByte", jsObject).getClass()); 
     355                assertEquals(new String(bytes, JavaScriptUtility.NON_CONVERT_CHARSET), jsObject.get("valuePrimitiveArrayByte", jsObject)); 
    330356                 
    331357                assertEquals(NativeArray.class, jsObject.get("valuePrimitiveArrayBoolean", jsObject).getClass()); 
     
    477503         
    478504        public void testConvertJavaBeans2JsObject_変換対象外なクラス_List() throws Exception { 
     505                Object actual; 
    479506                List value = new ArrayList(); 
     507                 
    480508                try { 
    481                         JavaScriptUtility.javaBeanToJS(value); 
     509                        actual = JavaScriptUtility.javaBeanToJS(value); 
    482510                } 
    483511                catch (IllegalArgumentException e) { 
    484                         assertTrue("IllegalArgumentException", true); 
    485                         assertEquals("TargetType 'java.util.ArrayList' must have one or more properties with getter & setter.", 
    486                                                 e.getMessage()); 
     512                        fail("IllegalArgumentExceptionは発生しません"); 
    487513                        return; 
    488514                } 
    489  
    490                 fail("IllegalArgumentExceptionが起こっていません。"); 
     515                 
     516                assertEquals(ValueObject.class, actual.getClass()); 
     517                ValueObject jsObj = (ValueObject) actual; 
     518                assertEquals(0, jsObj.getIds().length); 
    491519        } 
    492520         
    493521        public void testConvertJavaBeans2JsObject_変換対象外なクラス_Map() throws Exception { 
     522                Object actual; 
    494523                Map value = new HashMap();  
    495524                 
    496525                try { 
    497                         JavaScriptUtility.javaBeanToJS(value); 
     526                        actual = JavaScriptUtility.javaBeanToJS(value); 
    498527                } 
    499528                catch (IllegalArgumentException e) { 
    500                         assertTrue("IllegalArgumentException", true); 
    501                         assertEquals("TargetType 'java.util.HashMap' must have one or more properties with getter & setter.", 
    502                                                 e.getMessage()); 
     529                        fail("IllegalArgumentExceptionは発生しません"); 
    503530                        return; 
    504531                } 
    505532 
    506                 fail("IllegalArgumentExceptionが起こっていません。"); 
     533                assertEquals(ValueObject.class, actual.getClass()); 
     534                ValueObject jsObj = (ValueObject) actual; 
     535                assertEquals(0, jsObj.getIds().length); 
    507536        } 
    508537 
    509538        public void testConvertJavaBeans2JsObject_変換対象外なクラス_Set() throws Exception { 
     539                Object actual; 
    510540                Set value = new HashSet(); 
     541                 
    511542                try { 
    512                         JavaScriptUtility.javaBeanToJS(value); 
     543                        actual = JavaScriptUtility.javaBeanToJS(value); 
    513544                } 
    514545                catch (IllegalArgumentException e) { 
    515                         assertTrue("IllegalArgumentException", true); 
    516                         assertEquals("TargetType 'java.util.HashSet' must have one or more properties with getter & setter.", 
    517                                                 e.getMessage()); 
     546                        fail("IllegalArgumentExceptionは発生しません"); 
    518547                        return; 
    519548                } 
    520549 
    521                 fail("IllegalArgumentExceptionが起こっていません。"); 
     550                assertEquals(ValueObject.class, actual.getClass()); 
     551                ValueObject jsObj = (ValueObject) actual; 
     552                assertEquals(0, jsObj.getIds().length); 
    522553        } 
    523554 
     
    12981329                assertEquals(new Double(394.859), actualModel.getValueWrapperNumberModelA()); 
    12991330                assertEquals(new Date(1209612896000L), actualModel.getValueWrapperDateModelA());// Mon May 1 2008 12:34:56 GMT+0900 (JST) 
    1300         }       
     1331        } 
    13011332        public void testConvertJsObject2JavaBeansObjectClassOfQ_DateCalendar含むラッパークラスとプリミティブ型が定義されたJavaBeans() throws Exception { 
    13021333                 
     
    16971728                 
    16981729        public void testGetBeansPropertyMap_対象外_List() throws Exception { 
     1730                Object actual; 
    16991731                Class targetType = List.class; 
    17001732 
    17011733                try { 
    1702                         JavaScriptUtility.getBeanPropertyMap(targetType); 
     1734                        actual = JavaScriptUtility.getBeanPropertyMap(targetType); 
    17031735                } 
    17041736                catch (IllegalArgumentException e) { 
    1705                         assertTrue("IllegalArgumentException", true); 
    1706                         assertEquals("TargetType 'java.util.List' must have one or more properties with getter & setter.", 
    1707                                                 e.getMessage()); 
     1737                        fail("IllegalArgumentExceptionは発生しません"); 
    17081738                        return; 
    17091739                } 
    1710  
    1711                 fail("IllegalArgumentExceptionが起こっていません。"); 
     1740                 
     1741                assertNull(actual); 
    17121742        } 
    17131743         
    17141744        public void testGetBeansPropertyMap_対象外_Map() throws Exception { 
     1745                Object actual; 
    17151746                Class targetType = Map.class; 
    17161747                 
    17171748                try { 
    1718                         JavaScriptUtility.getBeanPropertyMap(targetType); 
     1749                        actual = JavaScriptUtility.getBeanPropertyMap(targetType); 
    17191750                } 
    17201751                catch (IllegalArgumentException e) { 
    1721                         assertTrue("IllegalArgumentException", true); 
    1722                         assertEquals("TargetType 'java.util.Map' must have one or more properties with getter & setter.", 
    1723                                                 e.getMessage()); 
     1752                        fail("IllegalArgumentExceptionは発生しません"); 
    17241753                        return; 
    17251754                } 
    17261755 
    1727                 fail("IllegalArgumentExceptionが起こっていません。"); 
     1756                assertNull(actual); 
    17281757        } 
    17291758 
    17301759        public void testGetBeansPropertyMap_対象外_Set() throws Exception { 
     1760                Object actual; 
    17311761                Class targetType = Set.class; 
    17321762 
    17331763                try { 
    1734                         JavaScriptUtility.getBeanPropertyMap(targetType); 
     1764                        actual = JavaScriptUtility.getBeanPropertyMap(targetType); 
    17351765                } 
    17361766                catch (IllegalArgumentException e) { 
    1737                         assertTrue("IllegalArgumentException", true); 
    1738                         assertEquals("TargetType 'java.util.Set' must have one or more properties with getter & setter.", 
    1739                                                 e.getMessage()); 
     1767                        fail("IllegalArgumentExceptionは発生しません"); 
    17401768                        return; 
    17411769                } 
    17421770 
    1743                 fail("IllegalArgumentExceptionが起こっていません。"); 
     1771                assertNull(actual); 
    17441772        } 
    17451773 
    17461774        public void testGetBeansPropertyMap_対象外_Object() throws Exception { 
     1775                Object actual; 
    17471776                Class targetType = Object.class; 
    17481777                 
    17491778                try { 
    1750                         JavaScriptUtility.getBeanPropertyMap(targetType); 
     1779                        actual = JavaScriptUtility.getBeanPropertyMap(targetType); 
    17511780                } 
    17521781                catch (IllegalArgumentException e) { 
    1753                         assertTrue("IllegalArgumentException", true); 
    1754                         assertEquals("TargetType 'java.lang.Object' must have one or more properties with getter & setter.", 
    1755                                                 e.getMessage()); 
     1782                        fail("IllegalArgumentExceptionは発生しません"); 
    17561783                        return; 
    17571784                } 
    17581785 
    1759                 fail("IllegalArgumentExceptionが起こっていません。"); 
     1786                assertNull(actual); 
    17601787        } 
    17611788 
     
    17641791                Map<String, PropertyDescriptor> actual = JavaScriptUtility.getBeanPropertyMap(beanType); 
    17651792 
    1766                 assertEquals(8, actual.size()); 
     1793                assertEquals(9, actual.size()); 
    17671794                assertNotNull(actual.get("modelA")); 
    17681795                assertNotNull(actual.get("modelArrayA")); 
     
    17721799                assertNotNull(actual.get("valueWrapperBooleanModelA")); 
    17731800                assertNotNull(actual.get("valueWrapperDateModelA")); 
     1801                assertNotNull(actual.get("plainObject")); 
    17741802        } 
    17751803         
     
    21972225                assertEquals(expected, actual); 
    21982226        } 
     2227 
     2228        public void testNewInstanceFilledPropertyStringString_javaLangObject() throws Exception { 
     2229                String beanClassName = Object.class.getName(); 
     2230                String defaultValue = null; 
     2231                Object actual = JavaScriptUtility.newInstanceFilledSampleData(beanClassName, defaultValue); 
     2232 
     2233                assertEquals("java.lang.Objectの場合は、サンプルデータの型がStringとなります", String.class, actual.getClass()); 
     2234                assertEquals("__default__", actual); 
     2235        } 
     2236 
     2237        public void testNewInstanceFilledPropertyStringString_javaLangObject_Calendar_initializeあり() throws Exception { 
     2238                String expected = new String("テストしています。"); 
     2239                JavaScriptUtility.initializeSampleData(expected, null, null, null, -1); 
     2240 
     2241                String beanClassName = Object.class.getName(); 
     2242                String defaultValue = null; 
     2243                Object actual = JavaScriptUtility.newInstanceFilledSampleData(beanClassName, defaultValue); 
     2244 
     2245                assertEquals("java.lang.Objectの場合は、サンプルデータの型がStringとなります", String.class, actual.getClass()); 
     2246                assertEquals(expected, actual); 
     2247        } 
     2248         
    21992249         
    22002250        public void testNewInstanceFilledPropertyStringClassLoaderString() throws Exception { 
     
    24042454        } 
    24052455 
     2456        public void testGetPublicFieldMap_Publicフィールド() throws Exception { 
     2457                 
     2458                Map<String, Field> pubFieldsMap = JavaScriptUtility.getPublicFieldMap(JavaScriptUtilityTestModel4PublicFields.class); 
     2459                 
     2460                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveChar"), pubFieldsMap.get("valuePrimitiveChar")); 
     2461                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveDouble"), pubFieldsMap.get("valuePrimitiveDouble")); 
     2462                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveFloat"), pubFieldsMap.get("valuePrimitiveFloat")); 
     2463                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveLong"), pubFieldsMap.get("valuePrimitiveLong")); 
     2464                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveInt"), pubFieldsMap.get("valuePrimitiveInt")); 
     2465                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveShort"), pubFieldsMap.get("valuePrimitiveShort")); 
     2466                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveByte"), pubFieldsMap.get("valuePrimitiveByte")); 
     2467                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveBoolean"), pubFieldsMap.get("valuePrimitiveBoolean")); 
     2468 
     2469                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveArrayChar"), pubFieldsMap.get("valuePrimitiveArrayChar")); 
     2470                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveArrayDouble"), pubFieldsMap.get("valuePrimitiveArrayDouble")); 
     2471                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveArrayFloat"), pubFieldsMap.get("valuePrimitiveArrayFloat")); 
     2472                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveArrayLong"), pubFieldsMap.get("valuePrimitiveArrayLong")); 
     2473                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveArrayInt"), pubFieldsMap.get("valuePrimitiveArrayInt")); 
     2474                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveArrayShort"), pubFieldsMap.get("valuePrimitiveArrayShort")); 
     2475                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveArrayByte"), pubFieldsMap.get("valuePrimitiveArrayByte")); 
     2476                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valuePrimitiveArrayBoolean"), pubFieldsMap.get("valuePrimitiveArrayBoolean")); 
     2477 
     2478                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperString"), pubFieldsMap.get("valueWrapperString")); 
     2479                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperCharacter"), pubFieldsMap.get("valueWrapperCharacter")); 
     2480                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperDouble"), pubFieldsMap.get("valueWrapperDouble")); 
     2481                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperDouble_MAX"), pubFieldsMap.get("valueWrapperDouble_MAX")); 
     2482                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperDouble_MIN"), pubFieldsMap.get("valueWrapperDouble_MIN")); 
     2483                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperDouble_NaN"), pubFieldsMap.get("valueWrapperDouble_NaN")); 
     2484                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperDouble_NEGA_INF"), pubFieldsMap.get("valueWrapperDouble_NEGA_INF")); 
     2485                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperDouble_POSI_INF"), pubFieldsMap.get("valueWrapperDouble_POSI_INF")); 
     2486                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperFloat"), pubFieldsMap.get("valueWrapperFloat")); 
     2487                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperLong"), pubFieldsMap.get("valueWrapperLong")); 
     2488                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperLong_MAX"), pubFieldsMap.get("valueWrapperLong_MAX")); 
     2489                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperLong_MIN"), pubFieldsMap.get("valueWrapperLong_MIN")); 
     2490                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperInteger"), pubFieldsMap.get("valueWrapperInteger")); 
     2491                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperShort"), pubFieldsMap.get("valueWrapperShort")); 
     2492                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperByte"), pubFieldsMap.get("valueWrapperByte")); 
     2493                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperBoolean"), pubFieldsMap.get("valueWrapperBoolean")); 
     2494 
     2495                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperArrayString"), pubFieldsMap.get("valueWrapperArrayString")); 
     2496                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperArrayCharacter"), pubFieldsMap.get("valueWrapperArrayCharacter")); 
     2497                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperArrayDouble"), pubFieldsMap.get("valueWrapperArrayDouble")); 
     2498                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperArrayFloat"), pubFieldsMap.get("valueWrapperArrayFloat")); 
     2499                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperArrayLong"), pubFieldsMap.get("valueWrapperArrayLong")); 
     2500                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperArrayInteger"), pubFieldsMap.get("valueWrapperArrayInteger")); 
     2501                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperArrayShort"), pubFieldsMap.get("valueWrapperArrayShort")); 
     2502                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperArrayByte"), pubFieldsMap.get("valueWrapperArrayByte")); 
     2503                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperArrayBoolean"), pubFieldsMap.get("valueWrapperArrayBoolean")); 
     2504                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperNumber"), pubFieldsMap.get("valueWrapperNumber")); 
     2505                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperArrayNumber"), pubFieldsMap.get("valueWrapperArrayNumber")); 
     2506                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperDate"), pubFieldsMap.get("valueWrapperDate")); 
     2507                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperArrayDate"), pubFieldsMap.get("valueWrapperArrayDate")); 
     2508                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperCalendar"), pubFieldsMap.get("valueWrapperCalendar")); 
     2509                assertEquals(JavaScriptUtilityTestModel4PublicFields.class.getField("valueWrapperArrayCalendar"), pubFieldsMap.get("valueWrapperArrayCalendar")); 
     2510        } 
     2511 
     2512        public void testGetPublicFieldMap_Publicフィールド_ModelA() throws Exception { 
     2513                Map<String, Field> pubFieldsMap = JavaScriptUtility.getPublicFieldMap(JavaScriptUtilityTestModel4PublicFieldsHasModelA.class); 
     2514                assertEquals(JavaScriptUtilityTestModel4PublicFieldsHasModelA.class.getField("modelA"), pubFieldsMap.get("modelA")); 
     2515        } 
     2516         
     2517        public void testGetPublicFieldMap_Publicフィールド_フィールドなし() throws Exception { 
     2518                Map<String, Field> pubFieldsMap = JavaScriptUtility.getPublicFieldMap(JavaScriptUtilityTestModelA.class); 
     2519                assertNull(pubFieldsMap); 
     2520        } 
     2521 
     2522        /** 
     2523         * <pre> 
     2524         * function createTestData(){ 
     2525         *     load('jssp/script/api/soap_client_helper'); 
     2526         *  
     2527         *     var beanType = "org.intra_mart.jssp.util.JavaScriptUtilityTestModel4PublicFields"; 
     2528         *     var bean = Packages.org.intra_mart.jssp.util.JavaScriptUtility.newInstanceFilledSampleData(beanType, "hoge"); 
     2529         *     var obj = Packages.org.intra_mart.jssp.util.JavaScriptUtility.javaBeanToJS(bean); 
     2530         *         obj = normalize(obj);         
     2531         *     Debug.console(obj); 
     2532         * } 
     2533         * </pre> 
     2534         * 
     2535         * <pre> 
     2536         *   0: ========== 1 ========== 
     2537         *   1: /&#42; Object &lt;JavaScriptUtilityTestModel4PublicFields&gt; &#42;/ 
     2538         *   2: { 
     2539         *   3:     /&#42; Array &lt;Character[]&gt; &#42;/ 
     2540         *   4:     "valueWrapperArrayCharacter" : [ 
     2541         *   5:         /&#42; String &#42;/ 
     2542         *   6:         "p" 
     2543         *   7:     ], 
     2544         *   8:  
     2545         *   9:     /&#42; Array &lt;Short[]&gt; &#42;/ 
     2546         *  10:     "valueWrapperArrayShort" : [ 
     2547         *  11:         /&#42; Number &#42;/ 
     2548         *  12:         123 
     2549         *  13:     ], 
     2550         *  14:  
     2551         *  15:     /&#42; String &#42;/ 
     2552         *  16:     "valueWrapperCharacter" : "p", 
     2553         *  17:  
     2554         *  18:     /&#42; Array &lt;byte[]&gt; &#42;/ 
     2555         *  19:     "valuePrimitiveArrayByte" : [ 
     2556         *  20:         /&#42; Number &#42;/ 
     2557         *  21:         123 
     2558         *  22:     ], 
     2559         *  23:  
     2560         *  24:     /&#42; Number &#42;/ 
     2561         *  25:     "valuePrimitiveFloat" : 123, 
     2562         *  26:  
     2563         *  27:     /&#42; String &#42;/ 
     2564         *  28:     "valuePrimitiveChar" : "p", 
     2565         *  29:  
     2566         *  30:     /&#42; Number &#42;/ 
     2567         *  31:     "valueWrapperInteger" : 123, 
     2568         *  32:  
     2569         *  33:     /&#42; Array &lt;Long[]&gt; &#42;/ 
     2570         *  34:     "valueWrapperArrayLong" : [ 
     2571         *  35:         /&#42; Number &#42;/ 
     2572         *  36:         123 
     2573         *  37:     ], 
     2574         *  38:  
     2575         *  39:     /&#42; Array &lt;Double[]&gt; &#42;/ 
     2576         *  40:     "valueWrapperArrayDouble" : [ 
     2577         *  41:         /&#42; Number &#42;/ 
     2578         *  42:         123 
     2579         *  43:     ], 
     2580         *  44:  
     2581         *  45:     /&#42; Number &#42;/ 
     2582         *  46:     "valuePrimitiveByte" : 123, 
     2583         *  47:  
     2584         *  48:     /&#42; Array &lt;Calendar[]&gt; &#42;/ 
     2585         *  49:     "valueWrapperArrayCalendar" : [ 
     2586         *  50:         /&#42; Date (Thu Jun 19 2008 12:34:56 GMT+0900 (JST)) &#42;/ 
     2587         *  51:         new Date(1213846496000) 
     2588         *  52:     ], 
     2589         *  53:  
     2590         *  54:     /&#42; Array &lt;String[]&gt; &#42;/ 
     2591         *  55:     "valueWrapperArrayString" : [ 
     2592         *  56:         /&#42; String &#42;/ 
     2593         *  57:         "prop_valueWrapperArrayString" 
     2594         *  58:     ], 
     2595         *  59:  
     2596         *  60:     /&#42; Array &lt;long[]&gt; &#42;/ 
     2597         *  61:     "valuePrimitiveArrayLong" : [ 
     2598         *  62:         /&#42; Number &#42;/ 
     2599         *  63:         123 
     2600         *  64:     ], 
     2601         *  65:  
     2602         *  66:     /&#42; Date (Thu Jun 19 2008 12:34:56 GMT+0900 (JST)) &#42;/ 
     2603         *  67:     "valueWrapperCalendar" : new Date(1213846496000), 
     2604         *  68:  
     2605         *  69:     /&#42; Array &lt;Byte[]&gt; &#42;/ 
     2606         *  70:     "valueWrapperArrayByte" : [ 
     2607         *  71:         /&#42; Number &#42;/ 
     2608         *  72:         123 
     2609         *  73:     ], 
     2610         *  74:  
     2611         *  75:     /&#42; Number &#42;/ 
     2612         *  76:     "valuePrimitiveLong" : 123, 
     2613         *  77:  
     2614         *  78:     /&#42; Array &lt;Float[]&gt; &#42;/ 
     2615         *  79:     "valueWrapperArrayFloat" : [ 
     2616         *  70:         /&#42; Number &#42;/ 
     2617         *  81:         123 
     2618         *  82:     ], 
     2619         *  83:  
     2620         *  84:     /&#42; Boolean &#42;/ 
     2621         *  85:     "valuePrimitiveBoolean" : true, 
     2622         *  86:  
     2623         *  87:     /&#42; String &#42;/ 
     2624         *  88:     "valueWrapperString" : "prop_valueWrapperString", 
     2625         *  89:  
     2626         *  90:     /&#42; Number &#42;/ 
     2627         *  91:     "valuePrimitiveShort" : 123, 
     2628         *  92:  
     2629         *  93:     /&#42; Number &#42;/ 
     2630         *  94:     "valueWrapperLong" : 123, 
     2631         *  95:  
     2632         *  96:     /&#42; Number &#42;/ 
     2633         *  97:     "valueWrapperDouble" : 123, 
     2634         *  98:  
     2635         *  99:     /&#42; Array &lt;Boolean[]&gt; &#42;/ 
     2636         * 100:     "valueWrapperArrayBoolean" : [ 
     2637         * 101:         /&#42; Boolean &#42;/ 
     2638         * 102:         true 
     2639         * 103:     ], 
     2640         * 104:  
     2641         * 105:     /&#42; Array &lt;Number[]&gt; &#42;/ 
     2642         * 106:     "valueWrapperArrayNumber" : [ 
     2643         * 107:         /&#42; Number &#42;/ 
     2644         * 108:         123 
     2645         * 109:     ], 
     2646         * 110:  
     2647         * 111:     /&#42; Number &#42;/ 
     2648         * 112:     "valueWrapperByte" : 123, 
     2649         * 113:  
     2650         * 114:     /&#42; Number &#42;/ 
     2651         * 115:     "valuePrimitiveDouble" : 123, 
     2652         * 116:  
     2653         * 117:     /&#42; Array &lt;Date[]&gt; &#42;/ 
     2654         * 118:     "valueWrapperArrayDate" : [ 
     2655         * 119:         /&#42; Date (Thu Jun 19 2008 12:34:56 GMT+0900 (JST)) &#42;/ 
     2656         * 120:         new Date(1213846496000) 
     2657         * 121:     ], 
     2658         * 122:  
     2659         * 123:     /&#42; Number &#42;/ 
     2660         * 124:     "valueWrapperShort" : 123, 
     2661         * 125:  
     2662         * 126:     /&#42; Array &lt;boolean[]&gt; &#42;/ 
     2663         * 127:     "valuePrimitiveArrayBoolean" : [ 
     2664         * 128:         /&#42; Boolean &#42;/ 
     2665         * 129:         true 
     2666         * 130:     ], 
     2667         * 131:  
     2668         * 132:     /&#42; Array &lt;float[]&gt; &#42;/ 
     2669         * 133:     "valuePrimitiveArrayFloat" : [ 
     2670         * 134:         /&#42; Number &#42;/ 
     2671         * 135:         123 
     2672         * 136:     ], 
     2673         * 137:  
     2674         * 138:     /&#42; Number &#42;/ 
     2675         * 139:     "valueWrapperDouble_POSI_INF" : 123, 
     2676         * 140:  
     2677         * 141:     /&#42; Array &lt;Integer[]&gt; &#42;/ 
     2678         * 142:     "valueWrapperArrayInteger" : [ 
     2679         * 143:         /&#42; Number &#42;/ 
     2680         * 144:         123 
     2681         * 145:     ], 
     2682         * 146:  
     2683         * 147:     /&#42; Number &#42;/ 
     2684         * 148:     "valuePrimitiveInt" : 123, 
     2685         * 149:  
     2686         * 150:     /&#42; Date (Thu Jun 19 2008 12:34:56 GMT+0900 (JST)) &#42;/ 
     2687         * 151:     "valueWrapperDate" : new Date(1213846496000), 
     2688         * 152:  
     2689         * 153:     /&#42; Number &#42;/ 
     2690         * 154:     "valueWrapperDouble_NaN" : 123, 
     2691         * 155:  
     2692         * 156:     /&#42; Number &#42;/ 
     2693         * 157:     "valueWrapperDouble_NEGA_INF" : 123, 
     2694         * 158:  
     2695         * 159:     /&#42; Number &#42;/ 
     2696         * 160:     "valueWrapperLong_MAX" : 123, 
     2697         * 161:  
     2698         * 162:     /&#42; Array &lt;short[]&gt; &#42;/ 
     2699         * 163:     "valuePrimitiveArrayShort" : [ 
     2700         * 164:         /&#42; Number &#42;/ 
     2701         * 165:         123 
     2702         * 166:     ], 
     2703         * 167:  
     2704         * 168:     /&#42; Array &lt;char[]&gt; &#42;/ 
     2705         * 169:     "valuePrimitiveArrayChar" : [ 
     2706         * 170:         /&#42; String &#42;/ 
     2707         * 171:         "p" 
     2708         * 172:     ], 
     2709         * 173:  
     2710         * 174:     /&#42; Array &lt;double[]&gt; &#42;/ 
     2711         * 175:     "valuePrimitiveArrayDouble" : [ 
     2712         * 176:         /&#42; Number &#42;/ 
     2713         * 177:         123 
     2714         * 178:     ], 
     2715         * 179:  
     2716         * 180:     /&#42; Number &#42;/ 
     2717         * 181:     "valueWrapperDouble_MIN" : 123, 
     2718         * 182:  
     2719         * 183:     /&#42; Number &#42;/ 
     2720         * 184:     "valueWrapperNumber" : 123, 
     2721         * 185:  
     2722         * 186:     /&#42; Boolean &#42;/ 
     2723         * 187:     "valueWrapperBoolean" : true, 
     2724         * 188:  
     2725         * 189:     /&#42; Number &#42;/ 
     2726         * 190:     "valueWrapperLong_MIN" : 123, 
     2727         * 191:  
     2728         * 192:     /&#42; Number &#42;/ 
     2729         * 193:     "valueWrapperDouble_MAX" : 123, 
     2730         * 194:  
     2731         * 195:     /&#42; Number &#42;/ 
     2732         * 196:     "valueWrapperFloat" : 123, 
     2733         * 197:  
     2734         * 198:     /&#42; Array &lt;int[]&gt; &#42;/ 
     2735         * 199:     "valuePrimitiveArrayInt" : [ 
     2736         * 200:         /&#42; Number &#42;/ 
     2737         * 201:         123 
     2738         * 202:     ], 
     2739         * 203:  
     2740         * 204:     /&#42; String &#42;/ 
     2741         * 205:     "propertyString" : "prop_propertyString" 
     2742         * 206: } 
     2743         * </pre> 
     2744         */ 
     2745        public void testJavaBeanToJS_Publicフィールド() throws Exception { 
     2746                // 可逆性あり! 
     2747                JavaScriptUtilityTestModel4PublicFields testData =  
     2748                        (JavaScriptUtilityTestModel4PublicFields)JavaScriptUtility.newInstanceFilledSampleData(JavaScriptUtilityTestModel4PublicFields.class, null); 
     2749 
     2750                Object actual = JavaScriptUtility.javaBeanToJS(testData); 
     2751 
     2752                assertEquals(ValueObject.class, actual.getClass()); 
     2753                ValueObject jsObj = (ValueObject)actual; 
     2754 
     2755                String propName; 
     2756                String expected; 
     2757                String actualString; 
     2758                Object actualValue; 
     2759                Date expectedDate; 
     2760                Date actualDate; 
     2761                Calendar expectedCal = Calendar.getInstance(); 
     2762                Calendar actualCal = Calendar.getInstance(); 
     2763                 
     2764 
     2765                // 1行目 
     2766                propName = ""; 
     2767                expected = JavaScriptUtilityTestModel4PublicFields.class.getSimpleName(); 
     2768                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     2769                assertEquals(expected, actualString); 
     2770                 
     2771                // 3行目 
     2772                propName = "valueWrapperArrayCharacter"; 
     2773                expected = Character[].class.getSimpleName(); 
     2774                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     2775                assertEquals(expected, actualString); 
     2776                 
     2777                // 4行目 
     2778                Object valueWrapperArrayCharacter = jsObj.get(propName, jsObj); 
     2779                assertNotNull(valueWrapperArrayCharacter); 
     2780                assertEquals(NativeArray.class, valueWrapperArrayCharacter.getClass()); 
     2781                NativeArray js_valueWrapperArrayCharacter = (NativeArray)valueWrapperArrayCharacter; 
     2782                assertEquals(1, js_valueWrapperArrayCharacter.getLength()); 
     2783                assertEquals("p", js_valueWrapperArrayCharacter.get(0, js_valueWrapperArrayCharacter)); 
     2784                 
     2785                // 9行目 
     2786                propName = "valueWrapperArrayShort"; 
     2787                expected = Short[].class.getSimpleName(); 
     2788                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     2789                assertEquals(expected, actualString); 
     2790 
     2791                // 10行目 
     2792                Object valueWrapperArrayShort = jsObj.get(propName, jsObj); 
     2793                assertNotNull(valueWrapperArrayCharacter); 
     2794                assertEquals(NativeArray.class, valueWrapperArrayCharacter.getClass()); 
     2795                NativeArray js_valueWrapperArrayShort = (NativeArray)valueWrapperArrayShort; 
     2796                assertEquals(1, js_valueWrapperArrayShort.getLength()); 
     2797                assertEquals(123.0, js_valueWrapperArrayShort.get(0, js_valueWrapperArrayShort)); 
     2798 
     2799                // 15行目 
     2800                propName = "valueWrapperCharacter"; 
     2801                expected = Character.class.getSimpleName(); 
     2802                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     2803                assertEquals(expected, actualString); 
     2804 
     2805                // 16行目 
     2806                Object valueWrapperCharacter = jsObj.get(propName, jsObj); 
     2807                assertNotNull(valueWrapperCharacter); 
     2808                assertEquals(String.class, valueWrapperCharacter.getClass()); 
     2809                assertEquals("p", valueWrapperCharacter); 
     2810         
     2811                // 18行目 
     2812                propName = "valuePrimitiveArrayByte"; 
     2813                expected = byte[].class.getSimpleName(); 
     2814                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     2815                assertEquals(expected, actualString); 
     2816         
     2817                // 19行目 
     2818                // byte[]はStringに変換されます。 
     2819                byte[] bytes = {123}; // Array の中の byte[]なので、実際には使われないであろう値。 
     2820                Object valuePrimitiveArrayByte = jsObj.get(propName, jsObj); 
     2821                assertNotNull(valuePrimitiveArrayByte); 
     2822                assertEquals(String.class, valuePrimitiveArrayByte.getClass()); 
     2823                assertEquals(new String(bytes, JavaScriptUtility.NON_CONVERT_CHARSET), valuePrimitiveArrayByte); 
     2824 
     2825                // 25行目 
     2826                propName = "valuePrimitiveFloat"; 
     2827                Object valuePrimitiveFloat = jsObj.get(propName, jsObj); 
     2828                assertNotNull(valuePrimitiveFloat); 
     2829                assertEquals(Double.class, valuePrimitiveFloat.getClass()); 
     2830                assertEquals(123.0, valuePrimitiveFloat); 
     2831                 
     2832                // 27行目 
     2833                propName = "valuePrimitiveChar"; 
     2834                Object valuePrimitiveChar = jsObj.get(propName, jsObj); 
     2835                assertNotNull(valuePrimitiveChar); 
     2836                assertEquals(String.class, valuePrimitiveChar.getClass()); 
     2837                assertEquals("p", valuePrimitiveChar); 
     2838 
     2839                // 30行目 
     2840                propName = "valueWrapperInteger"; 
     2841                Object valueWrapperInteger = jsObj.get(propName, jsObj); 
     2842                assertNotNull(valueWrapperInteger); 
     2843                assertEquals(Double.class, valueWrapperInteger.getClass()); 
     2844                assertEquals(123.0, valueWrapperInteger); 
     2845                 
     2846                // 33行目 
     2847                propName = "valueWrapperArrayLong"; 
     2848                expected = Long[].class.getSimpleName(); 
     2849                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     2850                assertEquals(expected, actualString); 
     2851         
     2852                // 34行目 
     2853                Object valueWrapperArrayLong = jsObj.get(propName, jsObj); 
     2854                assertNotNull(valueWrapperArrayLong); 
     2855                assertEquals(NativeArray.class, valueWrapperArrayLong.getClass()); 
     2856                NativeArray js_valueWrapperArrayLong = (NativeArray)valueWrapperArrayLong; 
     2857                assertEquals(1, js_valueWrapperArrayLong.getLength()); 
     2858                assertEquals(123.0, js_valueWrapperArrayShort.get(0, js_valueWrapperArrayLong)); 
     2859         
     2860                // 39行目 
     2861                propName = "valueWrapperArrayDouble"; 
     2862                expected = Double[].class.getSimpleName(); 
     2863                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     2864                assertEquals(expected, actualString); 
     2865         
     2866                // 40行目 
     2867                Object valueWrapperArrayDouble = jsObj.get(propName, jsObj); 
     2868                assertNotNull(valueWrapperArrayDouble); 
     2869                assertEquals(NativeArray.class, valueWrapperArrayDouble.getClass()); 
     2870                NativeArray js_valueWrapperArrayDouble = (NativeArray)valueWrapperArrayDouble; 
     2871                assertEquals(1, js_valueWrapperArrayDouble.getLength()); 
     2872                assertEquals(123.0, js_valueWrapperArrayShort.get(0, js_valueWrapperArrayDouble)); 
     2873 
     2874                // 45行目 
     2875                propName = "valuePrimitiveByte"; 
     2876                Object valuePrimitiveByte = jsObj.get(propName, jsObj); 
     2877                assertNotNull(valuePrimitiveByte); 
     2878                assertEquals(Double.class, valuePrimitiveByte.getClass()); 
     2879                assertEquals(123.0, valuePrimitiveByte); 
     2880 
     2881                // 48行目 
     2882                propName = "valueWrapperArrayCalendar"; 
     2883                expected = Calendar[].class.getSimpleName(); 
     2884                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     2885                assertEquals(expected, actualString); 
     2886         
     2887                // 49行目 
     2888                Object valueWrapperArrayCalendar = jsObj.get(propName, jsObj); 
     2889                assertNotNull(valueWrapperArrayCalendar); 
     2890                assertEquals(NativeArray.class, valueWrapperArrayCalendar.getClass()); 
     2891                NativeArray js_valueWrapperArrayCalendar = (NativeArray)valueWrapperArrayCalendar; 
     2892                assertEquals(1, js_valueWrapperArrayCalendar.getLength()); 
     2893 
     2894                expectedCal.setTimeInMillis(1213846496000L); // Thu Jun 19 2008 12:34:56 GMT+0900 (JST) 
     2895                actualDate = (Date) Context.jsToJava(js_valueWrapperArrayCalendar.get(0, js_valueWrapperArrayCalendar), Date.class); 
     2896                actualCal.setTime(actualDate); 
     2897                assertEquals(expectedCal, actualCal); 
     2898                 
     2899                // 54行目 
     2900                propName = "valueWrapperArrayString"; 
     2901                expected = String[].class.getSimpleName(); 
     2902                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     2903                assertEquals(expected, actualString); 
     2904         
     2905                // 55行目 
     2906                Object valueWrapperArrayString = jsObj.get(propName, jsObj); 
     2907                assertNotNull(valueWrapperArrayString); 
     2908                assertEquals(NativeArray.class, valueWrapperArrayString.getClass()); 
     2909                NativeArray js_valueWrapperArrayString = (NativeArray)valueWrapperArrayString; 
     2910                assertEquals(1, js_valueWrapperArrayString.getLength()); 
     2911                assertEquals("prop_valueWrapperArrayString", js_valueWrapperArrayString.get(0, js_valueWrapperArrayString)); 
     2912 
     2913                // 60行目 
     2914                propName = "valuePrimitiveArrayLong"; 
     2915                expected = long[].class.getSimpleName(); 
     2916                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     2917                assertEquals(expected, actualString); 
     2918         
     2919                // 61行目 
     2920                Object valuePrimitiveArrayLong = jsObj.get(propName, jsObj); 
     2921                assertNotNull(valuePrimitiveArrayLong); 
     2922                assertEquals(NativeArray.class, valuePrimitiveArrayLong.getClass()); 
     2923                NativeArray js_valuePrimitiveArrayLong = (NativeArray)valuePrimitiveArrayLong; 
     2924                assertEquals(1, js_valuePrimitiveArrayLong.getLength()); 
     2925                assertEquals(123.0, js_valuePrimitiveArrayLong.get(0, js_valuePrimitiveArrayLong)); 
     2926 
     2927                // 67行目 
     2928                propName = "valueWrapperCalendar"; 
     2929                Object valueWrapperCalendar = jsObj.get(propName, jsObj); 
     2930                assertNotNull(valueWrapperCalendar); 
     2931                assertEquals("org.mozilla.javascript.NativeDate", valueWrapperCalendar.getClass().getName()); 
     2932                expectedDate = new Date(1213846496000L); // Thu Jun 19 2008 12:34:56 GMT+0900 (JST) 
     2933                actualDate = (Date) Context.jsToJava(valueWrapperCalendar, Date.class); 
     2934                assertEquals(expectedDate, actualDate); 
     2935                 
     2936                // 69行目 
     2937                propName = "valueWrapperArrayByte"; 
     2938                expected = Byte[].class.getSimpleName(); 
     2939                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     2940                assertEquals(expected, actualString); 
     2941         
     2942                // 70行目 
     2943                Object valueWrapperArrayByte = jsObj.get(propName, jsObj); 
     2944                assertNotNull(valueWrapperArrayByte); 
     2945                assertEquals(NativeArray.class, valueWrapperArrayByte.getClass()); 
     2946                NativeArray js_valueWrapperArrayByte = (NativeArray)valueWrapperArrayByte; 
     2947                assertEquals(1, js_valueWrapperArrayByte.getLength()); 
     2948                assertEquals(123.0, js_valueWrapperArrayByte.get(0, js_valueWrapperArrayByte)); 
     2949                 
     2950                 
     2951                // 76行目 
     2952                propName = "valuePrimitiveLong"; 
     2953                Object valuePrimitiveLong = jsObj.get(propName, jsObj); 
     2954                assertNotNull(valuePrimitiveLong); 
     2955                assertEquals(Double.class, valuePrimitiveLong.getClass()); 
     2956                assertEquals(123.0, valuePrimitiveLong); 
     2957                 
     2958 
     2959                // 78行目 
     2960                propName = "valueWrapperArrayFloat"; 
     2961                expected = Float[].class.getSimpleName(); 
     2962                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     2963                assertEquals(expected, actualString); 
     2964         
     2965                // 79行目 
     2966                Object valueWrapperArrayFloat = jsObj.get(propName, jsObj); 
     2967                assertNotNull(valueWrapperArrayFloat); 
     2968                assertEquals(NativeArray.class, valueWrapperArrayFloat.getClass()); 
     2969                NativeArray js_valueWrapperArrayFloat = (NativeArray)valueWrapperArrayFloat; 
     2970                assertEquals(1, js_valueWrapperArrayFloat.getLength()); 
     2971                assertEquals(123.0, js_valueWrapperArrayFloat.get(0, js_valueWrapperArrayFloat)); 
     2972 
     2973                // 85行目 
     2974                propName = "valuePrimitiveBoolean"; 
     2975                Object valuePrimitiveBoolean = jsObj.get(propName, jsObj); 
     2976                assertNotNull(valuePrimitiveBoolean); 
     2977                assertEquals(Boolean.class, valuePrimitiveBoolean.getClass()); 
     2978                assertEquals(true, valuePrimitiveBoolean); 
     2979         
     2980                // 88行目 
     2981                propName = "valueWrapperString"; 
     2982                Object valueWrapperString = jsObj.get(propName, jsObj); 
     2983                assertNotNull(valueWrapperString); 
     2984                assertEquals(String.class, valueWrapperString.getClass()); 
     2985                assertEquals("prop_valueWrapperString", valueWrapperString); 
     2986 
     2987                // 90行目 
     2988                propName = "valuePrimitiveShort"; 
     2989                Object valuePrimitiveShort = jsObj.get(propName, jsObj); 
     2990                assertNotNull(valuePrimitiveShort); 
     2991                assertEquals(Double.class, valuePrimitiveShort.getClass()); 
     2992                assertEquals(123.0, valuePrimitiveShort); 
     2993 
     2994                // 94行目 
     2995                propName = "valueWrapperLong"; 
     2996                Object valueWrapperLong = jsObj.get(propName, jsObj); 
     2997                assertNotNull(valueWrapperLong); 
     2998                assertEquals(Double.class, valueWrapperLong.getClass()); 
     2999                assertEquals(123.0, valueWrapperLong); 
     3000                 
     3001                // 96行目 
     3002                propName = "valueWrapperDouble"; 
     3003                Object valueWrapperDouble = jsObj.get(propName, jsObj); 
     3004                assertNotNull(valueWrapperDouble); 
     3005                assertEquals(Double.class, valueWrapperDouble.getClass()); 
     3006                assertEquals(123.0, valueWrapperLong); 
     3007                 
     3008                // 99行目 
     3009                propName = "valueWrapperArrayBoolean"; 
     3010                expected = Boolean[].class.getSimpleName(); 
     3011                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     3012                assertEquals(expected, actualString); 
     3013         
     3014                // 100行目 
     3015                Object valueWrapperArrayBoolean = jsObj.get(propName, jsObj); 
     3016                assertNotNull(valueWrapperArrayBoolean); 
     3017                assertEquals(NativeArray.class, valueWrapperArrayBoolean.getClass()); 
     3018                NativeArray js_valueWrapperArrayBoolean = (NativeArray)valueWrapperArrayBoolean; 
     3019                assertEquals(1, js_valueWrapperArrayBoolean.getLength()); 
     3020                assertEquals(true, js_valueWrapperArrayBoolean.get(0, js_valueWrapperArrayBoolean)); 
     3021                 
     3022                // 105行目 
     3023                propName = "valueWrapperArrayNumber"; 
     3024                expected = Number[].class.getSimpleName(); 
     3025                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     3026                assertEquals(expected, actualString); 
     3027         
     3028                // 106行目 
     3029                Object valueWrapperArrayNumber = jsObj.get(propName, jsObj); 
     3030                assertNotNull(valueWrapperArrayNumber); 
     3031                assertEquals(NativeArray.class, valueWrapperArrayNumber.getClass()); 
     3032                NativeArray js_valueWrapperArrayNumber = (NativeArray)valueWrapperArrayNumber; 
     3033                assertEquals(1, js_valueWrapperArrayNumber.getLength()); 
     3034                assertEquals(123.0, js_valueWrapperArrayNumber.get(0, js_valueWrapperArrayNumber)); 
     3035 
     3036                // 112行目 
     3037                propName = "valueWrapperByte"; 
     3038                Object valueWrapperByte = jsObj.get(propName, jsObj); 
     3039                assertNotNull(valueWrapperByte); 
     3040                assertEquals(Double.class, valueWrapperByte.getClass()); 
     3041                assertEquals(123.0, valueWrapperByte); 
     3042 
     3043                // 115行目 
     3044                propName = "valuePrimitiveDouble"; 
     3045                Object valuePrimitiveDouble = jsObj.get(propName, jsObj); 
     3046                assertNotNull(valuePrimitiveDouble); 
     3047                assertEquals(Double.class, valuePrimitiveDouble.getClass()); 
     3048                assertEquals(123.0, valuePrimitiveDouble); 
     3049 
     3050                // 117行目 
     3051                propName = "valueWrapperArrayDate"; 
     3052                expected = Date[].class.getSimpleName(); 
     3053                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     3054                assertEquals(expected, actualString); 
     3055         
     3056                // 118行目 
     3057                Object valueWrapperArrayDate = jsObj.get(propName, jsObj); 
     3058                assertNotNull(valueWrapperArrayDate); 
     3059                assertEquals(NativeArray.class, valueWrapperArrayDate.getClass()); 
     3060                NativeArray js_valueWrapperArrayDate = (NativeArray)valueWrapperArrayDate; 
     3061                assertEquals(1, js_valueWrapperArrayDate.getLength()); 
     3062                 
     3063                expectedDate = new Date(1213846496000L); // Thu Jun 19 2008 12:34:56 GMT+0900 (JST) 
     3064                actualDate = (Date) Context.jsToJava(js_valueWrapperArrayDate.get(0, js_valueWrapperArrayDate), Date.class); 
     3065                assertEquals(expectedDate, actualDate); 
     3066                 
     3067                // 124行目 
     3068                propName = "valueWrapperShort"; 
     3069                Object valueWrapperShort = jsObj.get(propName, jsObj); 
     3070                assertNotNull(valueWrapperShort); 
     3071                assertEquals(Double.class, valueWrapperShort.getClass()); 
     3072                assertEquals(123.0, valueWrapperShort); 
     3073 
     3074                // 126行目 
     3075                propName = "valuePrimitiveArrayBoolean"; 
     3076                expected = boolean[].class.getSimpleName(); 
     3077                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     3078                assertEquals(expected, actualString); 
     3079         
     3080                // 127行目 
     3081                Object valuePrimitiveArrayBoolean = jsObj.get(propName, jsObj); 
     3082                assertNotNull(valuePrimitiveArrayBoolean); 
     3083                assertEquals(NativeArray.class, valuePrimitiveArrayBoolean.getClass()); 
     3084                NativeArray js_valuePrimitiveArrayBoolean = (NativeArray)valuePrimitiveArrayBoolean; 
     3085                assertEquals(1, js_valuePrimitiveArrayBoolean.getLength()); 
     3086                assertEquals(true, js_valuePrimitiveArrayBoolean.get(0, js_valuePrimitiveArrayBoolean)); 
     3087 
     3088                // 132行目 
     3089                propName = "valuePrimitiveArrayFloat"; 
     3090                expected = float[].class.getSimpleName(); 
     3091                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     3092                assertEquals(expected, actualString); 
     3093         
     3094                // 133行目 
     3095                Object valuePrimitiveArrayFloat = jsObj.get(propName, jsObj); 
     3096                assertNotNull(valuePrimitiveArrayFloat); 
     3097                assertEquals(NativeArray.class, valuePrimitiveArrayFloat.getClass()); 
     3098                NativeArray js_valuePrimitiveArrayFloat = (NativeArray)valuePrimitiveArrayFloat; 
     3099                assertEquals(1, js_valuePrimitiveArrayFloat.getLength()); 
     3100                assertEquals(123.0, js_valuePrimitiveArrayFloat.get(0, js_valuePrimitiveArrayFloat)); 
     3101         
     3102                // 138行目 
     3103                propName = "valueWrapperDouble_POSI_INF"; 
     3104                Object valueWrapperDouble_POSI_INF = jsObj.get(propName, jsObj); 
     3105                assertNotNull(valueWrapperDouble_POSI_INF); 
     3106                assertEquals(Double.class, valueWrapperDouble_POSI_INF.getClass()); 
     3107                assertEquals(123.0, valueWrapperDouble_POSI_INF); 
     3108         
     3109 
     3110                // 141行目 
     3111                propName = "valueWrapperArrayInteger"; 
     3112                expected = Integer[].class.getSimpleName(); 
     3113                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     3114                assertEquals(expected, actualString); 
     3115         
     3116                // 142行目 
     3117                Object valueWrapperArrayInteger = jsObj.get(propName, jsObj); 
     3118                assertNotNull(valueWrapperArrayInteger); 
     3119                assertEquals(NativeArray.class, valueWrapperArrayInteger.getClass()); 
     3120                NativeArray js_valueWrapperArrayInteger = (NativeArray)valueWrapperArrayInteger; 
     3121                assertEquals(1, js_valueWrapperArrayInteger.getLength()); 
     3122                assertEquals(123.0, js_valueWrapperArrayInteger.get(0, js_valueWrapperArrayInteger)); 
     3123         
     3124                // 147行目 
     3125                propName = "valuePrimitiveInt"; 
     3126                Object valuePrimitiveInt = jsObj.get(propName, jsObj); 
     3127                assertNotNull(valuePrimitiveInt); 
     3128                assertEquals(Double.class, valuePrimitiveInt.getClass()); 
     3129                assertEquals(123.0, valuePrimitiveInt); 
     3130                 
     3131                // 151行目 
     3132                propName = "valueWrapperDate"; 
     3133                Object valueWrapperDate = jsObj.get(propName, jsObj); 
     3134                assertNotNull(valueWrapperDate); 
     3135                assertEquals("org.mozilla.javascript.NativeDate", valueWrapperDate.getClass().getName()); 
     3136                expectedDate = new Date(1213846496000L); // Thu Jun 19 2008 12:34:56 GMT+0900 (JST) 
     3137                actualDate = (Date) Context.jsToJava(valueWrapperDate, Date.class); 
     3138                assertEquals(expectedDate, actualDate); 
     3139                 
     3140                // 154行目 
     3141                propName = "valueWrapperDouble_NaN"; 
     3142                Object valueWrapperDouble_NaN = jsObj.get(propName, jsObj); 
     3143                assertNotNull(valueWrapperDouble_NaN); 
     3144                assertEquals(Double.class, valueWrapperDouble_NaN.getClass()); 
     3145                assertEquals(123.0, valueWrapperDouble_NaN); 
     3146         
     3147                // 157行目 
     3148                propName = "valueWrapperDouble_NEGA_INF"; 
     3149                Object valueWrapperDouble_NEGA_INF = jsObj.get(propName, jsObj); 
     3150                assertNotNull(valueWrapperDouble_NEGA_INF); 
     3151                assertEquals(Double.class, valueWrapperDouble_NEGA_INF.getClass()); 
     3152                assertEquals(123.0, valueWrapperDouble_NEGA_INF); 
     3153 
     3154                // 160行目 
     3155                propName = "valueWrapperLong_MAX"; 
     3156                Object valueWrapperLong_MAX = jsObj.get(propName, jsObj); 
     3157                assertNotNull(valueWrapperLong_MAX); 
     3158                assertEquals(Double.class, valueWrapperLong_MAX.getClass()); 
     3159                assertEquals(123.0, valueWrapperLong_MAX); 
     3160                 
     3161                // 162行目 
     3162                propName = "valuePrimitiveArrayShort"; 
     3163                expected = short[].class.getSimpleName(); 
     3164                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     3165                assertEquals(expected, actualString); 
     3166         
     3167                // 163行目 
     3168                Object valuePrimitiveArrayShort = jsObj.get(propName, jsObj); 
     3169                assertNotNull(valuePrimitiveArrayShort); 
     3170                assertEquals(NativeArray.class, valuePrimitiveArrayShort.getClass()); 
     3171                NativeArray js_valuePrimitiveArrayShort = (NativeArray)valuePrimitiveArrayShort; 
     3172                assertEquals(1, js_valuePrimitiveArrayShort.getLength()); 
     3173                assertEquals(123.0, js_valuePrimitiveArrayShort.get(0, js_valuePrimitiveArrayShort)); 
     3174 
     3175                // 168行目 
     3176                propName = "valuePrimitiveArrayChar"; 
     3177                expected = char[].class.getSimpleName(); 
     3178                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     3179                assertEquals(expected, actualString); 
     3180         
     3181                // 169行目 
     3182                Object valuePrimitiveArrayChar = jsObj.get(propName, jsObj); 
     3183                assertNotNull(valuePrimitiveArrayChar); 
     3184                assertEquals(NativeArray.class, valuePrimitiveArrayChar.getClass()); 
     3185                NativeArray js_valuePrimitiveArrayChar = (NativeArray)valuePrimitiveArrayChar; 
     3186                assertEquals(1, js_valuePrimitiveArrayChar.getLength()); 
     3187                assertEquals("p", js_valuePrimitiveArrayChar.get(0, js_valuePrimitiveArrayChar)); 
     3188                 
     3189                // 174行目 
     3190                propName = "valuePrimitiveArrayDouble"; 
     3191                expected = double[].class.getSimpleName(); 
     3192                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     3193                assertEquals(expected, actualString); 
     3194         
     3195                // 175行目 
     3196                Object valuePrimitiveArrayDouble = jsObj.get(propName, jsObj); 
     3197                assertNotNull(valuePrimitiveArrayDouble); 
     3198                assertEquals(NativeArray.class, valuePrimitiveArrayDouble.getClass()); 
     3199                NativeArray js_valuePrimitiveArrayDouble = (NativeArray)valuePrimitiveArrayDouble; 
     3200                assertEquals(1, js_valuePrimitiveArrayDouble.getLength()); 
     3201                assertEquals(123.0, js_valuePrimitiveArrayDouble.get(0, js_valuePrimitiveArrayDouble)); 
     3202                 
     3203                // 181行目 
     3204                propName = "valueWrapperDouble_MIN"; 
     3205                Object valueWrapperDouble_MIN = jsObj.get(propName, jsObj); 
     3206                assertNotNull(valueWrapperDouble_MIN); 
     3207                assertEquals(Double.class, valueWrapperDouble_MIN.getClass()); 
     3208                assertEquals(123.0, valueWrapperDouble_MIN); 
     3209 
     3210                // 184行目 
     3211                propName = "valueWrapperNumber"; 
     3212                Object valueWrapperNumber = jsObj.get(propName, jsObj); 
     3213                assertNotNull(valueWrapperNumber); 
     3214                assertEquals(Double.class, valueWrapperNumber.getClass()); 
     3215                assertEquals(123.0, valueWrapperNumber); 
     3216 
     3217                // 187行目 
     3218                propName = "valueWrapperBoolean"; 
     3219                Object valueWrapperBoolean = jsObj.get(propName, jsObj); 
     3220                assertNotNull(valueWrapperBoolean); 
     3221                assertEquals(Boolean.class, valueWrapperBoolean.getClass()); 
     3222                assertEquals(true, valueWrapperBoolean); 
     3223 
     3224                // 189行目 
     3225                propName = "valueWrapperLong_MIN"; 
     3226                Object valueWrapperLong_MIN = jsObj.get(propName, jsObj); 
     3227                assertNotNull(valueWrapperLong_MIN); 
     3228                assertEquals(Double.class, valueWrapperLong_MIN.getClass()); 
     3229                assertEquals(123.0, valueWrapperLong_MIN); 
     3230 
     3231                // 193行目 
     3232                propName = "valueWrapperDouble_MAX"; 
     3233                Object valueWrapperDouble_MAX = jsObj.get(propName, jsObj); 
     3234                assertNotNull(valueWrapperDouble_MAX); 
     3235                assertEquals(Double.class, valueWrapperDouble_MAX.getClass()); 
     3236                assertEquals(123.0, valueWrapperDouble_MAX); 
     3237 
     3238                // 195行目 
     3239                propName = "valueWrapperFloat"; 
     3240                Object valueWrapperFloat = jsObj.get(propName, jsObj); 
     3241                assertNotNull(valueWrapperFloat); 
     3242                assertEquals(Double.class, valueWrapperFloat.getClass()); 
     3243                assertEquals(123.0, valueWrapperFloat); 
     3244 
     3245                // 198行目 
     3246                propName = "valuePrimitiveArrayInt"; 
     3247                expected = int[].class.getSimpleName(); 
     3248                actualString = (String) jsObj.get("__javaClassName_" + propName + "__", jsObj); 
     3249                assertEquals(expected, actualString); 
     3250         
     3251                // 199行目 
     3252                Object valuePrimitiveArrayInt = jsObj.get(propName, jsObj); 
     3253                assertNotNull(valuePrimitiveArrayInt); 
     3254                assertEquals(NativeArray.class, valuePrimitiveArrayInt.getClass()); 
     3255                NativeArray js_valuePrimitiveArrayInt = (NativeArray)valuePrimitiveArrayInt; 
     3256                assertEquals(1, js_valuePrimitiveArrayInt.getLength()); 
     3257                assertEquals(123.0, js_valuePrimitiveArrayInt.get(0, js_valuePrimitiveArrayInt)); 
     3258                 
     3259                // 205行目 
     3260                propName = "propertyString"; 
     3261                Object propertyString = jsObj.get(propName, jsObj); 
     3262                assertNotNull(propertyString); 
     3263                assertEquals(String.class, propertyString.getClass()); 
     3264                assertEquals("prop_propertyString", propertyString); 
     3265        } 
     3266 
     3267        public void testjsToJavaBean_Publicフィールド() throws Exception { 
     3268                // 可逆性あり! 
     3269                JavaScriptUtilityTestModel4PublicFields expected = (JavaScriptUtilityTestModel4PublicFields)JavaScriptUtility.newInstanceFilledSampleData(JavaScriptUtilityTestModel4PublicFields.class, null); 
     3270                Object jsObject = JavaScriptUtility.javaBeanToJS(expected); 
     3271                 
     3272                Object actual = JavaScriptUtility.jsToJavaBean(jsObject, JavaScriptUtilityTestModel4PublicFields.class); 
     3273                assertEquals(JavaScriptUtilityTestModel4PublicFields.class, actual.getClass()); 
     3274                 
     3275                JavaScriptUtilityTestModel4PublicFields actualModel = (JavaScriptUtilityTestModel4PublicFields) actual; 
     3276                 
     3277                assertEquals(expected.valuePrimitiveChar, actualModel.valuePrimitiveChar); 
     3278                assertEquals(expected.valuePrimitiveDouble, actualModel.valuePrimitiveDouble); 
     3279                assertEquals(expected.valuePrimitiveFloat, actualModel.valuePrimitiveFloat); 
     3280                assertEquals(expected.valuePrimitiveLong, actualModel.valuePrimitiveLong); 
     3281                assertEquals(expected.valuePrimitiveInt, actualModel.valuePrimitiveInt); 
     3282                assertEquals(expected.valuePrimitiveShort, actualModel.valuePrimitiveShort); 
     3283                assertEquals(expected.valuePrimitiveByte, actualModel.valuePrimitiveByte); 
     3284                assertEquals(expected.valuePrimitiveBoolean, actualModel.valuePrimitiveBoolean); 
     3285                 
     3286                assertEquals(expected.valuePrimitiveArrayChar[0], actualModel.valuePrimitiveArrayChar[0]); 
     3287                assertEquals(expected.valuePrimitiveArrayDouble[0], actualModel.valuePrimitiveArrayDouble[0]); 
     3288                assertEquals(expected.valuePrimitiveArrayFloat[0], actualModel.valuePrimitiveArrayFloat[0]); 
     3289                assertEquals(expected.valuePrimitiveArrayLong[0], actualModel.valuePrimitiveArrayLong[0]); 
     3290                assertEquals(expected.valuePrimitiveArrayInt[0], actualModel.valuePrimitiveArrayInt[0]); 
     3291                assertEquals(expected.valuePrimitiveArrayShort[0], actualModel.valuePrimitiveArrayShort[0]); 
     3292                assertEquals(expected.valuePrimitiveArrayByte[0], actualModel.valuePrimitiveArrayByte[0]); 
     3293                assertEquals(expected.valuePrimitiveArrayBoolean[0], actualModel.valuePrimitiveArrayBoolean[0]); 
     3294 
     3295                assertEquals(expected.valueWrapperString, actualModel.valueWrapperString); 
     3296                assertEquals(expected.valueWrapperCharacter, actualModel.valueWrapperCharacter); 
     3297                assertEquals(expected.valueWrapperDouble, actualModel.valueWrapperDouble); 
     3298                assertEquals(expected.valueWrapperDouble_MAX, actualModel.valueWrapperDouble_MAX); 
     3299                assertEquals(expected.valueWrapperDouble_MIN, actualModel.valueWrapperDouble_MIN); 
     3300                assertEquals(expected.valueWrapperDouble_NaN, actualModel.valueWrapperDouble_NaN); 
     3301                assertEquals(expected.valueWrapperDouble_NEGA_INF, actualModel.valueWrapperDouble_NEGA_INF); 
     3302                assertEquals(expected.valueWrapperDouble_POSI_INF, actualModel.valueWrapperDouble_POSI_INF); 
     3303                assertEquals(expected.valueWrapperFloat, actualModel.valueWrapperFloat); 
     3304                assertEquals(expected.valueWrapperLong, actualModel.valueWrapperLong); 
     3305                assertEquals(expected.valueWrapperLong_MAX, actualModel.valueWrapperLong_MAX); 
     3306                assertEquals(expected.valueWrapperLong_MIN, actualModel.valueWrapperLong_MIN); 
     3307                assertEquals(expected.valueWrapperInteger, actualModel.valueWrapperInteger); 
     3308                assertEquals(expected.valueWrapperShort, actualModel.valueWrapperShort); 
     3309                assertEquals(expected.valueWrapperByte, actualModel.valueWrapperByte); 
     3310                assertEquals(expected.valueWrapperBoolean, actualModel.valueWrapperBoolean); 
     3311                 
     3312                assertEquals(expected.valueWrapperArrayString[0], actualModel.valueWrapperArrayString[0]); 
     3313                assertEquals(expected.valueWrapperArrayCharacter[0], actualModel.valueWrapperArrayCharacter[0]); 
     3314                assertEquals(expected.valueWrapperArrayDouble[0], actualModel.valueWrapperArrayDouble[0]); 
     3315                assertEquals(expected.valueWrapperArrayFloat[0], actualModel.valueWrapperArrayFloat[0]); 
     3316                assertEquals(expected.valueWrapperArrayLong[0], actualModel.valueWrapperArrayLong[0]); 
     3317                assertEquals(expected.valueWrapperArrayLong[0], actualModel.valueWrapperArrayLong[0]); 
     3318                assertEquals(expected.valueWrapperArrayInteger[0], actualModel.valueWrapperArrayInteger[0]); 
     3319                assertEquals(expected.valueWrapperArrayShort[0], actualModel.valueWrapperArrayShort[0]); 
     3320                assertEquals(expected.valueWrapperArrayByte[0], actualModel.valueWrapperArrayByte[0]); 
     3321                assertEquals(expected.valueWrapperArrayBoolean[0], actualModel.valueWrapperArrayBoolean[0]); 
     3322                assertEquals(expected.valueWrapperNumber, actualModel.valueWrapperNumber); 
     3323                assertEquals(expected.valueWrapperArrayNumber[0], actualModel.valueWrapperArrayNumber[0]); 
     3324                assertEquals(expected.valueWrapperDate, actualModel.valueWrapperDate); 
     3325                assertEquals(expected.valueWrapperArrayDate[0], actualModel.valueWrapperArrayDate[0]); 
     3326                assertEquals(expected.valueWrapperCalendar, actualModel.valueWrapperCalendar); 
     3327                assertEquals(expected.valueWrapperArrayCalendar[0], actualModel.valueWrapperArrayCalendar[0]); 
     3328        } 
     3329 
    24063330} 
  • trunk/im-jssp/src/test/java/org/intra_mart/jssp/util/JavaScriptUtilityTestModelA.java

    r232 r302  
    6565                this.valueWrapperDateModelA = valueWrapperDateModelA; 
    6666        } 
     67 
     68         
     69         
     70        private Object plainObject = new Object(); 
     71 
     72        public Object getPlainObject() { 
     73                return plainObject; 
     74        } 
     75        public void setPlainObject(Object plainObject) { 
     76                this.plainObject = plainObject; 
     77        } 
    6778}