();
+
+ String attrsStr = sbAttrs.toString().trim();
+
+ if(attrsStr.length() > 0) {
+// //Create an array with each string containing one key="value" chain
+// String[] attrs = attrsStr.split("\\s+");
+//
+// //Create each map entry
+// for(int i=0; i < attrs.length; i++) {
+// String attr = attrs[i];
+// String[] keyVal = attr.split("\\x3D"); //Split using '='
+// if(keyVal.length == 2) {
+// String value = keyVal[1].substring(1, keyVal[1].length()-1);
+//
+// //Delete ending '"' for unspaced attributes
+// if(i == attrs.length-1 && unspacedAttributes) {
+// value = value.substring(0, value.length()-1);
+// }
+//
+// attributes.put(
+// keyVal[0],
+// value);
+// }
+// }
+ Pattern regex = Pattern.compile(
+ "(\\w+)" +
+ "=" +
+ "(" +
+ " (?[\\x22\\x27])" +
+ " (.*?)" +
+ " \\k
" +
+ ")",
+ Pattern.COMMENTS);
+ Matcher regexMatcher = regex.matcher(attrsStr);
+ while (regexMatcher.find()) {
+ attributes.put(regexMatcher.group(1), regexMatcher.group(4));
+ }
+ }
+ }
+
+ /**
+ * Defines the current declaration markup as invalid.
+ * For example, when markup ends with "/>".
+ */
+ void setDeclarationInvalid() {
+ invalidDeclaration = true;
+ }
+
+ /**
+ * Initializes the finite-state automaton for markup recognition.
+ * It does simple recognition, it could be improved to read more complex markups.
+ */
+ private void initAutomaton() {
+ //Init string builders
+ sbName = new StringBuilder();
+ sbAttrs = new StringBuilder();
+ sbText = new StringBuilder();
+ sbEndName = new StringBuilder();
+
+ //Starting state
+ automaton = new State();
+ automaton.addTransition("\\s", automaton); //Remove whitespaces
+
+ State startMarkup = new State(false, sbName);
+ automaton.addTransition('<', startMarkup); //Markup opening
+
+ //Markup name
+ State name2 = new State(false, sbName);
+ startMarkup.addTransition("[a-zA-Z]", name2); //First character of the name
+ name2.addTransition("\\w", name2); //Following characters of the name
+
+ State endName = new State(false, sbAttrs);
+ name2.addTransition("\\s", endName); //White space between name and attributes
+ endName.addTransition("\\s", endName); //Idem
+
+ //Declaration '?'
+ State declStart = new State(false, sbName);
+ TransitionListener tl1 = new TypeTransitionListener(this, DECLARATION);
+ startMarkup.addTransition('?', declStart, tl1);
+ declStart.addTransition("[a-zA-Z]", name2);
+
+ //Attributes
+ State startAttrs = new State(false, sbAttrs);
+ endName.addTransition("[a-zA-Z]", startAttrs); //First character of attributes
+ startAttrs.addTransition("\\w", startAttrs); //Following characters of first key
+
+ State equalSign = new State(false, sbAttrs);
+ startAttrs.addTransition('=', equalSign); //'=' for first attribute
+
+ State startValue = new State(false, sbAttrs);
+ startValue.addTransition("[^\\x{22}\\x{27}]", startValue);
+ equalSign.addTransition("[\\x{22}\\x{27}]", startValue); //Escape character for attribute value
+
+ State endEscChar = new State(false, sbAttrs);
+ startValue.addTransition("[\\x{22}\\x{27}]", endEscChar); //The end escape character for value
+
+ State whiteSpace = new State(false, sbAttrs);
+ endEscChar.addTransition("\\s", whiteSpace); //White spaces between end of value and rest
+ whiteSpace.addTransition("\\s", whiteSpace); //Idem
+ whiteSpace.addTransition("[a-zA-Z]", startAttrs); //First char of next key
+
+ //End of empty markup
+ State endEmptyMarkup1 = new State();
+ whiteSpace.addTransition('/', endEmptyMarkup1); //The / char of empty markup
+ name2.addTransition('/', endEmptyMarkup1); //Idem, without attributes and with only one space
+ endName.addTransition('/', endEmptyMarkup1); //Idem, without attributes but with spaces
+ endEscChar.addTransition('/', endEmptyMarkup1); //Idem without spaces
+
+ State endEmptyMarkup2 = new State(true);
+ TransitionListener ttl2 = new TypeTransitionListener(this, EMPTY);
+ endEmptyMarkup1.addTransition(
+ '>',
+ endEmptyMarkup2,
+ ttl2); //The > char of empty markup
+ endEmptyMarkup2.addTransition("\\s", endEmptyMarkup2); //White spaces after empty markup
+
+ //End of declaration
+ State endDeclarationMarkup = new State();
+ whiteSpace.addTransition('?', endDeclarationMarkup); //The ? char of declaration markup
+ name2.addTransition('?', endDeclarationMarkup); //Idem, without attributes and with only space
+ endName.addTransition('?', endDeclarationMarkup); //Idem, without attributes but with spaces
+ endEscChar.addTransition('?', endDeclarationMarkup); //Idem without spaces
+ endDeclarationMarkup.addTransition('>', endEmptyMarkup2);
+
+ //End of start markup
+ State endStartMarkup = new State(true, sbText);
+ TypeTransitionListener startListener = new TypeTransitionListener(this, START);
+ whiteSpace.addTransition(
+ '>',
+ endStartMarkup,
+ startListener); //The > char of start markup
+ endStartMarkup.addTransition("\\s", endStartMarkup); //White spaces after start markup
+ name2.addTransition(
+ '>',
+ endStartMarkup,
+ startListener); //The > char of start markup without attributes
+ endEscChar.addTransition(
+ '>',
+ endStartMarkup,
+ startListener); //The > char of start markup with attributes and without space
+
+ //Text
+ State text = new State(true, sbText);
+ endStartMarkup.addTransition("[^\\e\\x{3C}\\x{3E}]", text);
+ text.addTransition("[^\\e\\x{3C}\\x{3E}]", text);
+
+ //End markup
+ State startEndMarkup = new State();
+ text.addTransition('<', startEndMarkup);
+
+ State slashEndMarkup = new State(false, sbEndName);
+ TypeTransitionListener endListener = new TypeTransitionListener(this, END);
+ startEndMarkup.addTransition('/', slashEndMarkup, endListener);
+ startMarkup.addTransition('/', slashEndMarkup, endListener);
+
+ State nameEndMarkup = new State(false, sbEndName);
+ slashEndMarkup.addTransition("[a-zA-Z]", nameEndMarkup);
+ nameEndMarkup.addTransition("\\w", nameEndMarkup);
+
+ State endEndMarkup = new State(true);
+ nameEndMarkup.addTransition('>', endEndMarkup);
+ endEndMarkup.addTransition("\\s", endEndMarkup);
+ }
+}
diff --git a/src/main/info/pavie/osm2hive/model/xml/State.java b/src/main/info/pavie/osm2hive/model/xml/State.java
new file mode 100644
index 0000000..27c2e2d
--- /dev/null
+++ b/src/main/info/pavie/osm2hive/model/xml/State.java
@@ -0,0 +1,164 @@
+package info.pavie.osm2hive.model.xml;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * A state of a finite-state automaton.
+ * It has several transitions based on character recognition.
+ * It is possible to capture a String with a StringBuilder.
+ * @author Adrien PAVIE
+ */
+public class State {
+//ATTRIBUTES
+ /** The transitions from this state, based on character reading. **/
+ private Map transitions;
+
+ /** The listeners which can be called when a transition is followed. **/
+ private Map transitionsListeners;
+
+ /** Is this state a final state ? **/
+ private boolean isFinal;
+
+ /** A string builder for capture **/
+ private StringBuilder capture;
+
+//CONSTRUCTORS
+ /**
+ * Default constructor, creates a non-final state.
+ */
+ public State() {
+ this(false);
+ }
+
+ /**
+ * Class constructor
+ * @param isFinal Is this a final state ?
+ */
+ public State(boolean isFinal) {
+ this.isFinal = isFinal;
+ transitions = new HashMap();
+ transitionsListeners = new HashMap();
+ }
+
+ /**
+ * Class constructor, with ability to capture string
+ * @param isFinal Is this a final state ?
+ * @param sb The string builder
+ */
+ public State(boolean isFinal, StringBuilder sb) {
+ this(isFinal);
+ capture = sb;
+ }
+
+//ACCESSORS
+ /**
+ * @return True if this state is final
+ */
+ public boolean isFinal() {
+ return isFinal;
+ }
+
+ /**
+ * @return The string builder
+ */
+ public StringBuilder getCapture() {
+ return capture;
+ }
+
+ /**
+ * Is the given string value, according to this state and its transitions.
+ * It also captures string if needed.
+ * @param s The string to evaluate
+ * @return True if valid
+ */
+ public boolean eval(String s) {
+ boolean result;
+
+ //Not empty string
+ if(!s.equals("")) {
+ char c = s.charAt(0);
+
+ //Append to string builder if needed
+ if(capture != null) {
+ capture.append(c);
+ }
+
+ //Try to find a transition
+ boolean transitionFound = false;
+ Iterator itePattern = transitions.keySet().iterator();
+ Pattern current = null;
+
+ while(!transitionFound && itePattern.hasNext()) {
+ current = itePattern.next();
+ transitionFound = current.matcher(Character.toString(c)).matches();
+ }
+
+ if(!transitionFound) {
+ result = false;
+ } else {
+ //Call listener if there is one
+ if(transitionsListeners.containsKey(current)) {
+ transitionsListeners.get(current).performAction();
+ }
+
+ //Continue evaluation
+ result = transitions.get(current).eval(s.substring(1));
+// System.out.println(current.pattern()+": "+result);
+ }
+ }
+ //If empty string, OK if this state is final
+ else {
+ result = isFinal;
+ }
+
+ return result;
+ }
+
+//MODIFIERS
+ /**
+ * Add a new transition, following a given character.
+ * @param c The character to use
+ * @param s The state to reach
+ */
+ public void addTransition(char c, State s) {
+ addTransition(c, s, null);
+ }
+
+ /**
+ * Add a new transition, following a given character.
+ * @param c The character to use
+ * @param s The state to reach
+ * @param t The transition listener
+ */
+ public void addTransition(char c, State s, TransitionListener t) {
+ addTransition("\\x{"+Integer.toHexString(c | 0x10000).substring(1)+"}", s, t);
+ }
+
+ /**
+ * Add a new transition, following a regex.
+ * The given regex should recognize one character only.
+ * @param p The regular expression to use
+ * @param s The state to reach
+ */
+ public void addTransition(String p, State s) {
+ addTransition(p, s, null);
+ }
+
+ /**
+ * Add a new transition, following a regex.
+ * The given regex should recognize one character only.
+ * @param p The regular expression to use
+ * @param s The state to reach
+ * @param t The transition listener
+ */
+ public void addTransition(String p, State s, TransitionListener t) {
+ Pattern current = Pattern.compile(p);
+ transitions.put(current, s);
+ if(t != null) {
+ transitionsListeners.put(current, t);
+ }
+ }
+}
diff --git a/src/main/info/pavie/osm2hive/model/xml/TransitionListener.java b/src/main/info/pavie/osm2hive/model/xml/TransitionListener.java
new file mode 100644
index 0000000..8b87f3e
--- /dev/null
+++ b/src/main/info/pavie/osm2hive/model/xml/TransitionListener.java
@@ -0,0 +1,35 @@
+package info.pavie.osm2hive.model.xml;
+
+/**
+ * Allows to launch actions when a transition in {@link State} class is followed.
+ * @author Adrien PAVIE
+ */
+public abstract class TransitionListener {
+//ATTRIBUTES
+ /** The markup to edit. **/
+ protected Markup currentMarkup;
+
+//CONSTRUCTOR
+ /**
+ * Default constructor
+ * @param m The markup to edit
+ */
+ public TransitionListener(Markup m) {
+ currentMarkup = m;
+ }
+
+//MODIFIERS
+ /**
+ * Changes the markup to edit.
+ * @param m The new markup
+ */
+ public void setMarkup(Markup m) {
+ currentMarkup = m;
+ }
+
+//OTHER METHODS
+ /**
+ * The action to perform when a transition is followed.
+ */
+ public abstract void performAction();
+}
diff --git a/src/main/info/pavie/osm2hive/model/xml/TypeTransitionListener.java b/src/main/info/pavie/osm2hive/model/xml/TypeTransitionListener.java
new file mode 100644
index 0000000..121ebd7
--- /dev/null
+++ b/src/main/info/pavie/osm2hive/model/xml/TypeTransitionListener.java
@@ -0,0 +1,36 @@
+package info.pavie.osm2hive.model.xml;
+
+/**
+ * This transition listener edits markup type when called.
+ * @author Adrien PAVIE
+ */
+public class TypeTransitionListener extends TransitionListener {
+//ATTRIBUTES
+ /** The type that the markup will have. **/
+ private byte type;
+
+//CONSTRUCTOR
+ /**
+ * Class constructor
+ * @param m The markup
+ * @param type The type to apply on markup if called
+ */
+ public TypeTransitionListener(Markup m, byte type) {
+ super(m);
+ this.type = type;
+ }
+
+//OTHER METHODS
+ @Override
+ public void performAction() {
+ if(currentMarkup.getType() == Markup.UNDEFINED) {
+ currentMarkup.setType(type);
+ }
+ else if(type == Markup.END && currentMarkup.getType() == Markup.START) {
+ currentMarkup.setType(Markup.COMPLETE);
+ }
+ else if(currentMarkup.getType() == Markup.DECLARATION && currentMarkup.getType() != type) {
+ currentMarkup.setDeclarationInvalid();
+ }
+ }
+}
diff --git a/src/main/info/pavie/osm2hive/model/xml/package-info.java b/src/main/info/pavie/osm2hive/model/xml/package-info.java
new file mode 100644
index 0000000..53f9661
--- /dev/null
+++ b/src/main/info/pavie/osm2hive/model/xml/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Classes related to XML data parsing.
+ */
+package info.pavie.osm2hive.model.xml;
\ No newline at end of file
diff --git a/src/main/info/pavie/osm2hive/package-info.java b/src/main/info/pavie/osm2hive/package-info.java
new file mode 100644
index 0000000..8f8829c
--- /dev/null
+++ b/src/main/info/pavie/osm2hive/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * OSM2Hive main package.
+ */
+package info.pavie.osm2hive;
\ No newline at end of file
diff --git a/src/test/info/pavie/osm2hive/TestSuite.java b/src/test/info/pavie/osm2hive/TestSuite.java
new file mode 100644
index 0000000..4046544
--- /dev/null
+++ b/src/test/info/pavie/osm2hive/TestSuite.java
@@ -0,0 +1,21 @@
+package info.pavie.osm2hive;
+
+import info.pavie.osm2hive.controller.TestOSMParser;
+import info.pavie.osm2hive.model.xml.TestMarkup;
+import info.pavie.osm2hive.model.xml.TestState;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ TestOSMParser.class,
+ TestState.class,
+ TestMarkup.class
+ })
+
+/**
+ * This class runs all project tests.
+ * @author Adrien PAVIE
+ */
+public class TestSuite {;}
\ No newline at end of file
diff --git a/src/test/info/pavie/osm2hive/controller/TestOSMParser.java b/src/test/info/pavie/osm2hive/controller/TestOSMParser.java
new file mode 100644
index 0000000..834d698
--- /dev/null
+++ b/src/test/info/pavie/osm2hive/controller/TestOSMParser.java
@@ -0,0 +1,164 @@
+package info.pavie.osm2hive.controller;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import info.pavie.osm2hive.model.osm.Element;
+import info.pavie.osm2hive.model.osm.Node;
+import info.pavie.osm2hive.model.osm.Relation;
+import info.pavie.osm2hive.model.osm.Way;
+import info.pavie.osm2hive.model.xml.InvalidMarkupException;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Scanner;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Test class for {@link OSMParser}.
+ * @author Adrien PAVIE
+ */
+public class TestOSMParser {
+//ATTRIBUTES
+ private OSMParser p1;
+ private Map result;
+ private List readLines;
+
+//SETUP
+ @Before
+ public void setUp() throws Exception {
+ p1 = new OSMParser();
+ result = new HashMap();
+ }
+
+//OTHER METHODS
+ /**
+ * Reads a text file, and returns lines as a list
+ * @param f The file to read
+ * @return The list of read lines
+ * @throws FileNotFoundException If file isn't found
+ */
+ private List readFileLines(File f) throws FileNotFoundException {
+ List lines = new ArrayList();
+ Scanner s = new Scanner(f);
+ while(s.hasNextLine()) {
+ lines.add(s.nextLine());
+ }
+ s.close();
+ return lines;
+ }
+
+//TESTS
+// parse()
+ /**
+ * Test data from sample.osm
+ */
+ private void testSampleFile() {
+ //First node
+ Node n1 = (Node) result.get("N298884269");
+ assertEquals(54.0901746, n1.getLat(), 0);
+ assertEquals(12.2482632, n1.getLon(), 0);
+ assertEquals("SvenHRO", n1.getUser());
+ assertEquals(46882, n1.getUid());
+ assertTrue(n1.isVisible());
+ assertEquals(1, n1.getVersion());
+ assertEquals(676636, n1.getChangeset());
+ assertEquals("2008-09-21T21:37:45Z", n1.getTimestamp());
+ assertEquals(0, n1.getTags().size());
+
+ //Tagged node
+ Node n2 = (Node) result.get("N1831881213");
+ assertEquals(54.0900666, n2.getLat(), 0);
+ assertEquals(12.2539381, n2.getLon(), 0);
+ assertEquals("lafkor", n2.getUser());
+ assertEquals(75625, n2.getUid());
+ assertTrue(n2.isVisible());
+ assertEquals(1, n2.getVersion());
+ assertEquals(12370172, n2.getChangeset());
+ assertEquals("2012-07-20T09:43:19Z", n2.getTimestamp());
+ assertEquals(2, n2.getTags().size());
+ assertEquals("Neu Broderstorf", n2.getTags().get("name"));
+ assertEquals("city_limit", n2.getTags().get("traffic_sign"));
+
+ //Way
+ Way w1 = (Way) result.get("W26659127");
+ assertEquals("Masch", w1.getUser());
+ assertEquals(55988, w1.getUid());
+ assertTrue(w1.isVisible());
+ assertEquals(5, w1.getVersion());
+ assertEquals(4142606, w1.getChangeset());
+ assertEquals("2010-03-16T11:47:08Z", w1.getTimestamp());
+ assertEquals(2, w1.getTags().size());
+ assertEquals("unclassified", w1.getTags().get("highway"));
+ assertEquals("Pastower Straße", w1.getTags().get("name"));
+ assertEquals(3, w1.getNodes().size());
+ assertEquals("N298884269", w1.getNodes().get(0));
+ assertEquals("N298884272", w1.getNodes().get(1));
+ assertEquals("N261728686", w1.getNodes().get(2));
+
+ //Relation
+ Relation r1 = (Relation) result.get("R56688");
+ assertEquals("kmvar", r1.getUser());
+ assertEquals(56190, r1.getUid());
+ assertTrue(r1.isVisible());
+ assertEquals(28, r1.getVersion());
+ assertEquals(6947637, r1.getChangeset());
+ assertEquals("2011-01-12T14:23:49Z", r1.getTimestamp());
+ assertEquals(6, r1.getTags().size());
+ assertEquals("Küstenbus Linie 123", r1.getTags().get("name"));
+ assertEquals("VVW", r1.getTags().get("network"));
+ assertEquals("Regionalverkehr Küste", r1.getTags().get("operator"));
+ assertEquals("123", r1.getTags().get("ref"));
+ assertEquals("bus", r1.getTags().get("route"));
+ assertEquals("route", r1.getTags().get("type"));
+ assertEquals(4, r1.getMembers().size());
+ assertEquals("N298884269", r1.getMembers().get(0));
+ assertEquals("N261728686", r1.getMembers().get(1));
+ assertEquals("W26659127", r1.getMembers().get(2));
+ assertEquals("N298884272", r1.getMembers().get(3));
+ assertEquals("stop", r1.getMemberRole("N298884269"));
+ assertEquals("path", r1.getMemberRole("W26659127"));
+ }
+
+ @Test
+ public void testParse() throws IOException, InvalidMarkupException {
+ readLines = readFileLines(new File("res/xml/sample.osm"));
+
+ for(String line : readLines) {
+ p1.parse(line);
+ if(p1.isElementReady()) {
+ result.put(p1.getCurrentElement().getId(), p1.getCurrentElement());
+ }
+ }
+
+ testSampleFile();
+ }
+
+ @Test
+ public void testParseVillage() throws IOException, InvalidMarkupException {
+ readLines = readFileLines(new File("res/xml/bleruais.osm"));
+
+ for(String line : readLines) {
+ p1.parse(line);
+ if(p1.isElementReady()) {
+ result.put(p1.getCurrentElement().getId(), p1.getCurrentElement());
+ }
+ }
+
+ Way single1 = (Way) result.get("W108790362");
+ assertEquals(2, single1.getNodes().size());
+
+ Way single4_1 = (Way) result.get("W108790361");
+ assertEquals(2, single4_1.getNodes().size());
+
+ Way single4_2 = (Way) result.get("W108790366");
+ assertEquals(2, single4_2.getNodes().size());
+ assertEquals(single4_1.getNodes().get(1), single4_2.getNodes().get(0));
+ }
+}
\ No newline at end of file
diff --git a/src/test/info/pavie/osm2hive/model/xml/TestMarkup.java b/src/test/info/pavie/osm2hive/model/xml/TestMarkup.java
new file mode 100644
index 0000000..cb9eb94
--- /dev/null
+++ b/src/test/info/pavie/osm2hive/model/xml/TestMarkup.java
@@ -0,0 +1,228 @@
+package info.pavie.osm2hive.model.xml;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Test class for {@link Markup}.
+ * @author Adrien PAVIE
+ */
+public class TestMarkup {
+//ATTRIBUTES
+ private Markup m1;
+
+//SETUP
+ @Before
+ public void setUp() throws Exception {
+ }
+
+//TESTS
+/*
+ * Constructor
+ */
+ @Test
+ public void testMarkupStartSimple() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.START, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("node", m1.getName());
+ }
+
+ @Test(expected=InvalidMarkupException.class)
+ public void testMarkupStartInvalid() throws InvalidMarkupException {
+ m1 = new Markup("");
+ }
+
+ @Test
+ public void testMarkupEmptySimple() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.EMPTY, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("node", m1.getName());
+ }
+
+ @Test(expected=InvalidMarkupException.class)
+ public void testMarkupEmptySimpleInvalid() throws InvalidMarkupException {
+ m1 = new Markup("");
+ }
+
+ @Test
+ public void testMarkupEmptySimpleSpaced() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.EMPTY, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("node", m1.getName());
+ }
+
+ @Test
+ public void testMarkupEndSimple() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.END, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("node", m1.getName());
+ }
+
+ @Test(expected=InvalidMarkupException.class)
+ public void testMarkupEndSimpleInvalid() throws InvalidMarkupException {
+ m1 = new Markup("");
+ }
+
+ @Test
+ public void testMarkupEndSimpleWhitespaces() throws InvalidMarkupException {
+ m1 = new Markup(" \t");
+ assertEquals(Markup.END, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("node", m1.getName());
+ }
+
+ @Test
+ public void testMarkupEmptyAttributeSpaced() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.EMPTY, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("value", m1.getAttribute("key"));
+ assertTrue(m1.hasAttribute("key"));
+ assertEquals("node", m1.getName());
+ }
+
+ @Test
+ public void testMarkupEmptyAttributeWithpunctationSpaced() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.EMPTY, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("value, is it the key !?", m1.getAttribute("key"));
+ assertTrue(m1.hasAttribute("key"));
+ assertEquals("node", m1.getName());
+ }
+
+ @Test(expected=InvalidMarkupException.class)
+ public void testMarkupEmptyAttributeSpacedInvalid() throws InvalidMarkupException {
+ m1 = new Markup("");
+ }
+
+ @Test(expected=InvalidMarkupException.class)
+ public void testMarkupEmptyAttributeSpacedInvalidChar() throws InvalidMarkupException {
+ m1 = new Markup("");
+ }
+
+ @Test
+ public void testMarkupEmptyMultiAttributesSpaced() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.EMPTY, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("value", m1.getAttribute("key"));
+ assertTrue(m1.hasAttribute("key"));
+ assertEquals("lala2", m1.getAttribute("key2"));
+ assertTrue(m1.hasAttribute("key2"));
+ assertEquals("42", m1.getAttribute("life"));
+ assertTrue(m1.hasAttribute("life"));
+ assertEquals("node", m1.getName());
+ }
+
+ @Test
+ public void testMarkupEmptyMultiAttributesUnspaced() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.EMPTY, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("value", m1.getAttribute("key"));
+ assertTrue(m1.hasAttribute("key"));
+ assertEquals("lala2", m1.getAttribute("key2"));
+ assertTrue(m1.hasAttribute("key2"));
+ assertEquals("42", m1.getAttribute("life"));
+ assertTrue(m1.hasAttribute("life"));
+ assertEquals("node", m1.getName());
+ }
+
+ @Test
+ public void testMarkupStartMultiAttributesUnspaced() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.START, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("value", m1.getAttribute("key"));
+ assertTrue(m1.hasAttribute("key"));
+ assertEquals("lala2", m1.getAttribute("key2"));
+ assertTrue(m1.hasAttribute("key2"));
+ assertEquals("42", m1.getAttribute("life"));
+ assertTrue(m1.hasAttribute("life"));
+ assertEquals("node", m1.getName());
+ }
+
+ @Test
+ public void testMarkupStartMultiAttributesSimplequoteUnspaced() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.START, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("value", m1.getAttribute("key"));
+ assertTrue(m1.hasAttribute("key"));
+ assertEquals("lala2", m1.getAttribute("key2"));
+ assertTrue(m1.hasAttribute("key2"));
+ assertEquals("42", m1.getAttribute("life"));
+ assertTrue(m1.hasAttribute("life"));
+ assertEquals("node", m1.getName());
+ }
+
+ @Test
+ public void testMarkupStartMultiAttributesEmptyUnspaced() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.START, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("value", m1.getAttribute("key"));
+ assertTrue(m1.hasAttribute("key"));
+ assertEquals("", m1.getAttribute("key2"));
+ assertTrue(m1.hasAttribute("key2"));
+ assertEquals("", m1.getAttribute("life"));
+ assertTrue(m1.hasAttribute("life"));
+ assertEquals("node", m1.getName());
+ }
+
+ @Test
+ public void testMarkupEmptyMultiAttributesSpacedText() throws InvalidMarkupException {
+ m1 = new Markup("TEEEXT 123");
+ assertEquals(Markup.COMPLETE, m1.getType());
+ assertEquals("TEEEXT 123", m1.getText());
+ assertEquals("value", m1.getAttribute("key"));
+ assertTrue(m1.hasAttribute("key"));
+ assertEquals("lala2", m1.getAttribute("key2"));
+ assertTrue(m1.hasAttribute("key2"));
+ assertEquals("42", m1.getAttribute("life"));
+ assertTrue(m1.hasAttribute("life"));
+ assertEquals("node", m1.getName());
+ }
+
+ @Test(expected=InvalidMarkupException.class)
+ public void testMarkupEmptyMultiAttributesSpacedTextInvalidNames() throws InvalidMarkupException {
+ m1 = new Markup("TEEEXT 123");
+ }
+
+ @Test
+ public void testMarkupDeclarationSimpleUnspaced() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.DECLARATION, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("1.0", m1.getAttribute("version"));
+ assertTrue(m1.hasAttribute("version"));
+ assertEquals("UTF-8", m1.getAttribute("encoding"));
+ assertTrue(m1.hasAttribute("encoding"));
+ assertEquals("xml", m1.getName());
+ }
+
+ @Test(expected=InvalidMarkupException.class)
+ public void testMarkupDeclarationSimpleUnspacedInvalid() throws InvalidMarkupException {
+ m1 = new Markup("");
+ }
+
+ @Test
+ public void testMarkupDeclarationSimpleSpaced() throws InvalidMarkupException {
+ m1 = new Markup("");
+ assertEquals(Markup.DECLARATION, m1.getType());
+ assertEquals("", m1.getText());
+ assertEquals("1.0", m1.getAttribute("version"));
+ assertTrue(m1.hasAttribute("version"));
+ assertEquals("UTF-8", m1.getAttribute("encoding"));
+ assertTrue(m1.hasAttribute("encoding"));
+ assertEquals("xml", m1.getName());
+ }
+}
diff --git a/src/test/info/pavie/osm2hive/model/xml/TestState.java b/src/test/info/pavie/osm2hive/model/xml/TestState.java
new file mode 100644
index 0000000..efaac6d
--- /dev/null
+++ b/src/test/info/pavie/osm2hive/model/xml/TestState.java
@@ -0,0 +1,120 @@
+package info.pavie.osm2hive.model.xml;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Test class for {@link State}.
+ * @author Adrien PAVIE
+ */
+public class TestState {
+//ATTRIBUTES
+ private State s1, s2, s3, s4, s5;
+ private StringBuilder sb1;
+
+//SETUP
+ @Before
+ public void setUp() throws Exception {
+ sb1 = new StringBuilder();
+
+ s1 = new State();
+ s2 = new State(true);
+ s3 = new State(false, sb1);
+ s4 = new State(false, sb1);
+ s5 = new State(true);
+ }
+
+//TESTS
+/*
+ * Constructors
+ */
+ @Test
+ public void testState() {
+ assertFalse(s1.isFinal());
+ assertNull(s1.getCapture());
+ }
+
+ @Test
+ public void testStateBoolean() {
+ assertTrue(s2.isFinal());
+ assertNull(s2.getCapture());
+ }
+
+ @Test
+ public void testStateBooleanStringBuilder() {
+ assertFalse(s3.isFinal());
+ assertEquals(sb1, s3.getCapture());
+ }
+
+/*
+ * eval()
+ */
+ @Test
+ public void testEvalOneFinalState() {
+ assertTrue(s2.eval(""));
+ }
+
+ @Test
+ public void testEvalOneNonFinalState() {
+ assertFalse(s1.eval(""));
+ assertFalse(s1.eval("You shall not pass !"));
+ }
+
+ @Test
+ public void testEvalTwoStatesSimple() {
+ s1.addTransition('a', s2);
+ s1.addTransition('b', s3);
+ s3.addTransition('c', s2);
+
+ assertTrue(s1.eval("a"));
+ assertTrue(s1.eval("bc"));
+ assertFalse(s1.eval("b"));
+ assertFalse(s1.eval("aa"));
+ }
+
+ @Test
+ public void testEvalTwoStatesUnicode() {
+ s1.addTransition('<', s2);
+
+ assertTrue(s1.eval("<"));
+ assertFalse(s1.eval(">"));
+ assertFalse(s1.eval("<>"));
+ }
+
+/*
+ * Tests related to capture
+ */
+ @Test
+ public void testCapture() {
+ s3.addTransition("[a-z]", s4);
+ s4.addTransition("[0-9]", s5);
+
+ String result = "c4";
+ assertTrue(s3.eval(result));
+ assertEquals(result, sb1.toString());
+ }
+/*
+ * addTransition()
+ */
+ @Test
+ public void testAddTransitionStringState() {
+ s1.addTransition("[a-z]", s2);
+
+ assertTrue(s1.eval("a"));
+ assertTrue(s1.eval("x"));
+ assertFalse(s1.eval("T"));
+ }
+
+ @Test
+ public void testAddTransitionCharState() {
+ s1.addTransition('é', s2);
+ assertTrue(s1.eval("é"));
+ assertFalse(s1.eval("b"));
+ }
+
+}