diff options
Diffstat (limited to 'src/test/java/org/pyyaml')
| -rw-r--r-- | src/test/java/org/pyyaml/AnInstance.java | 34 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/CanonicalException.java | 19 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/CanonicalLoader.java | 72 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/CanonicalParser.java | 198 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/CanonicalScanner.java | 301 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/PyCanonicalTest.java | 53 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/PyEmitterTest.java | 284 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/PyErrorsTest.java | 120 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/PyImportTest.java | 128 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/PyMarkTest.java | 45 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/PyReaderTest.java | 36 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/PyRecursiveTest.java | 63 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/PyStructureTest.java | 287 | ||||
| -rw-r--r-- | src/test/java/org/pyyaml/PyTokensTest.java | 140 |
14 files changed, 1780 insertions, 0 deletions
diff --git a/src/test/java/org/pyyaml/AnInstance.java b/src/test/java/org/pyyaml/AnInstance.java new file mode 100644 index 00000000..655360dc --- /dev/null +++ b/src/test/java/org/pyyaml/AnInstance.java @@ -0,0 +1,34 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+public class AnInstance {
+ private Object foo;
+ private Object bar;
+
+ public AnInstance() {
+ }
+
+ public AnInstance(Object foo, Object bar) {
+ this.foo = foo;
+ this.bar = bar;
+ }
+
+ public Object getFoo() {
+ return foo;
+ }
+
+ public void setFoo(Object foo) {
+ this.foo = foo;
+ }
+
+ public Object getBar() {
+ return bar;
+ }
+
+ public void setBar(Object bar) {
+ this.bar = bar;
+ }
+
+}
\ No newline at end of file diff --git a/src/test/java/org/pyyaml/CanonicalException.java b/src/test/java/org/pyyaml/CanonicalException.java new file mode 100644 index 00000000..4bec5757 --- /dev/null +++ b/src/test/java/org/pyyaml/CanonicalException.java @@ -0,0 +1,19 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import org.yaml.snakeyaml.error.YAMLException;
+
+public class CanonicalException extends YAMLException {
+
+ private static final long serialVersionUID = -6489045150083747626L;
+
+ public CanonicalException(String message) {
+ super(message);
+ }
+
+ public CanonicalException(Throwable cause) {
+ super(cause);
+ }
+}
diff --git a/src/test/java/org/pyyaml/CanonicalLoader.java b/src/test/java/org/pyyaml/CanonicalLoader.java new file mode 100644 index 00000000..6d54306c --- /dev/null +++ b/src/test/java/org/pyyaml/CanonicalLoader.java @@ -0,0 +1,72 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import org.yaml.snakeyaml.Loader;
+import org.yaml.snakeyaml.composer.Composer;
+import org.yaml.snakeyaml.error.YAMLException;
+
+public class CanonicalLoader extends Loader {
+ @Override
+ public Object load(java.io.Reader yaml) {
+ try {
+ int ch = yaml.read();
+ StringBuffer buffer = new StringBuffer();
+ while (ch != -1) {
+ buffer.append((char) ch);
+ ch = yaml.read();
+ }
+ Composer composer = new Composer(new CanonicalParser(buffer.toString()), resolver);
+ constructor.setComposer(composer);
+ return constructor.getSingleData();
+ } catch (IOException e) {
+ throw new YAMLException(e);
+ }
+ }
+
+ public Iterable<Object> loadAll(java.io.Reader yaml) {
+ try {
+ int ch = yaml.read();
+ StringBuffer buffer = new StringBuffer();
+ while (ch != -1) {
+ buffer.append((char) ch);
+ ch = yaml.read();
+ }
+ Composer composer = new Composer(new CanonicalParser(buffer.toString()), resolver);
+ this.constructor.setComposer(composer);
+ Iterator<Object> result = new Iterator<Object>() {
+ public boolean hasNext() {
+ return constructor.checkData();
+ }
+
+ public Object next() {
+ return constructor.getData();
+ }
+
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+ };
+ return new YamlIterable(result);
+ } catch (IOException e) {
+ throw new YAMLException(e);
+ }
+ }
+
+ private class YamlIterable implements Iterable<Object> {
+ private Iterator<Object> iterator;
+
+ public YamlIterable(Iterator<Object> iterator) {
+ this.iterator = iterator;
+ }
+
+ public Iterator<Object> iterator() {
+ return iterator;
+ }
+
+ }
+}
diff --git a/src/test/java/org/pyyaml/CanonicalParser.java b/src/test/java/org/pyyaml/CanonicalParser.java new file mode 100644 index 00000000..f3a302f3 --- /dev/null +++ b/src/test/java/org/pyyaml/CanonicalParser.java @@ -0,0 +1,198 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.yaml.snakeyaml.events.AliasEvent;
+import org.yaml.snakeyaml.events.DocumentEndEvent;
+import org.yaml.snakeyaml.events.DocumentStartEvent;
+import org.yaml.snakeyaml.events.Event;
+import org.yaml.snakeyaml.events.MappingEndEvent;
+import org.yaml.snakeyaml.events.MappingStartEvent;
+import org.yaml.snakeyaml.events.ScalarEvent;
+import org.yaml.snakeyaml.events.SequenceEndEvent;
+import org.yaml.snakeyaml.events.SequenceStartEvent;
+import org.yaml.snakeyaml.events.StreamEndEvent;
+import org.yaml.snakeyaml.events.StreamStartEvent;
+import org.yaml.snakeyaml.parser.Parser;
+import org.yaml.snakeyaml.tokens.AliasToken;
+import org.yaml.snakeyaml.tokens.AnchorToken;
+import org.yaml.snakeyaml.tokens.DirectiveToken;
+import org.yaml.snakeyaml.tokens.DocumentStartToken;
+import org.yaml.snakeyaml.tokens.FlowEntryToken;
+import org.yaml.snakeyaml.tokens.FlowMappingEndToken;
+import org.yaml.snakeyaml.tokens.FlowMappingStartToken;
+import org.yaml.snakeyaml.tokens.FlowSequenceEndToken;
+import org.yaml.snakeyaml.tokens.FlowSequenceStartToken;
+import org.yaml.snakeyaml.tokens.KeyToken;
+import org.yaml.snakeyaml.tokens.ScalarToken;
+import org.yaml.snakeyaml.tokens.StreamEndToken;
+import org.yaml.snakeyaml.tokens.StreamStartToken;
+import org.yaml.snakeyaml.tokens.TagToken;
+import org.yaml.snakeyaml.tokens.Token;
+import org.yaml.snakeyaml.tokens.ValueToken;
+
+public class CanonicalParser implements Parser {
+ private LinkedList<Event> events;
+ private boolean parsed;
+ private CanonicalScanner scanner;
+
+ public CanonicalParser(String data) {
+ events = new LinkedList<Event>();
+ parsed = false;
+ scanner = new CanonicalScanner(data);
+ }
+
+ // stream: STREAM-START document* STREAM-END
+ private void parseStream() {
+ scanner.getToken(StreamStartToken.class);
+ events.add(new StreamStartEvent(null, null));
+ while (!scanner.checkToken(StreamEndToken.class)) {
+ List<Class<? extends Token>> list = new ArrayList<Class<? extends Token>>();
+ list.add(DirectiveToken.class);
+ list.add(DocumentStartToken.class);
+ if (scanner.checkToken(list)) {
+ parseDocument();
+ } else {
+ throw new CanonicalException("document is expected, got " + scanner.tokens.get(0));
+ }
+ }
+ scanner.getToken(StreamEndToken.class);
+ events.add(new StreamEndEvent(null, null));
+ }
+
+ // document: DIRECTIVE? DOCUMENT-START node
+ private void parseDocument() {
+ if (scanner.checkToken(DirectiveToken.class)) {
+ scanner.getToken(DirectiveToken.class);
+ }
+ scanner.getToken(DocumentStartToken.class);
+ events.add(new DocumentStartEvent(null, null, true, new Integer[] { 1, 1 }, null));
+ parseNode();
+ events.add(new DocumentEndEvent(null, null, true));
+ }
+
+ // node: ALIAS | ANCHOR? TAG? (SCALAR|sequence|mapping)
+ private void parseNode() {
+ if (scanner.checkToken(AliasToken.class)) {
+ AliasToken token = (AliasToken) scanner.getToken();
+ events.add(new AliasEvent(token.getValue(), null, null));
+ } else {
+ String anchor = null;
+ if (scanner.checkToken(AnchorToken.class)) {
+ AnchorToken token = (AnchorToken) scanner.getToken();
+ anchor = token.getValue();
+ }
+ String tag = null;
+ if (scanner.checkToken(TagToken.class)) {
+ TagToken token = (TagToken) scanner.getToken();
+ tag = token.getValue()[0] + token.getValue()[1];
+ }
+ if (scanner.checkToken(ScalarToken.class)) {
+ ScalarToken token = (ScalarToken) scanner.getToken();
+ events.add(new ScalarEvent(anchor, tag, new boolean[] { false, false }, token
+ .getValue(), null, null, null));
+ } else if (scanner.checkToken(FlowSequenceStartToken.class)) {
+ events.add(new SequenceStartEvent(anchor, tag, false, null, null, null));
+ parseSequence();
+ } else if (scanner.checkToken(FlowMappingStartToken.class)) {
+ events.add(new MappingStartEvent(anchor, tag, false, null, null, null));
+ parseMapping();
+ } else {
+ throw new CanonicalException("SCALAR, '[', or '{' is expected, got "
+ + scanner.tokens.get(0));
+ }
+ }
+ }
+
+ // sequence: SEQUENCE-START (node (ENTRY node)*)? ENTRY? SEQUENCE-END
+ private void parseSequence() {
+ scanner.getToken(FlowSequenceStartToken.class);
+ if (!scanner.checkToken(FlowSequenceEndToken.class)) {
+ parseNode();
+ while (!scanner.checkToken(FlowSequenceEndToken.class)) {
+ scanner.getToken(FlowEntryToken.class);
+ if (!scanner.checkToken(FlowSequenceEndToken.class)) {
+ parseNode();
+ }
+ }
+ }
+ scanner.getToken(FlowSequenceEndToken.class);
+ events.add(new SequenceEndEvent(null, null));
+ }
+
+ // mapping: MAPPING-START (map_entry (ENTRY map_entry)*)? ENTRY? MAPPING-END
+ private void parseMapping() {
+ scanner.getToken(FlowMappingStartToken.class);
+ if (!scanner.checkToken(FlowMappingEndToken.class)) {
+ parseMapEntry();
+ while (!scanner.checkToken(FlowMappingEndToken.class)) {
+ scanner.getToken(FlowEntryToken.class);
+ if (!scanner.checkToken(FlowMappingEndToken.class)) {
+ parseMapEntry();
+ }
+ }
+ }
+ scanner.getToken(FlowMappingEndToken.class);
+ events.add(new MappingEndEvent(null, null));
+ }
+
+ // map_entry: KEY node VALUE node
+ private void parseMapEntry() {
+ scanner.getToken(KeyToken.class);
+ parseNode();
+ scanner.getToken(ValueToken.class);
+ parseNode();
+ }
+
+ public void parse() {
+ parseStream();
+ parsed = true;
+ }
+
+ public Event getEvent() {
+ if (!parsed) {
+ parse();
+ }
+ return events.removeFirst();
+ }
+
+ public boolean checkEvent(List<Class<? extends Event>> choices) {
+ if (!parsed) {
+ parse();
+ }
+ if (!events.isEmpty()) {
+ if (choices.isEmpty()) {
+ return true;
+ }
+ for (Class<? extends Event> class1 : choices) {
+ if (class1.isInstance(events.peek())) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ public boolean checkEvent(Class<? extends Event> choice) {
+ List<Class<? extends Event>> list = new ArrayList<Class<? extends Event>>(1);
+ list.add(choice);
+ return checkEvent(list);
+ }
+
+ public Event peekEvent() {
+ if (!parsed) {
+ parse();
+ }
+ if (events.isEmpty()) {
+ return null;
+ } else {
+ return events.get(0);
+ }
+ }
+
+}
diff --git a/src/test/java/org/pyyaml/CanonicalScanner.java b/src/test/java/org/pyyaml/CanonicalScanner.java new file mode 100644 index 00000000..146cdf98 --- /dev/null +++ b/src/test/java/org/pyyaml/CanonicalScanner.java @@ -0,0 +1,301 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.yaml.snakeyaml.error.Mark;
+import org.yaml.snakeyaml.scanner.Scanner;
+import org.yaml.snakeyaml.scanner.ScannerImpl;
+import org.yaml.snakeyaml.tokens.AliasToken;
+import org.yaml.snakeyaml.tokens.AnchorToken;
+import org.yaml.snakeyaml.tokens.DirectiveToken;
+import org.yaml.snakeyaml.tokens.DocumentStartToken;
+import org.yaml.snakeyaml.tokens.FlowEntryToken;
+import org.yaml.snakeyaml.tokens.FlowMappingEndToken;
+import org.yaml.snakeyaml.tokens.FlowMappingStartToken;
+import org.yaml.snakeyaml.tokens.FlowSequenceEndToken;
+import org.yaml.snakeyaml.tokens.FlowSequenceStartToken;
+import org.yaml.snakeyaml.tokens.KeyToken;
+import org.yaml.snakeyaml.tokens.ScalarToken;
+import org.yaml.snakeyaml.tokens.StreamEndToken;
+import org.yaml.snakeyaml.tokens.StreamStartToken;
+import org.yaml.snakeyaml.tokens.TagToken;
+import org.yaml.snakeyaml.tokens.Token;
+import org.yaml.snakeyaml.tokens.ValueToken;
+
+public class CanonicalScanner implements Scanner {
+ private static final String DIRECTIVE = "%YAML 1.1";
+ private final static Map<Character, Integer> QUOTE_CODES = ScannerImpl.ESCAPE_CODES;
+
+ private final static Map<Character, String> QUOTE_REPLACES = ScannerImpl.ESCAPE_REPLACEMENTS;
+
+ private String data;
+ private int index;
+ public LinkedList<Token> tokens;
+ private boolean scanned;
+ private Mark mark;
+
+ public CanonicalScanner(String data) {
+ this.data = data + "\0";
+ this.index = 0;
+ this.tokens = new LinkedList<Token>();
+ this.scanned = false;
+ this.mark = new Mark("test", 0, 0, 0, data, 0);
+ }
+
+ public boolean checkToken(List<Class<? extends Token>> choices) {
+ if (!scanned) {
+ scan();
+ }
+ if (!tokens.isEmpty()) {
+ if (choices.isEmpty()) {
+ return true;
+ }
+ Token first = this.tokens.get(0);
+ for (Class<? extends Token> choice : choices) {
+ if (choice.isInstance(first)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ public boolean checkToken(Class<? extends Token> choice) {
+ List<Class<? extends Token>> list = new ArrayList<Class<? extends Token>>();
+ list.add(choice);
+ return checkToken(list);
+ }
+
+ public Token peekToken() {
+ if (!scanned) {
+ scan();
+ }
+ if (!tokens.isEmpty()) {
+ Token first = this.tokens.get(0);
+ return first;
+ }
+ return null;
+ }
+
+ public Token getToken() {
+ if (!scanned) {
+ scan();
+ }
+ Token token = this.tokens.poll();
+ return token;
+ }
+
+ public Token getToken(Class<? extends Token> choice) {
+ Token token = getToken();
+ if (choice != null && !choice.isInstance(token)) {
+ throw new CanonicalException("unexpected token " + token);
+ }
+ return token;
+ }
+
+ private void scan() {
+ this.tokens.add(new StreamStartToken(mark, mark));
+ boolean stop = false;
+ while (!stop) {
+ findToken();
+ char ch = data.charAt(index);
+ switch (ch) {
+ case '\0':
+ tokens.add(new StreamEndToken(mark, mark));
+ stop = true;
+ break;
+
+ case '%':
+ tokens.add(scanDirective());
+ break;
+
+ case '-':
+ if ("---".equals(data.substring(index, index + 3))) {
+ index += 3;
+ tokens.add(new DocumentStartToken(mark, mark));
+ }
+ break;
+
+ case '[':
+ index++;
+ tokens.add(new FlowSequenceStartToken(mark, mark));
+ break;
+
+ case '{':
+ index++;
+ tokens.add(new FlowMappingStartToken(mark, mark));
+ break;
+
+ case ']':
+ index++;
+ tokens.add(new FlowSequenceEndToken(mark, mark));
+ break;
+
+ case '}':
+ index++;
+ tokens.add(new FlowMappingEndToken(mark, mark));
+ break;
+
+ case '?':
+ index++;
+ tokens.add(new KeyToken(mark, mark));
+ break;
+
+ case ':':
+ index++;
+ tokens.add(new ValueToken(mark, mark));
+ break;
+
+ case ',':
+ index++;
+ tokens.add(new FlowEntryToken(mark, mark));
+ break;
+
+ case '*':
+ tokens.add(scanAlias());
+ break;
+
+ case '&':
+ tokens.add(scanAlias());
+ break;
+
+ case '!':
+ tokens.add(scanTag());
+ break;
+
+ case '"':
+ tokens.add(scanScalar());
+ break;
+
+ default:
+ throw new CanonicalException("invalid token");
+ }
+ }
+ scanned = true;
+ }
+
+ private Token scanDirective() {
+ String chunk1 = data.substring(index, index + DIRECTIVE.length());
+ char chunk2 = data.charAt(index + DIRECTIVE.length());
+ if (DIRECTIVE.equals(chunk1) && "\n\0".indexOf(chunk2) != -1) {
+ index += DIRECTIVE.length();
+ List<Integer> implicit = new ArrayList<Integer>(2);
+ implicit.add(new Integer(1));
+ implicit.add(new Integer(1));
+ return new DirectiveToken("YAML", implicit, mark, mark);
+ } else {
+ throw new CanonicalException("invalid directive");
+ }
+ }
+
+ private Token scanAlias() {
+ boolean isTokenClassAlias;
+ if (data.charAt(index) == '*') {
+ isTokenClassAlias = true;
+ } else {
+ isTokenClassAlias = false;
+ }
+ index++;
+ int start = index;
+ while (", \n\0".indexOf(data.charAt(index)) == -1) {
+ index++;
+ }
+ String value = data.substring(start, index);
+ Token token;
+ if (isTokenClassAlias) {
+ token = new AliasToken(value, mark, mark);
+ } else {
+ token = new AnchorToken(value, mark, mark);
+ }
+ return token;
+ }
+
+ private Token scanTag() {
+ index++;
+ int start = index;
+ while (" \n\0".indexOf(data.charAt(index)) == -1) {
+ index++;
+ }
+ String value = data.substring(start, index);
+ if (value.length() == 0) {
+ value = "!";
+ } else if (value.charAt(0) == '!') {
+ value = "tag:yaml.org,2002:" + value.substring(1);
+ } else if (value.charAt(0) == '<' && value.charAt(value.length() - 1) == '>') {
+ value = value.substring(1, value.length() - 1);
+ } else {
+ value = "!" + value;
+ }
+ return new TagToken(new String[] { "", value }, mark, mark);
+ }
+
+ private Token scanScalar() {
+ index++;
+ StringBuffer chunks = new StringBuffer();
+ int start = index;
+ boolean ignoreSpaces = false;
+ while (data.charAt(index) != '"') {
+ if (data.charAt(index) == '\\') {
+ ignoreSpaces = false;
+ chunks.append(data.substring(start, index));
+ index++;
+ char ch = data.charAt(index);
+ index++;
+ if (ch == '\n') {
+ ignoreSpaces = true;
+ } else if (QUOTE_CODES.keySet().contains(ch)) {
+ int length = QUOTE_CODES.get(ch);
+ int code = Integer.parseInt(data.substring(index, index + length), 16);
+ chunks.append(String.valueOf((char) code));
+ index += length;
+ } else {
+ if (!QUOTE_REPLACES.keySet().contains(ch)) {
+ throw new CanonicalException("invalid escape code");
+ }
+ chunks.append(QUOTE_REPLACES.get(ch));
+ }
+ start = index;
+ } else if (data.charAt(index) == '\n') {
+ chunks.append(data.substring(start, index));
+ chunks.append(" ");
+ index++;
+ start = index;
+ ignoreSpaces = true;
+ } else if (ignoreSpaces && data.charAt(index) == ' ') {
+ index++;
+ start = index;
+ } else {
+ ignoreSpaces = false;
+ index++;
+ }
+ }
+ chunks.append(data.substring(start, index));
+ index++;
+ return new ScalarToken(chunks.toString(), mark, mark, false);
+ }
+
+ private void findToken() {
+ boolean found = false;
+ while (!found) {
+ while (" \t".indexOf(data.charAt(index)) != -1) {
+ index++;
+ }
+ if (data.charAt(index) == '#') {
+ while (data.charAt(index) != '\n') {
+ index++;
+ }
+ }
+ if (data.charAt(index) == '\n') {
+ index++;
+ } else {
+ found = true;
+ }
+ }
+ }
+}
diff --git a/src/test/java/org/pyyaml/PyCanonicalTest.java b/src/test/java/org/pyyaml/PyCanonicalTest.java new file mode 100644 index 00000000..41a9e8e2 --- /dev/null +++ b/src/test/java/org/pyyaml/PyCanonicalTest.java @@ -0,0 +1,53 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.yaml.snakeyaml.events.Event;
+import org.yaml.snakeyaml.tokens.Token;
+
+/**
+ * @see imported from PyYAML
+ */
+public class PyCanonicalTest extends PyImportTest {
+
+ public void testCanonicalScanner() throws IOException {
+ File[] files = getStreamsByExtension(".canonical");
+ assertTrue("No test files found.", files.length > 0);
+ for (int i = 0; i < files.length; i++) {
+ List<Token> tokens = canonicalScan(new FileInputStream(files[i]));
+ assertFalse(tokens.isEmpty());
+ }
+ }
+
+ private List<Token> canonicalScan(InputStream input) throws IOException {
+ int ch = input.read();
+ StringBuffer buffer = new StringBuffer();
+ while (ch != -1) {
+ buffer.append((char) ch);
+ ch = input.read();
+ }
+ CanonicalScanner scanner = new CanonicalScanner(buffer.toString());
+ List<Token> result = new LinkedList<Token>();
+ while (scanner.peekToken() != null) {
+ result.add(scanner.getToken());
+ }
+ return result;
+ }
+
+ public void testCanonicalParser() throws IOException {
+ File[] files = getStreamsByExtension(".canonical");
+ assertTrue("No test files found.", files.length > 0);
+ for (int i = 0; i < files.length; i++) {
+ List<Event> tokens = canonicalParse(new FileInputStream(files[i]));
+ assertFalse(tokens.isEmpty());
+ }
+ }
+}
diff --git a/src/test/java/org/pyyaml/PyEmitterTest.java b/src/test/java/org/pyyaml/PyEmitterTest.java new file mode 100644 index 00000000..f2de9a65 --- /dev/null +++ b/src/test/java/org/pyyaml/PyEmitterTest.java @@ -0,0 +1,284 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Loader;
+import org.yaml.snakeyaml.emitter.Emitter;
+import org.yaml.snakeyaml.emitter.EventsLoader;
+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.Reader;
+import org.yaml.snakeyaml.reader.UnicodeReader;
+
+/**
+ * @see imported from PyYAML
+ */
+public class PyEmitterTest extends PyImportTest {
+ public void testEmitterOnData() throws IOException {
+ _testEmitter(".data", false);
+ }
+
+ public void testEmitterOnCanonicalNormally() throws IOException {
+ _testEmitter(".canonical", false);
+ }
+
+ public void testEmitterOnCanonicalCanonically() throws IOException {
+ _testEmitter(".canonical", true);
+ }
+
+ private void _testEmitter(String mask, boolean canonical) throws IOException {
+ 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 {
+ List<Event> events = parse(new FileInputStream(file));
+ //
+ 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 LinkedList<Event>();
+ Reader reader = new Reader(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;
+ boolean[] implicit1 = e1.getImplicit();
+ boolean[] implicit2 = e2.getImplicit();
+ if (!implicit1[0] && !implicit1[1] && !implicit2[0] && !implicit2[1]) {
+ 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);
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public void testEmitterStyles() throws IOException {
+ 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 LinkedList(Arrays.asList(canonicalFiles));
+ allFiles.addAll(Arrays.asList(dataFiles));
+ for (File file : allFiles) {
+ try {
+ List<Event> events = new LinkedList<Event>();
+ Reader reader = new Reader(new UnicodeReader(new FileInputStream(file)));
+ Parser parser = new ParserImpl(reader);
+ while (parser.peekEvent() != null) {
+ Event event = parser.getEvent();
+ events.add(event);
+ }
+ //
+ for (Boolean flowStyle : new Boolean[] { Boolean.FALSE, Boolean.TRUE }) {
+ for (DumperOptions.DefaultScalarStyle style : DumperOptions.DefaultScalarStyle
+ .values()) {
+ List<Event> styledEvents = new LinkedList<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;
+ boolean[] oldImplicit = scalarOld.getImplicit();
+ boolean[] newImplicit = scalarNew.getImplicit();
+ if (!oldImplicit[0] && !oldImplicit[1] && !newImplicit[0]
+ && !newImplicit[1]) {
+ 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 Reader(data));
+ List<Event> newEvents = new LinkedList<Event>();
+ while (parser.peekEvent() != null) {
+ newEvents.add(parser.getEvent());
+ }
+ return newEvents;
+ }
+
+ @SuppressWarnings("unchecked")
+ public void testEmitterEvents() throws IOException {
+ 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 {
+ Loader loader = new EventsLoader();
+ List<Event> events = new LinkedList<Event>();
+ String content = getResource(file.getName());
+ events = (List<Event>) load(loader, 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 LinkedList<Event>();
+ Reader reader = new Reader(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;
+ boolean[] implicit1 = e1.getImplicit();
+ boolean[] implicit2 = e2.getImplicit();
+ if (implicit1[0] == implicit2[0] && implicit1[1] == implicit2[1]) {
+
+ } 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);
+ }
+ }
+ }
+
+}
diff --git a/src/test/java/org/pyyaml/PyErrorsTest.java b/src/test/java/org/pyyaml/PyErrorsTest.java new file mode 100644 index 00000000..8eb46962 --- /dev/null +++ b/src/test/java/org/pyyaml/PyErrorsTest.java @@ -0,0 +1,120 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Loader;
+import org.yaml.snakeyaml.constructor.Constructor;
+import org.yaml.snakeyaml.emitter.Emitter;
+import org.yaml.snakeyaml.emitter.EventConstructor;
+import org.yaml.snakeyaml.error.YAMLException;
+import org.yaml.snakeyaml.events.Event;
+
+/**
+ * @see imported from PyYAML
+ */
+public class PyErrorsTest extends PyImportTest {
+ private boolean skip(String filename) {
+ List<String> failures = new ArrayList<String>();
+ // in python list cannot be a key in a dictionary.
+ failures.add("unacceptable-key.loader-error");
+ for (String name : failures) {
+ if (name.equals(filename)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public void testLoaderErrors() throws FileNotFoundException {
+ File[] files = getStreamsByExtension(".loader-error");
+ assertTrue("No test files found.", files.length > 0);
+ for (int i = 0; i < files.length; i++) {
+ if (skip(files[i].getName())) {
+ continue;
+ }
+ try {
+ for (Object document : loadAll(new FileInputStream(files[i]))) {
+ assertNotNull("File " + files[i], document);
+ }
+ fail("Loading must fail for " + files[i].getAbsolutePath());
+ // System.err.println("Loading must fail for " +
+ // files[i].getAbsolutePath());
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+ }
+
+ public void testLoaderStringErrors() throws FileNotFoundException {
+ File[] files = getStreamsByExtension(".loader-error");
+ assertTrue("No test files found.", files.length > 0);
+ for (int i = 0; i < files.length; i++) {
+ if (skip(files[i].getName())) {
+ continue;
+ }
+ try {
+ String content = getResource(files[i].getName());
+ for (Object document : loadAll(content.trim())) {
+ assertNotNull(document);
+ }
+ fail("Loading must fail for " + files[i].getAbsolutePath());
+ // System.err.println("Loading must fail for " +
+ // files[i].getAbsolutePath());
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+ }
+
+ public void testLoaderSingleErrors() throws FileNotFoundException {
+ File[] files = getStreamsByExtension(".single-loader-error");
+ assertTrue("No test files found.", files.length > 0);
+ for (int i = 0; i < files.length; i++) {
+ try {
+ String content = getResource(files[i].getName());
+ load(content.trim());
+ fail("Loading must fail for " + files[i].getAbsolutePath());
+ // multiple documents must not be accepted
+ System.err.println("Loading must fail for " + files[i].getAbsolutePath());
+ } catch (YAMLException e) {
+ assertTrue(true);
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public void testEmitterErrors() {
+ File[] files = getStreamsByExtension(".emitter-error");
+ assertTrue("No test files found.", files.length > 0);
+ for (int i = 0; i < files.length; i++) {
+ Constructor constructor = new EventConstructor();
+ Loader loader = new Loader(constructor);
+ String content = getResource(files[i].getName());
+ List<Event> document = (List<Event>) load(loader, content.trim());
+ Writer writer = new StringWriter();
+ Emitter emitter = new Emitter(writer, new DumperOptions());
+ try {
+ for (Event event : document) {
+ emitter.emit(event);
+ }
+ fail("Loading must fail for " + files[i].getAbsolutePath());
+ // System.err.println("Loading must fail for " +
+ // files[i].getAbsolutePath());
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+ }
+
+ // testDumperErrors() is implemented in SerializerTest.java
+}
diff --git a/src/test/java/org/pyyaml/PyImportTest.java b/src/test/java/org/pyyaml/PyImportTest.java new file mode 100644 index 00000000..5bc7fe77 --- /dev/null +++ b/src/test/java/org/pyyaml/PyImportTest.java @@ -0,0 +1,128 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.LinkedList;
+import java.util.List;
+
+import junit.framework.TestCase;
+
+import org.yaml.snakeyaml.Loader;
+import org.yaml.snakeyaml.Util;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.events.Event;
+import org.yaml.snakeyaml.parser.Parser;
+import org.yaml.snakeyaml.parser.ParserImpl;
+import org.yaml.snakeyaml.reader.Reader;
+import org.yaml.snakeyaml.reader.UnicodeReader;
+
+public abstract class PyImportTest extends TestCase {
+ public static final String PATH = "pyyaml";
+
+ protected Object load(String data) {
+ Yaml yaml = new Yaml();
+ Object obj = yaml.load(data);
+ return obj;
+ }
+
+ protected Object load(Loader loader, String data) {
+ Yaml yaml = new Yaml(loader);
+ Object obj = yaml.load(data);
+ return obj;
+ }
+
+ protected Iterable<Object> loadAll(InputStream data) {
+ Yaml yaml = new Yaml();
+ return yaml.loadAll(data);
+ }
+
+ protected Iterable<Object> loadAll(String data) {
+ Yaml yaml = new Yaml();
+ return yaml.loadAll(data);
+ }
+
+ protected Iterable<Object> loadAll(Loader loader, String data) {
+ Yaml yaml = new Yaml(loader);
+ return yaml.loadAll(data);
+ }
+
+ protected String getResource(String theName) {
+ try {
+ String content;
+ content = Util.getLocalResource(PATH + File.separator + theName);
+ return content;
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ protected File[] getStreamsByExtension(String extention) {
+ return getStreamsByExtension(extention, false);
+ }
+
+ protected File[] getStreamsByExtension(String extention, boolean onlyIfCanonicalPresent) {
+ File file = new File("src/test/resources/pyyaml");
+ assertTrue("Folder not found: " + file.getAbsolutePath(), file.exists());
+ assertTrue(file.isDirectory());
+ File[] files = file.listFiles(new PyFilenameFilter(extention, onlyIfCanonicalPresent));
+ return files;
+ }
+
+ protected File getFileByName(String name) {
+ File file = new File("src/test/resources/pyyaml/" + name);
+ assertTrue("Folder not found: " + file.getAbsolutePath(), file.exists());
+ assertTrue(file.isFile());
+ return file;
+ }
+
+ protected List<Event> canonicalParse(InputStream input2) throws IOException {
+ Reader reader = new Reader(new UnicodeReader(input2));
+ StringBuffer buffer = new StringBuffer();
+ while (reader.peek() != '\0') {
+ buffer.append(reader.peek());
+ reader.forward();
+ }
+ CanonicalParser parser = new CanonicalParser(buffer.toString());
+ List<Event> result = new LinkedList<Event>();
+ while (parser.peekEvent() != null) {
+ result.add(parser.getEvent());
+ }
+ return result;
+ }
+
+ protected List<Event> parse(InputStream input) throws IOException {
+ Reader reader = new Reader(new UnicodeReader(input));
+ Parser parser = new ParserImpl(reader);
+ List<Event> result = new LinkedList<Event>();
+ while (parser.peekEvent() != null) {
+ result.add(parser.getEvent());
+ }
+ return result;
+ }
+
+ private class PyFilenameFilter implements FilenameFilter {
+ private String extension;
+ private boolean onlyIfCanonicalPresent;
+
+ public PyFilenameFilter(String extension, boolean onlyIfCanonicalPresent) {
+ this.extension = extension;
+ this.onlyIfCanonicalPresent = onlyIfCanonicalPresent;
+ }
+
+ public boolean accept(File dir, String name) {
+ int position = name.lastIndexOf('.');
+ String canonicalFileName = name.substring(0, position) + ".canonical";
+ File canonicalFile = new File(dir, canonicalFileName);
+ if (onlyIfCanonicalPresent && !canonicalFile.exists()) {
+ return false;
+ } else {
+ return name.endsWith(extension);
+ }
+ }
+ }
+}
diff --git a/src/test/java/org/pyyaml/PyMarkTest.java b/src/test/java/org/pyyaml/PyMarkTest.java new file mode 100644 index 00000000..fe078385 --- /dev/null +++ b/src/test/java/org/pyyaml/PyMarkTest.java @@ -0,0 +1,45 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import org.yaml.snakeyaml.error.Mark;
+
+/**
+ * @see imported from PyYAML
+ */
+public class PyMarkTest extends PyImportTest {
+
+ public void testMarks() {
+ String content = getResource("test_mark.marks");
+ String[] inputs = content.split("---\n");
+ for (int i = 1; i < inputs.length; i++) {
+ String input = inputs[i];
+ int index = 0;
+ int line = 0;
+ int column = 0;
+ while (input.charAt(index) != '*') {
+ if (input.charAt(index) != '\n') {
+ line += 1;
+ column = 0;
+ } else {
+ column += 1;
+ }
+ index += 1;
+ }
+ Mark mark = new Mark("testMarks", index, line, column, input, index);
+ String snippet = mark.get_snippet(2, 79);
+ assertTrue("Must only have one '\n'.", snippet.indexOf("\n") > -1);
+ assertEquals("Must only have only one '\n'.", snippet.indexOf("\n"), snippet
+ .lastIndexOf("\n"));
+ String[] lines = snippet.split("\n");
+ String data = lines[0];
+ String pointer = lines[1];
+ assertTrue("Mark must be restricted: " + data, data.length() < 82);
+ int dataPosition = data.indexOf("*");
+ int pointerPosition = pointer.indexOf("^");
+ assertEquals("Pointer should coincide with '*':\n " + snippet, dataPosition,
+ pointerPosition);
+ }
+ }
+}
diff --git a/src/test/java/org/pyyaml/PyReaderTest.java b/src/test/java/org/pyyaml/PyReaderTest.java new file mode 100644 index 00000000..c9891d76 --- /dev/null +++ b/src/test/java/org/pyyaml/PyReaderTest.java @@ -0,0 +1,36 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+import org.yaml.snakeyaml.reader.Reader;
+import org.yaml.snakeyaml.reader.ReaderException;
+import org.yaml.snakeyaml.reader.UnicodeReader;
+
+/**
+ * @see imported from PyYAML
+ */
+public class PyReaderTest extends PyImportTest {
+
+ public void testReaderUnicodeErrors() throws IOException {
+ File[] inputs = getStreamsByExtension(".stream-error");
+ for (int i = 0; i < inputs.length; i++) {
+ Reader stream = new Reader(new UnicodeReader(new FileInputStream(inputs[i])));
+ try {
+ while (stream.peek() != '\u0000') {
+ stream.forward();
+ }
+ fail("Invalid stream must not be accepted: " + inputs[i].getAbsolutePath()
+ + "; encoding=" + stream.getEncoding());
+ } catch (ReaderException e) {
+ System.out.println(e.toString());
+ assertTrue(true);
+ }
+ }
+ }
+
+}
diff --git a/src/test/java/org/pyyaml/PyRecursiveTest.java b/src/test/java/org/pyyaml/PyRecursiveTest.java new file mode 100644 index 00000000..14fb5d51 --- /dev/null +++ b/src/test/java/org/pyyaml/PyRecursiveTest.java @@ -0,0 +1,63 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import junit.framework.TestCase;
+
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.ConstructorException;
+
+public class PyRecursiveTest extends TestCase {
+
+ @SuppressWarnings("unchecked")
+ public void testDict() {
+ Map<AnInstance, AnInstance> value = new HashMap<AnInstance, AnInstance>();
+ AnInstance instance = new AnInstance(value, value);
+ value.put(instance, instance);
+ Yaml yaml = new Yaml();
+ try {
+ String output1 = yaml.dump(value);
+ Map<AnInstance, AnInstance> value2 = (Map<AnInstance, AnInstance>) yaml.load(output1);
+ assertEquals(value, value2);
+ } catch (ConstructorException e) {
+ // TODO recursive objects are not allowed
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public void testList() {
+ List value = new ArrayList();
+ value.add(value);
+ Yaml yaml = new Yaml();
+ try {
+ String output1 = yaml.dump(value);
+ System.out.println(output1);
+ List value2 = (List) yaml.load(output1);
+ assertEquals(value, value2);
+ } catch (ConstructorException e) {
+ // TODO recursive objects are not allowed
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public void testSet() {
+ Set value = new HashSet();
+ value.add(new AnInstance(value, value));
+ Yaml yaml = new Yaml();
+ try {
+ String output1 = yaml.dump(value);
+ List value2 = (List) yaml.load(output1);
+ assertEquals(value, value2);
+ } catch (ConstructorException e) {
+ // TODO recursive objects are not allowed
+ }
+ }
+}
diff --git a/src/test/java/org/pyyaml/PyStructureTest.java b/src/test/java/org/pyyaml/PyStructureTest.java new file mode 100644 index 00000000..0362ee5c --- /dev/null +++ b/src/test/java/org/pyyaml/PyStructureTest.java @@ -0,0 +1,287 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.yaml.snakeyaml.Loader;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.composer.Composer;
+import org.yaml.snakeyaml.constructor.Construct;
+import org.yaml.snakeyaml.constructor.Constructor;
+import org.yaml.snakeyaml.events.AliasEvent;
+import org.yaml.snakeyaml.events.CollectionStartEvent;
+import org.yaml.snakeyaml.events.Event;
+import org.yaml.snakeyaml.events.ScalarEvent;
+import org.yaml.snakeyaml.nodes.MappingNode;
+import org.yaml.snakeyaml.nodes.Node;
+import org.yaml.snakeyaml.nodes.ScalarNode;
+import org.yaml.snakeyaml.nodes.SequenceNode;
+import org.yaml.snakeyaml.parser.ParserImpl;
+import org.yaml.snakeyaml.reader.Reader;
+import org.yaml.snakeyaml.reader.UnicodeReader;
+import org.yaml.snakeyaml.resolver.Resolver;
+
+/**
+ * @see imported from PyYAML
+ */
+public class PyStructureTest extends PyImportTest {
+
+ private void compareEvents(List<Event> events1, List<Event> events2, boolean full) {
+ assertEquals(events1.size(), events2.size());
+ Iterator<Event> iter1 = events1.iterator();
+ Iterator<Event> iter2 = events2.iterator();
+ while (iter1.hasNext()) {
+ Event event1 = iter1.next();
+ Event event2 = iter2.next();
+ assertEquals(event1.getClass(), event2.getClass());
+ if (event1 instanceof AliasEvent && full) {
+ assertEquals(((AliasEvent) event1).getAnchor(), ((AliasEvent) event2).getAnchor());
+ }
+ if (event1 instanceof CollectionStartEvent) {
+ String tag1 = ((CollectionStartEvent) event1).getTag();
+ String tag2 = ((CollectionStartEvent) event1).getTag();
+ if (tag1 != null && !"!".equals(tag1) && tag2 != null && !"!".equals(tag1)) {
+ assertEquals(tag1, tag2);
+ }
+ }
+ if (event1 instanceof ScalarEvent) {
+ ScalarEvent scalar1 = (ScalarEvent) event1;
+ ScalarEvent scalar2 = (ScalarEvent) event2;
+ boolean[] oldImplicit = scalar1.getImplicit();
+ boolean[] newImplicit = scalar2.getImplicit();
+ if (!oldImplicit[0] && !oldImplicit[1] && !newImplicit[0] && !newImplicit[1]) {
+ assertEquals(scalar1.getTag(), scalar2.getTag());
+ }
+ assertEquals(scalar1.getValue(), scalar2.getValue());
+ }
+ }
+ }
+
+ public void testParser() throws IOException {
+ File[] files = getStreamsByExtension(".data", true);
+ assertTrue("No test files found.", files.length > 0);
+ for (File file : files) {
+ if (!file.getName().contains("scan-line-b")) {
+ continue;
+ }
+ try {
+ List<Event> events1 = parse(new FileInputStream(file));
+ assertFalse(events1.isEmpty());
+ int index = file.getAbsolutePath().lastIndexOf('.');
+ String canonicalName = file.getAbsolutePath().substring(0, index) + ".canonical";
+ File canonical = new File(canonicalName);
+ List<Event> events2 = canonicalParse(new FileInputStream(canonical));
+ assertFalse(events2.isEmpty());
+ System.out.println("try:" + file);
+ compareEvents(events1, events2, false);
+ } catch (Exception e) {
+ System.out.println("Failed File: " + file);
+ // fail("Failed File: " + file + "; " + e.getMessage());
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ public void testParserOnCanonical() throws IOException {
+ File[] canonicalFiles = getStreamsByExtension(".canonical", false);
+ assertTrue("No test files found.", canonicalFiles.length > 0);
+ for (File file : canonicalFiles) {
+ try {
+ List<Event> events1 = parse(new FileInputStream(file));
+ assertFalse(events1.isEmpty());
+ List<Event> events2 = canonicalParse(new FileInputStream(file));
+ assertFalse(events2.isEmpty());
+ compareEvents(events1, events2, true);
+ } catch (Exception e) {
+ System.out.println("Failed File: " + file);
+ // fail("Failed File: " + file + "; " + e.getMessage());
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private void compareNodes(Node node1, Node node2) {
+ assertEquals(node1.getClass(), node2.getClass());
+ if (node1 instanceof ScalarNode) {
+ ScalarNode scalar1 = (ScalarNode) node1;
+ ScalarNode scalar2 = (ScalarNode) node2;
+ assertEquals(scalar1.getTag(), scalar2.getTag());
+ assertEquals(scalar1.getValue(), scalar2.getValue());
+ } else {
+ if (node1 instanceof SequenceNode) {
+ SequenceNode seq1 = (SequenceNode) node1;
+ SequenceNode seq2 = (SequenceNode) node2;
+ assertEquals(seq1.getTag(), seq2.getTag());
+ assertEquals(seq1.getValue().size(), seq2.getValue().size());
+ Iterator<Node> iter2 = seq2.getValue().iterator();
+ for (Node child1 : seq1.getValue()) {
+ Node child2 = iter2.next();
+ compareNodes(child1, child2);
+ }
+ } else {
+ MappingNode seq1 = (MappingNode) node1;
+ MappingNode seq2 = (MappingNode) node2;
+ assertEquals(seq1.getTag(), seq2.getTag());
+ assertEquals(seq1.getValue().size(), seq2.getValue().size());
+ Iterator<Node[]> iter2 = seq2.getValue().iterator();
+ for (Node[] child1 : seq1.getValue()) {
+ Node[] child2 = iter2.next();
+ compareNodes(child1[0], child2[0]);// keys
+ compareNodes(child1[1], child2[1]);// values
+ }
+ }
+ }
+ }
+
+ public void testComposer() throws IOException {
+ File[] files = getStreamsByExtension(".data", true);
+ assertTrue("No test files found.", files.length > 0);
+ for (File file : files) {
+ try {
+ List<Node> events1 = compose_all(new FileInputStream(file));
+ int index = file.getAbsolutePath().lastIndexOf('.');
+ String canonicalName = file.getAbsolutePath().substring(0, index) + ".canonical";
+ File canonical = new File(canonicalName);
+ List<Node> events2 = canonical_compose_all(new FileInputStream(canonical));
+ assertEquals(events1.size(), events2.size());
+ Iterator<Node> iter1 = events1.iterator();
+ Iterator<Node> iter2 = events2.iterator();
+ while (iter1.hasNext()) {
+ compareNodes(iter1.next(), iter2.next());
+ }
+ } catch (Exception e) {
+ System.out.println("Failed File: " + file);
+ // fail("Failed File: " + file + "; " + e.getMessage());
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ private List<Node> compose_all(InputStream file) {
+ Composer composer = new Composer(new ParserImpl(new Reader(new UnicodeReader(file))),
+ new Resolver());
+ List<Node> documents = new LinkedList<Node>();
+ while (composer.checkNode()) {
+ documents.add(composer.getNode());
+ }
+ return documents;
+ }
+
+ private List<Node> canonical_compose_all(InputStream file) {
+ Reader reader = new Reader(new UnicodeReader(file));
+ StringBuffer buffer = new StringBuffer();
+ while (reader.peek() != '\0') {
+ buffer.append(reader.peek());
+ reader.forward();
+ }
+ CanonicalParser parser = new CanonicalParser(buffer.toString());
+ Composer composer = new Composer(parser, new Resolver());
+ List<Node> documents = new LinkedList<Node>();
+ while (composer.checkNode()) {
+ documents.add(composer.getNode());
+ }
+ return documents;
+ }
+
+ class MyLoader extends Loader {
+ public MyLoader() {
+ super(new MyConstructor());
+ }
+ }
+
+ class CanonicalLoader extends Loader {
+ public CanonicalLoader() {
+ super(new MyConstructor());
+ }
+
+ @Override
+ public Iterable<Object> loadAll(java.io.Reader yaml) {
+ Reader reader = new Reader(yaml);
+ StringBuffer buffer = new StringBuffer();
+ while (reader.peek() != '\0') {
+ buffer.append(reader.peek());
+ reader.forward();
+ }
+ CanonicalParser parser = new CanonicalParser(buffer.toString());
+ Composer composer = new Composer(parser, resolver);
+ this.constructor.setComposer(composer);
+ Iterator<Object> result = new Iterator<Object>() {
+ public boolean hasNext() {
+ return constructor.checkData();
+ }
+
+ public Object next() {
+ return constructor.getData();
+ }
+
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+ };
+ return new YamlIterable(result);
+ }
+
+ private class YamlIterable implements Iterable<Object> {
+ private Iterator<Object> iterator;
+
+ public YamlIterable(Iterator<Object> iterator) {
+ this.iterator = iterator;
+ }
+
+ public Iterator<Object> iterator() {
+ return iterator;
+ }
+
+ }
+
+ }
+
+ private class MyConstructor extends Constructor {
+ public MyConstructor() {
+ this.yamlConstructors.put(null, new ConstructUndefined());
+ }
+
+ private class ConstructUndefined implements Construct {
+ public Object construct(Node node) {
+ return constructScalar((ScalarNode) node);
+ }
+ }
+ }
+
+ public void testConstructor() throws IOException {
+ File[] files = getStreamsByExtension(".data", true);
+ assertTrue("No test files found.", files.length > 0);
+ Yaml myYaml = new Yaml(new MyLoader());
+ Yaml canonicalYaml = new Yaml(new CanonicalLoader());
+ for (File file : files) {
+ try {
+ Iterable<Object> documents1 = myYaml.loadAll(new FileInputStream(file));
+ int index = file.getAbsolutePath().lastIndexOf('.');
+ String canonicalName = file.getAbsolutePath().substring(0, index) + ".canonical";
+ File canonical = new File(canonicalName);
+ Iterable<Object> documents2 = canonicalYaml.loadAll(new FileInputStream(canonical));
+ Iterator<Object> iter2 = documents2.iterator();
+ for (Object object1 : documents1) {
+ Object object2 = iter2.next();
+ if (object2 != null) {
+ assertFalse(System.identityHashCode(object1) == System
+ .identityHashCode(object2));
+ }
+ assertEquals("" + object1, object1, object2);
+ }
+ } catch (Exception e) {
+ System.out.println("Failed File: " + file);
+ // fail("Failed File: " + file + "; " + e.getMessage());
+ throw new RuntimeException(e);
+ }
+ }
+ }
+}
diff --git a/src/test/java/org/pyyaml/PyTokensTest.java b/src/test/java/org/pyyaml/PyTokensTest.java new file mode 100644 index 00000000..42f65948 --- /dev/null +++ b/src/test/java/org/pyyaml/PyTokensTest.java @@ -0,0 +1,140 @@ +/*
+ * See LICENSE file in distribution for copyright and licensing information.
+ */
+package org.pyyaml;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import org.yaml.snakeyaml.reader.Reader;
+import org.yaml.snakeyaml.reader.UnicodeReader;
+import org.yaml.snakeyaml.scanner.Scanner;
+import org.yaml.snakeyaml.scanner.ScannerImpl;
+import org.yaml.snakeyaml.tokens.AliasToken;
+import org.yaml.snakeyaml.tokens.AnchorToken;
+import org.yaml.snakeyaml.tokens.BlockEndToken;
+import org.yaml.snakeyaml.tokens.BlockEntryToken;
+import org.yaml.snakeyaml.tokens.BlockMappingStartToken;
+import org.yaml.snakeyaml.tokens.BlockSequenceStartToken;
+import org.yaml.snakeyaml.tokens.DirectiveToken;
+import org.yaml.snakeyaml.tokens.DocumentEndToken;
+import org.yaml.snakeyaml.tokens.DocumentStartToken;
+import org.yaml.snakeyaml.tokens.FlowEntryToken;
+import org.yaml.snakeyaml.tokens.FlowMappingEndToken;
+import org.yaml.snakeyaml.tokens.FlowMappingStartToken;
+import org.yaml.snakeyaml.tokens.FlowSequenceEndToken;
+import org.yaml.snakeyaml.tokens.FlowSequenceStartToken;
+import org.yaml.snakeyaml.tokens.KeyToken;
+import org.yaml.snakeyaml.tokens.ScalarToken;
+import org.yaml.snakeyaml.tokens.StreamEndToken;
+import org.yaml.snakeyaml.tokens.StreamStartToken;
+import org.yaml.snakeyaml.tokens.TagToken;
+import org.yaml.snakeyaml.tokens.Token;
+import org.yaml.snakeyaml.tokens.ValueToken;
+
+/**
+ * @see imported from PyYAML
+ */
+public class PyTokensTest extends PyImportTest {
+
+ @SuppressWarnings("unchecked")
+ public void testTokens() throws FileNotFoundException {
+ Map<Class, String> replaces = new HashMap<Class, String>();
+ replaces.put(DirectiveToken.class, "%");
+ replaces.put(DocumentStartToken.class, "---");
+ replaces.put(DocumentEndToken.class, "...");
+ replaces.put(AliasToken.class, "*");
+ replaces.put(AnchorToken.class, "&");
+ replaces.put(TagToken.class, "!");
+ replaces.put(ScalarToken.class, "_");
+ replaces.put(BlockSequenceStartToken.class, "[[");
+ replaces.put(BlockMappingStartToken.class, "{{");
+ replaces.put(BlockEndToken.class, "]}");
+ replaces.put(FlowSequenceStartToken.class, "[");
+ replaces.put(FlowSequenceEndToken.class, "]");
+ replaces.put(FlowMappingStartToken.class, "{");
+ replaces.put(FlowMappingEndToken.class, "}");
+ replaces.put(BlockEntryToken.class, ",");
+ replaces.put(FlowEntryToken.class, ",");
+ replaces.put(KeyToken.class, "?");
+ replaces.put(ValueToken.class, ":");
+ //
+ File[] tokensFiles = getStreamsByExtension(".tokens");
+ assertTrue("No test files found.", tokensFiles.length > 0);
+ for (int i = 0; i < tokensFiles.length; i++) {
+ String name = tokensFiles[i].getName();
+ int position = name.lastIndexOf('.');
+ String dataName = name.substring(0, position) + ".data";
+ //
+ String tokenFileData = getResource(name);
+ String[] split = tokenFileData.split("\\s+");
+ List<String> tokens2 = new LinkedList<String>();
+ for (int j = 0; j < split.length; j++) {
+ tokens2.add(split[j]);
+ }
+ //
+ List<String> tokens1 = new LinkedList<String>();
+ Reader reader = new Reader(new UnicodeReader(new FileInputStream(
+ getFileByName(dataName))));
+ Scanner scanner = new ScannerImpl(reader);
+ try {
+ while (scanner.checkToken(new ArrayList<Class<? extends Token>>())) {
+ Token token = scanner.getToken();
+ if (!(token instanceof StreamStartToken || token instanceof StreamEndToken)) {
+ String replacement = replaces.get(token.getClass());
+ tokens1.add(replacement);
+ }
+ }
+ // System.out.println("File name: \n" +
+ // tokensFiles[i].getName());
+ // Iterator iter = tokens2.iterator();
+ // for (String string : tokens1) {
+ // String str2 = (String) iter.next();
+ // System.out.println(string + "=" + str2);
+ // }
+ assertEquals(tokenFileData, tokens1.size(), tokens2.size());
+ assertEquals(tokens1, tokens2);
+ } catch (RuntimeException e) {
+ System.out.println("File name: \n" + tokensFiles[i].getName());
+ String data = getResource(tokensFiles[i].getName());
+ System.out.println("Data: \n" + data);
+ System.out.println("Tokens:");
+ for (String token : tokens1) {
+ System.out.println(token);
+ }
+ fail("Cannot scan: " + tokensFiles[i]);
+ }
+ }
+ }
+
+ public void testScanner() throws FileNotFoundException {
+ File[] files = getStreamsByExtension(".data", true);
+ assertTrue("No test files found.", files.length > 0);
+ for (File file : files) {
+ List<String> tokens = new LinkedList<String>();
+ Reader reader = new Reader(new UnicodeReader(new FileInputStream(file)));
+ Scanner scanner = new ScannerImpl(reader);
+ try {
+ while (scanner.checkToken(new ArrayList<Class<? extends Token>>())) {
+ Token token = scanner.getToken();
+ tokens.add(token.getClass().getName());
+ }
+ } catch (RuntimeException e) {
+ System.out.println("File name: \n" + file.getName());
+ String data = getResource(file.getName());
+ System.out.println("Data: \n" + data);
+ System.out.println("Tokens:");
+ for (String token : tokens) {
+ System.out.println(token);
+ }
+ fail("Cannot scan: " + file + "; " + e.getMessage());
+ }
+ }
+ }
+}
|