1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.pyyaml;
18
19 import java.io.File;
20 import java.io.FileInputStream;
21 import java.io.IOException;
22 import java.io.InputStream;
23 import java.io.StringWriter;
24 import java.util.ArrayList;
25 import java.util.Arrays;
26 import java.util.Iterator;
27 import java.util.List;
28
29 import org.yaml.snakeyaml.DumperOptions;
30 import org.yaml.snakeyaml.emitter.Emitter;
31 import org.yaml.snakeyaml.emitter.EventConstructor;
32 import org.yaml.snakeyaml.events.CollectionStartEvent;
33 import org.yaml.snakeyaml.events.Event;
34 import org.yaml.snakeyaml.events.MappingStartEvent;
35 import org.yaml.snakeyaml.events.NodeEvent;
36 import org.yaml.snakeyaml.events.ScalarEvent;
37 import org.yaml.snakeyaml.events.SequenceStartEvent;
38 import org.yaml.snakeyaml.parser.Parser;
39 import org.yaml.snakeyaml.parser.ParserImpl;
40 import org.yaml.snakeyaml.reader.StreamReader;
41 import org.yaml.snakeyaml.reader.UnicodeReader;
42
43
44
45
46 public class PyEmitterTest extends PyImportTest {
47 public void testEmitterOnData() throws IOException {
48 _testEmitter(".data", false);
49 }
50
51 public void testEmitterOnCanonicalNormally() throws IOException {
52 _testEmitter(".canonical", false);
53 }
54
55 public void testEmitterOnCanonicalCanonically() throws IOException {
56 _testEmitter(".canonical", true);
57 }
58
59 private void _testEmitter(String mask, boolean canonical) throws IOException {
60 File[] files = getStreamsByExtension(mask, true);
61 assertTrue("No test files found.", files.length > 0);
62 for (File file : files) {
63
64
65
66 try {
67 InputStream input = new FileInputStream(file);
68 List<Event> events = parse(input);
69 input.close();
70
71 StringWriter stream = new StringWriter();
72 DumperOptions options = new DumperOptions();
73 options.setCanonical(canonical);
74 Emitter emitter = new Emitter(stream, options);
75 for (Event event : events) {
76 emitter.emit(event);
77 }
78
79 String data = stream.toString();
80 List<Event> newEvents = new ArrayList<Event>();
81 StreamReader reader = new StreamReader(data);
82 Parser parser = new ParserImpl(reader);
83 while (parser.peekEvent() != null) {
84 Event event = parser.getEvent();
85 newEvents.add(event);
86 }
87
88 assertEquals(events.size(), newEvents.size());
89 Iterator<Event> iter1 = events.iterator();
90 Iterator<Event> iter2 = newEvents.iterator();
91 while (iter1.hasNext()) {
92 Event event = iter1.next();
93 Event newEvent = iter2.next();
94 assertEquals(event.getClass().getName(), newEvent.getClass().getName());
95 if (event instanceof NodeEvent) {
96 NodeEvent e1 = (NodeEvent) event;
97 NodeEvent e2 = (NodeEvent) newEvent;
98 assertEquals(e1.getAnchor(), e2.getAnchor());
99 }
100 if (event instanceof CollectionStartEvent) {
101 CollectionStartEvent e1 = (CollectionStartEvent) event;
102 CollectionStartEvent e2 = (CollectionStartEvent) newEvent;
103 assertEquals(e1.getTag(), e2.getTag());
104 }
105 if (event instanceof ScalarEvent) {
106 ScalarEvent e1 = (ScalarEvent) event;
107 ScalarEvent e2 = (ScalarEvent) newEvent;
108 if (e1.getImplicit().bothFalse() && e2.getImplicit().bothFalse()) {
109 assertEquals(e1.getTag(), e2.getTag());
110 }
111 assertEquals(e1.getValue(), e2.getValue());
112 }
113 }
114 } catch (Exception e) {
115 System.out.println("Failed File: " + file);
116
117 throw new RuntimeException(e);
118 }
119 }
120 }
121
122 public void testEmitterStyles() throws IOException {
123 File[] canonicalFiles = getStreamsByExtension(".canonical", false);
124 assertTrue("No test files found.", canonicalFiles.length > 0);
125 File[] dataFiles = getStreamsByExtension(".data", true);
126 assertTrue("No test files found.", dataFiles.length > 0);
127 List<File> allFiles = new ArrayList<File>(Arrays.asList(canonicalFiles));
128 allFiles.addAll(Arrays.asList(dataFiles));
129 for (File file : allFiles) {
130 try {
131 List<Event> events = new ArrayList<Event>();
132 InputStream input = new FileInputStream(file);
133 StreamReader reader = new StreamReader(new UnicodeReader(input));
134 Parser parser = new ParserImpl(reader);
135 while (parser.peekEvent() != null) {
136 Event event = parser.getEvent();
137 events.add(event);
138 }
139 input.close();
140
141 for (Boolean flowStyle : new Boolean[] { Boolean.FALSE, Boolean.TRUE }) {
142 for (DumperOptions.ScalarStyle style : DumperOptions.ScalarStyle.values()) {
143 List<Event> styledEvents = new ArrayList<Event>();
144 for (Event event : events) {
145 if (event instanceof ScalarEvent) {
146 ScalarEvent scalar = (ScalarEvent) event;
147 event = new ScalarEvent(scalar.getAnchor(), scalar.getTag(),
148 scalar.getImplicit(), scalar.getValue(),
149 scalar.getStartMark(), scalar.getEndMark(), style.getChar());
150 } else if (event instanceof SequenceStartEvent) {
151 SequenceStartEvent seqStart = (SequenceStartEvent) event;
152 event = new SequenceStartEvent(seqStart.getAnchor(),
153 seqStart.getTag(), seqStart.getImplicit(),
154 seqStart.getStartMark(), seqStart.getEndMark(), flowStyle);
155 } else if (event instanceof MappingStartEvent) {
156 MappingStartEvent mapStart = (MappingStartEvent) event;
157 event = new MappingStartEvent(mapStart.getAnchor(),
158 mapStart.getTag(), mapStart.getImplicit(),
159 mapStart.getStartMark(), mapStart.getEndMark(), flowStyle);
160 }
161 styledEvents.add(event);
162 }
163
164 String data = emit(styledEvents);
165 List<Event> newEvents = parse(data);
166 assertEquals("Events must not change. File: " + file, events.size(),
167 newEvents.size());
168 Iterator<Event> oldIter = events.iterator();
169 Iterator<Event> newIter = newEvents.iterator();
170 while (oldIter.hasNext()) {
171 Event event = oldIter.next();
172 Event newEvent = newIter.next();
173 assertEquals(event.getClass(), newEvent.getClass());
174 if (event instanceof NodeEvent) {
175 assertEquals(((NodeEvent) event).getAnchor(),
176 ((NodeEvent) newEvent).getAnchor());
177 }
178 if (event instanceof CollectionStartEvent) {
179 assertEquals(((CollectionStartEvent) event).getTag(),
180 ((CollectionStartEvent) newEvent).getTag());
181 }
182 if (event instanceof ScalarEvent) {
183 ScalarEvent scalarOld = (ScalarEvent) event;
184 ScalarEvent scalarNew = (ScalarEvent) newEvent;
185 if (scalarOld.getImplicit().bothFalse()
186 && scalarNew.getImplicit().bothFalse()) {
187 assertEquals(scalarOld.getTag(), scalarNew.getTag());
188 }
189 assertEquals(scalarOld.getValue(), scalarNew.getValue());
190 }
191 }
192 }
193 }
194
195 } catch (Exception e) {
196 System.out.println("Failed File: " + file);
197
198 throw new RuntimeException(e);
199 }
200 }
201 }
202
203 private String emit(List<Event> events) throws IOException {
204 StringWriter writer = new StringWriter();
205 Emitter emitter = new Emitter(writer, new DumperOptions());
206 for (Event event : events) {
207 emitter.emit(event);
208 }
209 return writer.toString();
210 }
211
212 private List<Event> parse(String data) {
213 ParserImpl parser = new ParserImpl(new StreamReader(data));
214 List<Event> newEvents = new ArrayList<Event>();
215 while (parser.peekEvent() != null) {
216 newEvents.add(parser.getEvent());
217 }
218 return newEvents;
219 }
220
221 @SuppressWarnings("unchecked")
222 public void testEmitterEvents() throws IOException {
223 File[] files = getStreamsByExtension(".events", false);
224 assertTrue("No test files found.", files.length > 0);
225 for (File file : files) {
226
227
228
229 try {
230 List<Event> events = new ArrayList<Event>();
231 String content = getResource(file.getName());
232 events = (List<Event>) load(new EventConstructor(), content);
233
234 StringWriter stream = new StringWriter();
235 Emitter emitter = new Emitter(stream, new DumperOptions());
236 for (Event event : events) {
237 emitter.emit(event);
238 }
239
240 String data = stream.toString();
241 List<Event> newEvents = new ArrayList<Event>();
242 StreamReader reader = new StreamReader(data);
243 Parser parser = new ParserImpl(reader);
244 while (parser.peekEvent() != null) {
245 Event event = parser.getEvent();
246 newEvents.add(event);
247 }
248
249 assertEquals(events.size(), newEvents.size());
250 Iterator<Event> iter1 = events.iterator();
251 Iterator<Event> iter2 = newEvents.iterator();
252 while (iter1.hasNext()) {
253 Event event = iter1.next();
254 Event newEvent = iter2.next();
255 assertEquals(event.getClass().getName(), newEvent.getClass().getName());
256 if (event instanceof NodeEvent) {
257 NodeEvent e1 = (NodeEvent) event;
258 NodeEvent e2 = (NodeEvent) newEvent;
259 assertEquals(e1.getAnchor(), e2.getAnchor());
260 }
261 if (event instanceof CollectionStartEvent) {
262 CollectionStartEvent e1 = (CollectionStartEvent) event;
263 CollectionStartEvent e2 = (CollectionStartEvent) newEvent;
264 assertEquals(e1.getTag(), e2.getTag());
265 }
266 if (event instanceof ScalarEvent) {
267 ScalarEvent e1 = (ScalarEvent) event;
268 ScalarEvent e2 = (ScalarEvent) newEvent;
269 if (e1.getImplicit().canOmitTagInPlainScalar() == e2.getImplicit().canOmitTagInPlainScalar()
270 && e1.getImplicit().canOmitTagInNonPlainScalar() == e2.getImplicit().canOmitTagInNonPlainScalar()) {
271
272 } else {
273 if ((e1.getTag() == null || e2.getTag() == null)
274 || e1.getTag().equals(e2.getTag())) {
275 } else {
276 System.out.println("tag1: " + e1.getTag());
277 System.out.println("tag2: " + e2.getTag());
278 fail("in file: " + file);
279 }
280 }
281 assertEquals(e1.getValue(), e2.getValue());
282 }
283 }
284 } catch (Exception e) {
285 System.out.println("Failed File: " + file);
286
287 throw new RuntimeException(e);
288 }
289 }
290 }
291 }