View Javadoc

    1   /**
    2    * Copyright (c) 2008-2011, http://www.snakeyaml.org
    3    *
    4    * Licensed under the Apache License, Version 2.0 (the "License");
    5    * you may not use this file except in compliance with the License.
    6    * You may obtain a copy of the License at
    7    *
    8    *     http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16
    17  package org.yaml.snakeyaml.constructor;
    18
    19  import java.io.IOException;
    20  import java.math.BigInteger;
    21
    22  import junit.framework.TestCase;
    23
    24  import org.yaml.snakeyaml.DumperOptions;
    25  import org.yaml.snakeyaml.Util;
    26  import org.yaml.snakeyaml.Yaml;
    27  import org.yaml.snakeyaml.error.YAMLException;
    28
    29  public class BeanConstructorTest extends TestCase {
    30
    31      public void testPrimitivesConstructor() throws IOException {
    32          Yaml yaml = new Yaml(new Constructor(TestBean1.class));
    33          String document = Util.getLocalResource("constructor/test-primitives1.yaml");
    34          TestBean1 result = (TestBean1) yaml.load(document);
    35          assertNotNull(result);
    36          assertEquals(new Byte((byte) 1), result.getByteClass());
    37          assertEquals((byte) -3, result.getBytePrimitive());
    38          assertEquals(new Short((short) 0), result.getShortClass());
    39          assertEquals((short) -13, result.getShortPrimitive());
    40          assertEquals(new Integer(5), result.getInteger());
    41          assertEquals(17, result.getIntPrimitive());
    42          assertEquals("the text", result.getText());
    43          assertEquals("13", result.getId());
    44          assertEquals(new Long(11111111111L), result.getLongClass());
    45          assertEquals(9999999999L, result.getLongPrimitive());
    46          assertEquals(Boolean.TRUE, result.getBooleanClass());
    47          assertTrue(result.isBooleanPrimitive());
    48          assertEquals(new Character('2'), result.getCharClass());
    49          assertEquals('#', result.getCharPrimitive());
    50          assertEquals(new BigInteger("1234567890123456789012345678901234567890"),
    51                  result.getBigInteger());
    52          assertEquals(new Float(2), result.getFloatClass());
    53          assertEquals(new Float(3.1416), result.getFloatPrimitive());
    54          assertEquals(new Double(4), result.getDoubleClass());
    55          assertEquals(new Double(11200), result.getDoublePrimitive());
    56          assertEquals(1199836800000L, result.getDate().getTime());
    57          assertEquals("public", result.publicField);
    58          //
    59          DumperOptions options = new DumperOptions();
    60          options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
    61          Yaml yamlToDump = new Yaml(options);
    62          String output = yamlToDump.dump(result);
    63          TestBean1 result2 = (TestBean1) yaml.load(output);
    64          assertNotNull(result2);
    65          TestBean1 result3 = (TestBean1) new Yaml().load(output);
    66          assertNotNull(result3);
    67      }
    68
    69      public void testNoClassConstructor() {
    70          try {
    71              new Yaml(new Constructor((Class<? extends Object>) null));
    72              fail("Class must be provided.");
    73          } catch (NullPointerException e) {
    74              assertEquals("Root class must be provided.", e.getMessage());
    75          }
    76      }
    77
    78      public void testNoClassConstructorString() throws ClassNotFoundException {
    79          try {
    80              new Yaml(new Constructor((String) null));
    81              fail("Class must be provided.");
    82          } catch (NullPointerException e) {
    83              assertEquals("Root type must be provided.", e.getMessage());
    84          }
    85      }
    86
    87      public void testNoClassConstructorEmptyString() throws ClassNotFoundException {
    88          try {
    89              new Yaml(new Constructor(" "));
    90              fail("Class must be provided.");
    91          } catch (YAMLException e) {
    92              assertEquals("Root type must be provided.", e.getMessage());
    93          }
    94      }
    95
    96      public void testCharacter() throws IOException {
    97          Yaml yaml = new Yaml(new Constructor(TestBean1.class));
    98          String document = "charClass: id";
    99          try {
    100             yaml.load(document);
    101             fail("Only one char must be allowed.");
    102         } catch (Exception e) {
    103             assertTrue(e.getMessage(),
    104                     e.getMessage().contains("Invalid node Character: 'id'; length: 2"));
    105         }
    106         document = "charClass: #";
    107         TestBean1 bean = (TestBean1) yaml.load(document);
    108         assertNull("Null must be accepted.", bean.getCharClass());
    109         document = "charClass: ''";
    110         bean = (TestBean1) yaml.load(document);
    111         assertNull("Null must be accepted.", bean.getCharClass());
    112         document = "charClass:\n";
    113         bean = (TestBean1) yaml.load(document);
    114         assertNull("Null must be accepted.", bean.getCharClass());
    115         document = "charClass: 1\n";
    116         bean = (TestBean1) yaml.load(document);
    117         assertEquals(new Character('1'), bean.getCharClass());
    118     }
    119
    120     public void testNoEmptyConstructor() throws IOException {
    121         Yaml yaml = new Yaml(new Constructor(TestBean2.class));
    122         String document = "text: qwerty";
    123         try {
    124             yaml.load(document);
    125             fail("No empty constructor available");
    126         } catch (Exception e) {
    127             assertTrue(e.getMessage(), e.getMessage().contains("NoSuchMethodException"));
    128         }
    129         TestBean2 bean = new TestBean2();
    130         assertEquals("", bean.getText());
    131     }
    132
    133     private class TestBean2 {
    134         private String text;
    135
    136         public TestBean2() {
    137             setText("");
    138         }
    139
    140         public String getText() {
    141             return text;
    142         }
    143
    144         public void setText(String text) {
    145             this.text = text;
    146         }
    147     }
    148
    149     public void testPrivateMethod() throws IOException {
    150         // TODO: Are we sure no private ????
    151         Yaml yaml = new Yaml(new Constructor(TestBean2.class));
    152         String document = "text: qwerty";
    153         try {
    154             yaml.load(document);
    155             fail("Private method cannot be called.");
    156         } catch (Exception e) {
    157             assertTrue(e.getMessage(), e.getMessage().contains("NoSuchMethodException"));
    158         }
    159     }
    160
    161     public void testKeyNotScalar() throws IOException {
    162         Yaml yaml = new Yaml(new Constructor(TestBean1.class));
    163         String document = "[1, 2]: qwerty";
    164         try {
    165             yaml.load(document);
    166             fail("Keys must be scalars.");
    167         } catch (Exception e) {
    168             assertTrue(e.getMessage(), e.getMessage().contains("Keys must be scalars but found"));
    169         }
    170     }
    171
    172     public void testInvalidKey() throws IOException {
    173         Yaml yaml = new Yaml(new Constructor(TestBean1.class));
    174         String document = "something: qwerty";
    175         try {
    176             yaml.load(document);
    177             fail("Non-existing property must fail.");
    178         } catch (Exception e) {
    179             assertTrue(e.getMessage(),
    180                     e.getMessage().contains("Unable to find property 'something'"));
    181         }
    182     }
    183
    184     public void testStaticField() throws IOException {
    185         Yaml yaml = new Yaml(new Constructor(TestBean1.class));
    186         String document = "staticInteger: 123";
    187         try {
    188             yaml.load(document);
    189             fail("Staic variables must not be used.");
    190         } catch (Exception e) {
    191             assertTrue(e.getMessage(),
    192                     e.getMessage().contains("Unable to find property 'staticInteger'"));
    193         }
    194     }
    195
    196     public void testScalarContructor() throws IOException {
    197         Yaml yaml = new Yaml(new Constructor(Parent1.class));
    198         String document = "id: 123\nchild: 25";
    199         Parent1 parent = (Parent1) yaml.load(document);
    200         assertEquals("123", parent.getId());
    201         Child1 child = parent.getChild();
    202         assertEquals(new Integer(25), child.getCode());
    203     }
    204
    205     public void testScalarContructorException() throws IOException {
    206         Yaml yaml = new Yaml(new Constructor(ExceptionParent.class));
    207         String document = "id: 123\nchild: 25";
    208         try {
    209             yaml.load(document);
    210             fail("ExceptionParent should not be created.");
    211         } catch (Exception e) {
    212             assertTrue(
    213                     e.getMessage(),
    214                     e.getMessage().contains(
    215                             "Can't construct a java object for scalar tag:yaml.org,2002:int"));
    216         }
    217     }
    218
    219     static public class ExceptionParent {
    220         private String id;
    221         private ExceptionChild child;
    222
    223         public String getId() {
    224             return id;
    225         }
    226
    227         public void setId(String id) {
    228             this.id = id;
    229         }
    230
    231         public ExceptionChild getChild() {
    232             return child;
    233         }
    234
    235         public void setChild(ExceptionChild child) {
    236             this.child = child;
    237         }
    238
    239     }
    240
    241     public static class ExceptionChild {
    242         private Integer code;
    243
    244         public ExceptionChild(Integer code) {
    245             throw new RuntimeException("ExceptionChild cannot be created.");
    246         }
    247
    248         public Integer getCode() {
    249             return code;
    250         }
    251     }
    252 }