View Javadoc

1   /**
2    * Copyright (c) 2008-2012, 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  package examples.collections;
17  
18  import java.util.LinkedHashMap;
19  import java.util.Map;
20  
21  import junit.framework.TestCase;
22  
23  import org.yaml.snakeyaml.Util;
24  import org.yaml.snakeyaml.Yaml;
25  
26  /**
27   * Test MapBean->Map<String, Developer> developers <br/>
28   * Developer class must be properly recognised
29   */
30  public class TypeSafeMapTest extends TestCase {
31      public void testDumpMap() {
32          MapBean bean = new MapBean();
33          Map<String, Integer> data = new LinkedHashMap<String, Integer>();
34          data.put("aaa", 1);
35          data.put("bbb", 2);
36          data.put("zzz", 3);
37          bean.setData(data);
38          Map<String, Developer2> developers = new LinkedHashMap<String, Developer2>();
39          developers.put("team1", new Developer2("Fred", "creator"));
40          developers.put("team2", new Developer2("John", "committer"));
41          bean.setDevelopers(developers);
42          Yaml yaml = new Yaml();
43          String output = yaml.dumpAsMap(bean);
44          // System.out.println(output);
45          String etalon = Util.getLocalResource("examples/map-bean-10.yaml");
46          assertEquals(etalon, output);
47      }
48  
49      public void testDumpMap2() {
50          MapBean bean = new MapBean();
51          Map<String, Integer> data = new LinkedHashMap<String, Integer>();
52          data.put("aaa", 1);
53          data.put("bbb", 2);
54          bean.setData(data);
55          Map<String, Developer2> developers = new LinkedHashMap<String, Developer2>();
56          developers.put("team1", new Developer2("Fred", "creator"));
57          developers.put("team2", new Developer2("John", "committer"));
58          developers.put("team3", new Developer222("Bill", "head"));
59          bean.setDevelopers(developers);
60          Yaml yaml = new Yaml();
61          String output = yaml.dumpAsMap(bean);
62          // System.out.println(output);
63          String etalon = Util.getLocalResource("examples/map-bean-11.yaml");
64          assertEquals(etalon, output);
65      }
66  
67      public void testLoadMap() {
68          String output = Util.getLocalResource("examples/map-bean-10.yaml");
69          // System.out.println(output);
70          Yaml beanLoader = new Yaml();
71          MapBean parsed = beanLoader.loadAs(output, MapBean.class);
72          assertNotNull(parsed);
73          Map<String, Integer> data = parsed.getData();
74          assertEquals(3, data.size());
75          assertEquals(new Integer(1), data.get("aaa"));
76          assertEquals(new Integer(2), data.get("bbb"));
77          assertEquals(new Integer(3), data.get("zzz"));
78          Map<String, Developer2> developers = parsed.getDevelopers();
79          assertEquals(2, developers.size());
80          assertEquals("Developer must be recognised.", Developer2.class, developers.get("team1")
81                  .getClass());
82          Developer2 fred = developers.get("team1");
83          assertEquals("Fred", fred.getName());
84          assertEquals("creator", fred.getRole());
85      }
86  
87      public static class MapBean {
88          private Map<String, Integer> data;
89          private String name;
90          private Map<String, Developer2> developers;
91  
92          public MapBean() {
93              name = "Bean123";
94          }
95  
96          public Map<String, Integer> getData() {
97              return data;
98          }
99  
100         public void setData(Map<String, Integer> data) {
101             this.data = data;
102         }
103 
104         public String getName() {
105             return name;
106         }
107 
108         public void setName(String name) {
109             this.name = name;
110         }
111 
112         public Map<String, Developer2> getDevelopers() {
113             return developers;
114         }
115 
116         public void setDevelopers(Map<String, Developer2> developers) {
117             this.developers = developers;
118         }
119     }
120 
121     public static class Developer2 {
122         private String name;
123         private String role;
124 
125         public Developer2() {
126         }
127 
128         public Developer2(String name, String role) {
129             this.name = name;
130             this.role = role;
131         }
132 
133         public String getName() {
134             return name;
135         }
136 
137         public void setName(String name) {
138             this.name = name;
139         }
140 
141         public String getRole() {
142             return role;
143         }
144 
145         public void setRole(String role) {
146             this.role = role;
147         }
148     }
149 
150     public static class Developer222 extends Developer2 {
151         public Developer222() {
152             super();
153         }
154 
155         public Developer222(String name, String role) {
156             super(name, role);
157         }
158     }
159 
160     /*
161      * No generic collection
162      */
163     @SuppressWarnings({ "unchecked", "rawtypes" })
164     public void testLoadMapWithObject() {
165         String output = Util.getLocalResource("examples/map-bean-10.yaml");
166         // System.out.println(output);
167         Yaml beanLoader = new Yaml();
168         MapBeanNoGenerics parsed = beanLoader.loadAs(output, MapBeanNoGenerics.class);
169         assertNotNull(parsed);
170         Map<String, Integer> data = parsed.getData();
171         assertEquals(3, data.size());
172         assertEquals(new Integer(1), data.get("aaa"));
173         assertEquals(new Integer(2), data.get("bbb"));
174         assertEquals(new Integer(3), data.get("zzz"));
175         Map developers = parsed.getDevelopers();
176         assertNotNull(developers);
177         assertEquals(2, developers.size());
178         Object o1 = developers.get("team1");
179         // because of erasure we get simply Map
180         Map<String, String> developer = (Map<String, String>) o1;
181         assertEquals("Fred", developer.get("name"));
182         assertEquals("creator", developer.get("role"));
183     }
184 
185     @SuppressWarnings("rawtypes")
186     public static class MapBeanNoGenerics {
187         private Map data;
188         private String name;
189         private Map developers;
190 
191         public MapBeanNoGenerics() {
192             name = "Bean123";
193         }
194 
195         public Map getData() {
196             return data;
197         }
198 
199         public void setData(Map data) {
200             this.data = data;
201         }
202 
203         public String getName() {
204             return name;
205         }
206 
207         public void setName(String name) {
208             this.name = name;
209         }
210 
211         public Map getDevelopers() {
212             return developers;
213         }
214 
215         public void setDevelopers(Map developers) {
216             this.developers = developers;
217         }
218     }
219 }