@Test
public void testMore() throws InterruptedException {
final Element e1 = TestUtils.getElement("test1", Regexp.<AbstractStructuralNode>getMutable());
final Element e2 = TestUtils.getElement("test2", Regexp.<AbstractStructuralNode>getMutable());
final Element e3 = TestUtils.getElement("test3", Regexp.<AbstractStructuralNode>getMutable());
final Element e4 = TestUtils.getElement("test4", Regexp.<AbstractStructuralNode>getMutable());
e1.getSubnodes().setType(RegexpType.CONCATENATION);
e1.getSubnodes().setInterval(RegexpInterval.getOnce());
e2.getSubnodes().setType(RegexpType.CONCATENATION);
e2.getSubnodes().setInterval(RegexpInterval.getOnce());
e3.getSubnodes().setType(RegexpType.CONCATENATION);
e3.getSubnodes().setInterval(RegexpInterval.getOnce());
e4.getSubnodes().setType(RegexpType.CONCATENATION);
e4.getSubnodes().setInterval(RegexpInterval.getOnce());
e1.getSubnodes().addChild(Regexp.<AbstractStructuralNode>getToken(e2));
e1.getSubnodes().addChild(Regexp.<AbstractStructuralNode>getToken(e3));
e3.getSubnodes().addChild(Regexp.<AbstractStructuralNode>getToken(e4));
final List<Element> elements = Arrays.asList(e1, e2);
Collections.shuffle(elements);
final TopologicalSort s = new TopologicalSort(elements);
final List<Element> toposorted = s.sort();
assertEquals(2, toposorted.size());
assertTrue(toposorted.indexOf(e1) > toposorted.indexOf(e2));
assertTrue(toposorted.indexOf(e1) > toposorted.indexOf(e3));
assertTrue(toposorted.indexOf(e2) > toposorted.indexOf(e4));
}
/** Test of cleanRegularExpression method, of class CleanerEmptyChildren. */
@Test
public void testCleanRegularExpression2() {
System.out.println("cleanRegularExpression2");
final Regexp<String> r3 = Regexp.<String>getMutable();
r3.setInterval(RegexpInterval.getOnce());
r3.setType(RegexpType.TOKEN);
r3.setContent("a");
r3.setImmutable();
final Regexp<String> r2 = Regexp.<String>getMutable();
r2.setInterval(RegexpInterval.getOnce());
r2.setType(RegexpType.CONCATENATION);
r2.addChild(r3);
r2.setImmutable();
final Regexp<String> r1 = Regexp.<String>getMutable();
r1.setInterval(RegexpInterval.getOnce());
r1.setType(RegexpType.CONCATENATION);
r1.addChild(r2);
r1.setImmutable();
final Regexp<String> regexp = r1;
final EmptyChildren<String> instance = new EmptyChildren<String>();
final Regexp<String> result = instance.cleanRegularExpression(regexp);
assertEquals("a", result.toString());
}
/**
* Check if <code>Element</code> is properly defined; redefine it to lambda when it was empty, or
* redefine it to token if it only contained a simple data type. This method should be used only
* when the tag of a node was ELEMENT!
*
* @param ret Element to be finalized.
*/
public static void finalizeElement(final Element ret, final List<String> newContext) {
if (ret.getSubnodes().getInterval() == null) {
ret.getSubnodes().setInterval(RegexpInterval.getOnce());
}
if (ret.getSubnodes().getChildren().isEmpty()
&& ret.getMetadata().containsKey(XSDAttribute.TYPE.getMetadataName())) {
// [SIMPLE DATA SECTION]
// element has empty children, but its specified type is one of the built-in types
// create SimpleData with the defined type of the element
ret.getSubnodes().setType(RegexpType.TOKEN);
ret.getSubnodes()
.setContent(
new SimpleData(
newContext,
XSDUtility.SIMPLE_DATA_NAME,
Collections.<String, Object>emptyMap(),
(String) ret.getMetadata().get(XSDAttribute.TYPE.getMetadataName()),
Collections.<String>emptyList()));
} else if (ret.getSubnodes().getChildren().isEmpty() && ret.getSubnodes().getType() == null) {
// element with empty children and no specified type has currently only one option
// since we don't support restrictions, extensions, complexcontent -> it has to be LAMBDA
XSDUtility.setLambda(ret);
} else if (ret.getSubnodes().getType() == null) {
// type of element must be non-null, but apparently it has some children
// this should not happen
LOG.warn(NbBundle.getMessage(DOMHelper.class, "Warn.SetDefaultType", ret.getName()));
ret.getSubnodes().setType(RegexpType.CONCATENATION);
ret.getSubnodes().setContent(null);
}
if (ret.isMutable()) {
ret.setImmutable();
}
}
@Test
public void testOne() throws InterruptedException {
final Element e = TestUtils.getElement("test", Regexp.<AbstractStructuralNode>getMutable());
e.getSubnodes().setType(RegexpType.CONCATENATION);
e.getSubnodes().setInterval(RegexpInterval.getOnce());
final TopologicalSort s = new TopologicalSort(Arrays.asList(e));
final List<Element> elements = s.sort();
assertEquals(1, elements.size());
assertEquals(e, elements.get(0));
}
/** Test of start method, of class SchemaGeneratorImpl. */
@Test
public void testStart1() throws Exception {
System.out.println("start alt 2,5");
Element c = Element.getMutable();
c.setName("c");
c.getSubnodes().setType(RegexpType.LAMBDA);
c.getSubnodes().setImmutable();
Element b = Element.getMutable();
b.setName("b");
b.getSubnodes().setType(RegexpType.LAMBDA);
b.getSubnodes().setImmutable();
Regexp<AbstractStructuralNode> rb = Regexp.<AbstractStructuralNode>getToken(b);
Regexp<AbstractStructuralNode> rc = Regexp.<AbstractStructuralNode>getToken(c);
Element treeBase = Element.getMutable();
treeBase.setName("a");
treeBase.getSubnodes().setType(RegexpType.ALTERNATION);
treeBase.getSubnodes().getChildren().add(rb);
treeBase.getSubnodes().getChildren().add(rc);
treeBase.getSubnodes().setInterval(RegexpInterval.getBounded(2, 5));
List<Element> grammar = new ArrayList<Element>();
grammar.add(treeBase);
SchemaGeneratorCallback callback =
new SchemaGeneratorCallback() {
@Override
public void finished(String schema, String extension) {
assertEquals(
"<!-- %generated% -->\n<!ELEMENT a ((b|c),(b|c),(b|c)?,(b|c)?,(b|c)?)>\n", schema);
}
};
SchemaGeneratorImpl instance = new SchemaGeneratorImpl();
instance.start(grammar, callback);
}