| /** |
| * Copyright (c) 2008-2013, 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.InputStream; |
| import java.io.Reader; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.yaml.snakeyaml.Yaml; |
| import org.yaml.snakeyaml.composer.Composer; |
| import org.yaml.snakeyaml.constructor.AbstractConstruct; |
| 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.NodeTuple; |
| import org.yaml.snakeyaml.nodes.ScalarNode; |
| import org.yaml.snakeyaml.nodes.SequenceNode; |
| import org.yaml.snakeyaml.parser.ParserImpl; |
| import org.yaml.snakeyaml.reader.StreamReader; |
| 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; |
| if (scalar1.getImplicit().bothFalse() && scalar2.getImplicit().bothFalse()) { |
| assertEquals(scalar1.getTag(), scalar2.getTag()); |
| } |
| assertEquals(scalar1.getValue(), scalar2.getValue()); |
| } |
| } |
| } |
| |
| public void testParser() { |
| 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 { |
| InputStream input = new FileInputStream(file); |
| List<Event> events1 = parse(input); |
| input.close(); |
| 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()); |
| 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() { |
| File[] canonicalFiles = getStreamsByExtension(".canonical", false); |
| assertTrue("No test files found.", canonicalFiles.length > 0); |
| for (File file : canonicalFiles) { |
| try { |
| InputStream input = new FileInputStream(file); |
| List<Event> events1 = parse(input); |
| input.close(); |
| 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<NodeTuple> iter2 = seq2.getValue().iterator(); |
| for (NodeTuple child1 : seq1.getValue()) { |
| NodeTuple child2 = iter2.next(); |
| compareNodes(child1.getKeyNode(), child2.getKeyNode()); |
| compareNodes(child1.getValueNode(), child2.getValueNode()); |
| } |
| } |
| } |
| } |
| |
| public void testComposer() { |
| File[] files = getStreamsByExtension(".data", true); |
| assertTrue("No test files found.", files.length > 0); |
| for (File file : files) { |
| try { |
| InputStream input = new FileInputStream(file); |
| List<Node> events1 = compose_all(input); |
| input.close(); |
| int index = file.getAbsolutePath().lastIndexOf('.'); |
| String canonicalName = file.getAbsolutePath().substring(0, index) + ".canonical"; |
| File canonical = new File(canonicalName); |
| InputStream input2 = new FileInputStream(canonical); |
| List<Node> events2 = canonical_compose_all(input2); |
| input2.close(); |
| 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 StreamReader(new UnicodeReader(file))), |
| new Resolver()); |
| List<Node> documents = new ArrayList<Node>(); |
| while (composer.checkNode()) { |
| documents.add(composer.getNode()); |
| } |
| return documents; |
| } |
| |
| private List<Node> canonical_compose_all(InputStream file) { |
| StreamReader reader = new StreamReader(new UnicodeReader(file)); |
| StringBuilder buffer = new StringBuilder(); |
| 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 ArrayList<Node>(); |
| while (composer.checkNode()) { |
| documents.add(composer.getNode()); |
| } |
| return documents; |
| } |
| |
| class CanonicalLoader extends Yaml { |
| public CanonicalLoader() { |
| super(new MyConstructor()); |
| } |
| |
| @Override |
| public Iterable<Object> loadAll(Reader yaml) { |
| StreamReader reader = new StreamReader(yaml); |
| StringBuilder buffer = new StringBuilder(); |
| 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 extends AbstractConstruct { |
| public Object construct(Node node) { |
| return constructScalar((ScalarNode) node); |
| } |
| } |
| } |
| |
| public void testConstructor() { |
| File[] files = getStreamsByExtension(".data", true); |
| assertTrue("No test files found.", files.length > 0); |
| Yaml myYaml = new Yaml(new MyConstructor()); |
| Yaml canonicalYaml = new CanonicalLoader(); |
| for (File file : files) { |
| try { |
| InputStream input = new FileInputStream(file); |
| Iterable<Object> documents1 = myYaml.loadAll(input); |
| int index = file.getAbsolutePath().lastIndexOf('.'); |
| String canonicalName = file.getAbsolutePath().substring(0, index) + ".canonical"; |
| File canonical = new File(canonicalName); |
| InputStream input2 = new FileInputStream(canonical); |
| Iterable<Object> documents2 = canonicalYaml.loadAll(input2); |
| input2.close(); |
| 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); |
| } |
| input.close(); |
| } catch (Exception e) { |
| System.out.println("Failed File: " + file); |
| // fail("Failed File: " + file + "; " + e.getMessage()); |
| throw new RuntimeException(e); |
| } |
| } |
| } |
| } |