private static final String QNAME_STRING_NO_REVISION = "^\\((.+)\\)(.+)$";
private static final Pattern QNAME_PATTERN_NO_REVISION = Pattern.compile(QNAME_STRING_NO_REVISION);
- @RegEx
- private static final String QNAME_STRING_NO_NAMESPACE_NO_REVISION = "^(.+)$";
- private static final Pattern QNAME_PATTERN_NO_NAMESPACE_NO_REVISION =
- Pattern.compile(QNAME_STRING_NO_NAMESPACE_NO_REVISION);
-
private static final char[] ILLEGAL_CHARACTERS = new char[] { '?', '(', ')', '&', ':' };
// Non-null
final String localName = matcher.group(2);
return new QName(namespace, localName);
}
- matcher = QNAME_PATTERN_NO_NAMESPACE_NO_REVISION.matcher(input);
- if (matcher.matches()) {
- final String localName = matcher.group(1);
- return new QName((URI) null, localName);
- }
- throw new IllegalArgumentException("Invalid input:" + input);
+ throw new IllegalArgumentException("Invalid input: " + input);
}
public static QName create(final QName base, final String localName) {
*/
package org.opendaylight.yangtools.yang.common;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.collect.Interner;
import com.google.common.collect.Interners;
public final class QNameModule implements Immutable, Serializable {
private static final Interner<QNameModule> INTERNER = Interners.newWeakInterner();
private static final Logger LOG = LoggerFactory.getLogger(QNameModule.class);
- private static final QNameModule NULL_INSTANCE = new QNameModule(null, null);
private static final long serialVersionUID = 2L;
- //Nullable
private final URI namespace;
//Nullable
private transient int hash;
private QNameModule(final URI namespace, final Date revision) {
- // FIXME: 2.0.0: Preconditions.checkNotNull(namespace)
- this.namespace = namespace;
+ this.namespace = requireNonNull(namespace);
this.revision = revision;
}
* @return A new, potentially shared, QNameModule instance
*/
public static QNameModule create(final URI namespace, final Date revision) {
- if (namespace == null && revision == null) {
- return NULL_INSTANCE;
- }
-
return new QNameModule(namespace, revision);
}
import org.junit.Test;
public class QNameTest {
- private final String namespace = "urn:foo";
- private final String revision = "2013-12-24";
- private final String localName = "bar";
- private final URI ns = URI.create(namespace);
+ private static final String NAMESPACE = "urn:foo";
+ private static final String REVISION = "2013-12-24";
+ private static final String LOCALNAME = "bar";
+ private static final URI NS = URI.create(NAMESPACE);
@Test
public void testStringSerialization() throws Exception {
{
- QName qname = QName.create(namespace, revision, localName);
- assertEquals(QName.QNAME_LEFT_PARENTHESIS + namespace + QName.QNAME_REVISION_DELIMITER
- + revision + QName.QNAME_RIGHT_PARENTHESIS + localName, qname.toString());
+ QName qname = QName.create(NAMESPACE, REVISION, LOCALNAME);
+ assertEquals(QName.QNAME_LEFT_PARENTHESIS + NAMESPACE + QName.QNAME_REVISION_DELIMITER
+ + REVISION + QName.QNAME_RIGHT_PARENTHESIS + LOCALNAME, qname.toString());
QName copied = QName.create(qname.toString());
assertEquals(qname, copied);
}
// no revision
{
- QName qname = new QName(ns, localName);
- assertEquals(QName.QNAME_LEFT_PARENTHESIS + namespace + QName.QNAME_RIGHT_PARENTHESIS
- + localName, qname.toString());
- QName copied = QName.create(qname.toString());
- assertEquals(qname, copied);
- }
- // no namespace nor revision
- {
- QName qname = new QName(null, localName);
- assertEquals(localName, qname.toString());
+ QName qname = new QName(NS, LOCALNAME);
+ assertEquals(QName.QNAME_LEFT_PARENTHESIS + NAMESPACE + QName.QNAME_RIGHT_PARENTHESIS
+ + LOCALNAME, qname.toString());
QName copied = QName.create(qname.toString());
assertEquals(qname, copied);
}
final String A = "a";
final String B = "b";
- QName qa = QName.create(A);
- QName qb = QName.create(A);
- assertTrue(qa.compareTo(qb) == 0);
- assertTrue(qb.compareTo(qa) == 0);
-
- // compare with localName
- qa = QName.create(A);
- qb = QName.create(B);
- assertTrue(qa.compareTo(qb) < 0);
- assertTrue(qb.compareTo(qa) > 0);
-
// compare with namespace
- qa = QName.create(A, revision, A);
- qb = QName.create(B, revision, A);
- assertTrue(qa.compareTo(qb) < 0);
- assertTrue(qb.compareTo(qa) > 0);
-
- // compare with 1 null namespace
- qa = QName.create(null, QName.parseRevision(revision), A);
- qb = QName.create(URI.create(A), QName.parseRevision(revision), A);
+ QName qa = QName.create(A, REVISION, A);
+ QName qb = QName.create(B, REVISION, A);
assertTrue(qa.compareTo(qb) < 0);
assertTrue(qb.compareTo(qa) > 0);
- // compare with both null namespace
- qb = QName.create(null, QName.parseRevision(revision), A);
- assertTrue(qa.compareTo(qb) == 0);
- assertTrue(qb.compareTo(qa) == 0);
-
// compare with revision
qa = QName.create(A, "2013-12-24", A);
qb = QName.create(A, "2013-12-25", A);
// compare with 1 null revision
qa = QName.create(URI.create(A), null, A);
- qb = QName.create(URI.create(A), QName.parseRevision(revision), A);
+ qb = QName.create(URI.create(A), QName.parseRevision(REVISION), A);
assertTrue(qa.compareTo(qb) < 0);
assertTrue(qb.compareTo(qa) > 0);
@Test
public void testQName() {
- final QName qname = QName.create(namespace, revision, localName);
- final QName qname1 = QName.create(namespace, localName);
- final QName qname2 = QName.create(qname1, localName);
+ final QName qname = QName.create(NAMESPACE, REVISION, LOCALNAME);
+ final QName qname1 = QName.create(NAMESPACE, LOCALNAME);
+ final QName qname2 = QName.create(qname1, LOCALNAME);
assertEquals(qname1, qname.withoutRevision());
assertEquals(qname1, qname2);
assertTrue(qname.isEqualWithoutRevision(qname1));
@Test
public void testQNameModule() {
- final QNameModule qnameModule = QNameModule.create(ns, new Date());
+ final QNameModule qnameModule = QNameModule.create(NS, new Date());
assertNotNull(qnameModule.toString());
assertNotNull(qnameModule.getRevisionNamespace());
}
private static void assertLocalNameFails(final String localName) {
try {
- new QName(null, localName);
+ new QName(NS, localName);
fail("Local name should fail:" + localName);
} catch (IllegalArgumentException e) {
// Expected
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.annotations.Beta;
-import java.net.URI;
import java.util.Date;
import java.util.Optional;
-import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.ModuleIdentifier;
/**
@Deprecated
@Beta
public final class ModuleIdentifierImpl implements ModuleIdentifier {
- private final QNameModule qnameModule;
+ private final Date revision;
private final String name;
- private ModuleIdentifierImpl(final String name, final Optional<URI> namespace, final Optional<Date> revision) {
+ private ModuleIdentifierImpl(final String name, final Optional<Date> revision) {
this.name = checkNotNull(name);
- this.qnameModule = QNameModule.create(namespace.orElse(null), revision.orElse(null));
+ this.revision = revision.orElse(null);
}
public static ModuleIdentifier create(final String name, final Optional<Date> revision) {
- return new ModuleIdentifierImpl(name, Optional.empty(), revision);
- }
-
- public static ModuleIdentifier create(final String name, final Optional<URI> namespace,
- final Optional<Date> revision) {
- return new ModuleIdentifierImpl(name, namespace, revision);
+ return new ModuleIdentifierImpl(name, revision);
}
@Override
public Optional<Date> getRevision() {
- return Optional.ofNullable(qnameModule.getRevision());
+ return Optional.ofNullable(revision);
}
@Override
public String toString() {
return "ModuleIdentifierImpl{"
+ "name='" + name + '\''
- + ", revision=" + qnameModule.getFormattedRevision()
+ + ", revision=" + revision
+ '}';
}
}
private static ModuleIdentifier moduleToIdentifier(final Module module) {
- return ModuleIdentifierImpl.create(module.getName(), Optional.of(module.getNamespace()),
- Optional.of(module.getRevision()));
+ return ModuleIdentifierImpl.create(module.getName(), Optional.of(module.getRevision()));
}
private static SchemaNode findNodeInModule(final Module module, final Iterable<QName> path) {
MockitoAnnotations.initMocks(this);
doReturn("test").when(bit).getName();
- QName qname = QName.create("TestQName");
+ QName qname = QName.create("namespace", "localname");
SchemaPath schemaPath = SchemaPath.create(Collections.singletonList(qname), true);
BitsTypeDefinition bitsType = BaseTypes.bitsTypeBuilder(schemaPath).addBit(bit).build();
@Test
public void testMethodsOfLeafrefTest() {
- final SchemaPath schemaPath = SchemaPath.create(false, QName.create("Cont1"), QName.create("List1"));
+ final SchemaPath schemaPath = SchemaPath.create(false, QName.create("test", "Cont1"),
+ QName.create("test", "List1"));
final RevisionAwareXPathImpl revision = new RevisionAwareXPathImpl("/test:Cont1/test:List1", false);
final RevisionAwareXPathImpl revision2 = new RevisionAwareXPathImpl("/test:Cont1/test:List2", false);
assertNull("Base type of 'leafref' should be null.", leafref.getBaseType());
assertNull("Units of 'leafref' should be empty.", leafref.getUnits());
assertNull("Leafref does not have a default value", leafref.getDefaultValue());
- assertEquals(QName.create("List1"), leafref.getQName());
+ assertEquals(QName.create("test", "List1"), leafref.getQName());
assertEquals("SchemaPath of 'leafref' is '/Cont1/List1'.", schemaPath, leafref.getPath());
assertNull(leafref.getDescription());
assertNull(leafref.getReference());
@Test
public void testRequireInstanceSubstatement() {
- final SchemaPath schemaPath = SchemaPath.create(true, QName.create("my-cont"), QName.create("my-leafref"));
+ final SchemaPath schemaPath = SchemaPath.create(true, QName.create("test", "my-cont"),
+ QName.create("test", "my-leafref"));
final RevisionAwareXPathImpl path = new RevisionAwareXPathImpl("../my-leaf", false);
LeafrefTypeBuilder leafrefTypeBuilder = BaseTypes.leafrefTypeBuilder(schemaPath).setPathStatement(path);
leafrefTypeBuilder.setRequireInstance(false);
fail("An IllegalArgumentException should have been thrown.");
} catch (IllegalArgumentException ex) {
- assertEquals("Cannot switch off require-instance in type AbsoluteSchemaPath{path=[my-cont, my-leafref]}",
- ex.getMessage());
+ assertEquals(
+ "Cannot switch off require-instance in type AbsoluteSchemaPath{path=[(test)my-cont, (test)my-leafref]}",
+ ex.getMessage());
}
}
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doReturn;
+import java.net.URI;
import java.util.Collections;
import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
public class SchemaContextUtilTest {
+ private static final URI NAMESPACE = URI.create("abc");
@Mock
private SchemaContext mockSchemaContext;
@Mock
MockitoAnnotations.initMocks(this);
doReturn(Optional.empty()).when(mockSchemaContext).findModule(any(QNameModule.class));
- QName qname = QName.create("TestQName");
+ doReturn("test").when(mockModule).getPrefix();
+ doReturn(NAMESPACE).when(mockModule).getNamespace();
+ doReturn(QNameModule.create(NAMESPACE, null)).when(mockModule).getQNameModule();
+
+ QName qname = QName.create("namespace", "localname");
SchemaPath schemaPath = SchemaPath.create(Collections.singletonList(qname), true);
assertEquals("Should be null. Module TestQName not found", null,
SchemaContextUtil.findDataSchemaNode(mockSchemaContext, schemaPath));
- RevisionAwareXPath xpath = new RevisionAwareXPathImpl("/bookstore/book/title", true);
+ RevisionAwareXPath xpath = new RevisionAwareXPathImpl("/test:bookstore/test:book/test:title", true);
assertEquals("Should be null. Module bookstore not found", null,
SchemaContextUtil.findDataSchemaNode(mockSchemaContext, mockModule, xpath));
public void testFindDummyData() {
MockitoAnnotations.initMocks(this);
doReturn(Optional.empty()).when(mockSchemaContext).findModule(any(QNameModule.class));
+ doReturn(URI.create("dummy")).when(mockModule).getNamespace();
- final QName qName = QName.create("TestQName");
+ final QName qName = QName.create("dummy", "TestQName");
final SchemaPath schemaPath = SchemaPath.create(Collections.singletonList(qName), true);
assertEquals("Should be null. Module TestQName not found", null,
SchemaContextUtil.findDataSchemaNode(mockSchemaContext, schemaPath));
import static org.junit.Assert.assertTrue;
import com.google.common.collect.ImmutableSet;
-import java.net.URI;
import java.util.Date;
import java.util.Optional;
import java.util.Set;
@Test
public void testBug6961SchemaContext() throws Exception {
final Optional<Date> date = Optional.of(QName.parseRevision("2016-01-01"));
- final ModuleIdentifier foo = ModuleIdentifierImpl.create("foo", Optional.of(new URI("foo")), date);
- final ModuleIdentifier sub1Foo = ModuleIdentifierImpl.create("sub1-foo", Optional.of(new URI("foo")), date);
- final ModuleIdentifier sub2Foo = ModuleIdentifierImpl.create("sub2-foo", Optional.of(new URI("foo")), date);
- final ModuleIdentifier bar = ModuleIdentifierImpl.create("bar", Optional.of(new URI("bar")), date);
- final ModuleIdentifier sub1Bar = ModuleIdentifierImpl.create("sub1-bar", Optional.of(new URI("bar")), date);
- final ModuleIdentifier baz = ModuleIdentifierImpl.create("baz", Optional.of(new URI("baz")), date);
+ final ModuleIdentifier foo = ModuleIdentifierImpl.create("foo", date);
+ final ModuleIdentifier sub1Foo = ModuleIdentifierImpl.create("sub1-foo", date);
+ final ModuleIdentifier sub2Foo = ModuleIdentifierImpl.create("sub2-foo", date);
+ final ModuleIdentifier bar = ModuleIdentifierImpl.create("bar", date);
+ final ModuleIdentifier sub1Bar = ModuleIdentifierImpl.create("sub1-bar", date);
+ final ModuleIdentifier baz = ModuleIdentifierImpl.create("baz", date);
final Set<ModuleIdentifier> testSet = ImmutableSet.of(foo, sub1Foo, sub2Foo, bar, sub1Bar, baz);
final SchemaContext context = StmtTestUtils.parseYangSources("/bugs/bug6961/");
assertNotNull(context);
Code Review / yangtools.git / commitdiff