/**
* Copyright (c) 2008-2012, http://www.snakeyaml.org
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.pyyaml;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import org.yaml.snakeyaml.DumperOptions;
import org.yaml.snakeyaml.emitter.Emitter;
import org.yaml.snakeyaml.emitter.EventConstructor;
import org.yaml.snakeyaml.events.CollectionStartEvent;
import org.yaml.snakeyaml.events.Event;
import org.yaml.snakeyaml.events.MappingStartEvent;
import org.yaml.snakeyaml.events.NodeEvent;
import org.yaml.snakeyaml.events.ScalarEvent;
import org.yaml.snakeyaml.events.SequenceStartEvent;
import org.yaml.snakeyaml.parser.Parser;
import org.yaml.snakeyaml.parser.ParserImpl;
import org.yaml.snakeyaml.reader.StreamReader;
import org.yaml.snakeyaml.reader.UnicodeReader;
/**
* @see imported from PyYAML
*/
public class PyEmitterTest extends PyImportTest {
public void testEmitterOnData() {
_testEmitter(".data", false);
}
public void testEmitterOnCanonicalNormally() {
_testEmitter(".canonical", false);
}
public void testEmitterOnCanonicalCanonically() {
_testEmitter(".canonical", true);
}
private void _testEmitter(String mask, boolean canonical) {
File[] files = getStreamsByExtension(mask, true);
assertTrue("No test files found.", files.length > 0);
for (File file : files) {
// if (!file.getName().contains("spec-06-01.canonical")) {
// continue;
// }
try {
InputStream input = new FileInputStream(file);
List<Event> events = parse(input);
input.close();
//
StringWriter stream = new StringWriter();
DumperOptions options = new DumperOptions();
options.setCanonical(canonical);
Emitter emitter = new Emitter(stream, options);
for (Event event : events) {
emitter.emit(event);
}
//
String data = stream.toString();
List<Event> newEvents = new ArrayList<Event>();
StreamReader reader = new StreamReader(data);
Parser parser = new ParserImpl(reader);
while (parser.peekEvent() != null) {
Event event = parser.getEvent();
newEvents.add(event);
}
// check
assertEquals(events.size(), newEvents.size());
Iterator<Event> iter1 = events.iterator();
Iterator<Event> iter2 = newEvents.iterator();
while (iter1.hasNext()) {
Event event = iter1.next();
Event newEvent = iter2.next();
assertEquals(event.getClass().getName(), newEvent.getClass().getName());
if (event instanceof NodeEvent) {
NodeEvent e1 = (NodeEvent) event;
NodeEvent e2 = (NodeEvent) newEvent;
assertEquals(e1.getAnchor(), e2.getAnchor());
}
if (event instanceof CollectionStartEvent) {
CollectionStartEvent e1 = (CollectionStartEvent) event;
CollectionStartEvent e2 = (CollectionStartEvent) newEvent;
assertEquals(e1.getTag(), e2.getTag());
}
if (event instanceof ScalarEvent) {
ScalarEvent e1 = (ScalarEvent) event;
ScalarEvent e2 = (ScalarEvent) newEvent;
if (e1.getImplicit().bothFalse() && e2.getImplicit().bothFalse()) {
assertEquals(e1.getTag(), e2.getTag());
}
assertEquals(e1.getValue(), e2.getValue());
}
}
} catch (Exception e) {
System.out.println("Failed File: " + file);
// fail("Failed File: " + file + "; " + e.getMessage());
throw new RuntimeException(e);
}
}
}
public void testEmitterStyles() {
File[] canonicalFiles = getStreamsByExtension(".canonical", false);
assertTrue("No test files found.", canonicalFiles.length > 0);
File[] dataFiles = getStreamsByExtension(".data", true);
assertTrue("No test files found.", dataFiles.length > 0);
List<File> allFiles = new ArrayList<File>(Arrays.asList(canonicalFiles));
allFiles.addAll(Arrays.asList(dataFiles));
for (File file : allFiles) {
try {
List<Event> events = new ArrayList<Event>();
InputStream input = new FileInputStream(file);
StreamReader reader = new StreamReader(new UnicodeReader(input));
Parser parser = new ParserImpl(reader);
while (parser.peekEvent() != null) {
Event event = parser.getEvent();
events.add(event);
}
input.close();
//
for (Boolean flowStyle : new Boolean[] { Boolean.FALSE, Boolean.TRUE }) {
for (DumperOptions.ScalarStyle style : DumperOptions.ScalarStyle.values()) {
List<Event> styledEvents = new ArrayList<Event>();
for (Event event : events) {
if (event instanceof ScalarEvent) {
ScalarEvent scalar = (ScalarEvent) event;
event = new ScalarEvent(scalar.getAnchor(), scalar.getTag(),
scalar.getImplicit(), scalar.getValue(),
scalar.getStartMark(), scalar.getEndMark(), style.getChar());
} else if (event instanceof SequenceStartEvent) {
SequenceStartEvent seqStart = (SequenceStartEvent) event;
event = new SequenceStartEvent(seqStart.getAnchor(),
seqStart.getTag(), seqStart.getImplicit(),
seqStart.getStartMark(), seqStart.getEndMark(), flowStyle);
} else if (event instanceof MappingStartEvent) {
MappingStartEvent mapStart = (MappingStartEvent) event;
event = new MappingStartEvent(mapStart.getAnchor(),
mapStart.getTag(), mapStart.getImplicit(),
mapStart.getStartMark(), mapStart.getEndMark(), flowStyle);
}
styledEvents.add(event);
}
// emit
String data = emit(styledEvents);
List<Event> newEvents = parse(data);
assertEquals("Events must not change. File: " + file, events.size(),
newEvents.size());
Iterator<Event> oldIter = events.iterator();
Iterator<Event> newIter = newEvents.iterator();
while (oldIter.hasNext()) {
Event event = oldIter.next();
Event newEvent = newIter.next();
assertEquals(event.getClass(), newEvent.getClass());
if (event instanceof NodeEvent) {
assertEquals(((NodeEvent) event).getAnchor(),
((NodeEvent) newEvent).getAnchor());
}
if (event instanceof CollectionStartEvent) {
assertEquals(((CollectionStartEvent) event).getTag(),
((CollectionStartEvent) newEvent).getTag());
}
if (event instanceof ScalarEvent) {
ScalarEvent scalarOld = (ScalarEvent) event;
ScalarEvent scalarNew = (ScalarEvent) newEvent;
if (scalarOld.getImplicit().bothFalse()
&& scalarNew.getImplicit().bothFalse()) {
assertEquals(scalarOld.getTag(), scalarNew.getTag());
}
assertEquals(scalarOld.getValue(), scalarNew.getValue());
}
}
}
}
} catch (Exception e) {
System.out.println("Failed File: " + file);
// fail("Failed File: " + file + "; " + e.getMessage());
throw new RuntimeException(e);
}
}
}
private String emit(List<Event> events) throws IOException {
StringWriter writer = new StringWriter();
Emitter emitter = new Emitter(writer, new DumperOptions());
for (Event event : events) {
emitter.emit(event);
}
return writer.toString();
}
private List<Event> parse(String data) {
ParserImpl parser = new ParserImpl(new StreamReader(data));
List<Event> newEvents = new ArrayList<Event>();
while (parser.peekEvent() != null) {
newEvents.add(parser.getEvent());
}
return newEvents;
}
@SuppressWarnings("unchecked")
public void testEmitterEvents() {
File[] files = getStreamsByExtension(".events", false);
assertTrue("No test files found.", files.length > 0);
for (File file : files) {
// if (!file.getName().contains("spec-06-01.canonical")) {
// continue;
// }
try {
List<Event> events = new ArrayList<Event>();
String content = getResource(file.getName());
events = (List<Event>) load(new EventConstructor(), content);
//
StringWriter stream = new StringWriter();
Emitter emitter = new Emitter(stream, new DumperOptions());
for (Event event : events) {
emitter.emit(event);
}
//
String data = stream.toString();
List<Event> newEvents = new ArrayList<Event>();
StreamReader reader = new StreamReader(data);
Parser parser = new ParserImpl(reader);
while (parser.peekEvent() != null) {
Event event = parser.getEvent();
newEvents.add(event);
}
// check
assertEquals(events.size(), newEvents.size());
Iterator<Event> iter1 = events.iterator();
Iterator<Event> iter2 = newEvents.iterator();
while (iter1.hasNext()) {
Event event = iter1.next();
Event newEvent = iter2.next();
assertEquals(event.getClass().getName(), newEvent.getClass().getName());
if (event instanceof NodeEvent) {
NodeEvent e1 = (NodeEvent) event;
NodeEvent e2 = (NodeEvent) newEvent;
assertEquals(e1.getAnchor(), e2.getAnchor());
}
if (event instanceof CollectionStartEvent) {
CollectionStartEvent e1 = (CollectionStartEvent) event;
CollectionStartEvent e2 = (CollectionStartEvent) newEvent;
assertEquals(e1.getTag(), e2.getTag());
}
if (event instanceof ScalarEvent) {
ScalarEvent e1 = (ScalarEvent) event;
ScalarEvent e2 = (ScalarEvent) newEvent;
if (e1.getImplicit().canOmitTagInPlainScalar() == e2.getImplicit()
.canOmitTagInPlainScalar()
&& e1.getImplicit().canOmitTagInNonPlainScalar() == e2
.getImplicit().canOmitTagInNonPlainScalar()) {
} else {
if ((e1.getTag() == null || e2.getTag() == null)
|| e1.getTag().equals(e2.getTag())) {
} else {
System.out.println("tag1: " + e1.getTag());
System.out.println("tag2: " + e2.getTag());
fail("in file: " + file);
}
}
assertEquals(e1.getValue(), e2.getValue());
}
}
} catch (Exception e) {
System.out.println("Failed File: " + file);
// fail("Failed File: " + file + "; " + e.getMessage());
throw new RuntimeException(e);
}
}
}
}