From f07653736cdf6665a0ab8e39fe5427a095c1730b Mon Sep 17 00:00:00 2001 From: Michael Vorburger Date: Tue, 26 Jul 2016 05:46:08 +0200 Subject: [PATCH] Intro. new yangtools.testutils artifacts (incl. Mikito) Seeding new project with proposed Mikito (new), and a MockitoUnstubbedMethodExceptionAnswer (alternative to yangtools.mockito-configuration; see the package-info.java in mockito-configuration about why this is not being proposed in that project). Change-Id: I78237936924e0befc0ff17e7604e0fb33262d7cd Signed-off-by: Michael Vorburger --- common/artifacts/pom.xml | 6 + common/pom.xml | 1 + common/testutils/pom.xml | 76 ++++++++++ .../mockito/CallsRealOrExceptionAnswer.java | 132 ++++++++++++++++++ .../testutils/mockito/MethodExtensions.java | 55 ++++++++ .../testutils/mockito/MoreAnswers.java | 52 +++++++ .../mockito/ThrowsMethodExceptionAnswer.java | 53 +++++++ .../mockito/UnstubbedMethodException.java | 29 ++++ .../mockito/tests/MethodExtensionsTest.java | 27 ++++ .../testutils/mockito/tests/MikitoTest.java | 70 ++++++++++ .../tests/MockitoExampleTutorialTest.java | 110 +++++++++++++++ ...itoUnstubbedMethodExceptionAnswerTest.java | 34 +++++ common/util/pom.xml | 2 +- 13 files changed, 646 insertions(+), 1 deletion(-) create mode 100644 common/testutils/pom.xml create mode 100644 common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/CallsRealOrExceptionAnswer.java create mode 100644 common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/MethodExtensions.java create mode 100644 common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/MoreAnswers.java create mode 100644 common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/ThrowsMethodExceptionAnswer.java create mode 100644 common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/UnstubbedMethodException.java create mode 100644 common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MethodExtensionsTest.java create mode 100644 common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MikitoTest.java create mode 100644 common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MockitoExampleTutorialTest.java create mode 100644 common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MockitoUnstubbedMethodExceptionAnswerTest.java diff --git a/common/artifacts/pom.xml b/common/artifacts/pom.xml index c24871f06e..d9d64f7d9d 100644 --- a/common/artifacts/pom.xml +++ b/common/artifacts/pom.xml @@ -151,6 +151,12 @@ ${project.version} test + + ${project.groupId} + testutils + ${project.version} + test + diff --git a/common/pom.xml b/common/pom.xml index 03ac840b61..e207bcbeef 100644 --- a/common/pom.xml +++ b/common/pom.xml @@ -32,6 +32,7 @@ object-cache-guava object-cache-noop util + testutils + + + + + org.opendaylight.yangtools + yangtools-artifacts + ${project.version} + import + pom + + + + + + + + org.slf4j + slf4j-api + + + org.slf4j + slf4j-simple + + + junit + junit + + + org.mockito + mockito-all + compile + + + com.google.truth + truth + + + org.eclipse.xtend + org.eclipse.xtend.lib + + + + + + + org.eclipse.xtend + xtend-maven-plugin + + + + + diff --git a/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/CallsRealOrExceptionAnswer.java b/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/CallsRealOrExceptionAnswer.java new file mode 100644 index 0000000000..9426fd3f06 --- /dev/null +++ b/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/CallsRealOrExceptionAnswer.java @@ -0,0 +1,132 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.testutils.mockito; + +import com.google.common.annotations.Beta; +import java.io.Serializable; +import java.lang.reflect.Modifier; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; + +/** + * Mockito Answer which for un-stubbed methods forwards the call to the real + * method if it is implemented on the mocked object (i.e. not an interface or + * abstract method), and otherwise throws an {@link UnstubbedMethodException}, like the + * {@link ThrowsMethodExceptionAnswer}. + * + *

+ * This can be useful to create light-weight Fake Doubles + * (in particular some with state). For example: + * + * 

+ * import static ...testutils.mockito.MoreAnswers.realOrException;
+ *
+ * interface Service {
+ *     List<Thing> getThings();
+ *     boolean installThing(Thing thing);
+ * }
+ *
+ * abstract class FakeService implements Service {
+ *     // Ignore getThings() - we don't need that for this test
+ *     boolean installThing(Thing thing) {
+ *         LOGGER.log("not really installed");
+ *         return false;
+ *     }
+ * }
+ *
+ * Service fake = Mockito.mock(FakeService.class, realOrException())
+ *
+ * + *

+ * TIP: An impact of Mockito is that, just like in standard Mockito, constructors + * (and thus field initializers) are not called. So in your abstract fake class, + * instead of: + * + * 

+ * abstract class FakeService implements Service {
+ *     private final List<Thing> things = new ArrayList<>();
+ *
+ *     public List<Thing> getThings() {
+ *         return things;
+ *     }
+ *
+ *     @Override
+ *     public boolean installThing(Thing thing) {
+ *         return things.add(thing);
+ *     }
+ * }
+ *
+ * + *

+ * you'll just need to do: + * + * 

+ * abstract class FakeService implements Service {
+ *     private List<Thing> things;
+ *
+ *     public List<Thing> getThings() {
+ *         if (things == null)
+ *             things = new ArrayList<>()
+ *         return things;
+ *     }
+ *
+ *     @Override
+ *     public boolean installThing(Thing thing) {
+ *         return getThings().add(thing);
+ *     }
+ * }
+ *
+ * + *

+ * The big advantage of Mikitos versus just writing classes implementing service + * interfaces without using Mockito at all is that you don't have to implement a + * lot of methods you don't care about - you can just make an abstract fake + * class (incl. e.g. an inner class in your Test) and implement only one or some + * methods. This keeps code shorter and thus more readable. + * + *

+ * The advantage of Mikitos VS pure Mockito's when/thenAnswer are that they: + *

+ * + * @see Mockito#mock(Class, Answer) + * @see ThrowsMethodExceptionAnswer + * @see Mockito#CALLS_REAL_METHODS + * @see Mockito#CALLS_REAL_METHODS + * + * @author Michael Vorburger + */ +@Beta +public class CallsRealOrExceptionAnswer implements Answer, Serializable { + private static final long serialVersionUID = -3730024662402964588L; + + /** + * Use {@link MoreAnswers} to obtain an instance. + */ + CallsRealOrExceptionAnswer() { + } + + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + if (Modifier.isAbstract(invocation.getMethod().getModifiers())) { + throw new UnstubbedMethodException(invocation.getMethod(), invocation.getMock()); + } + return invocation.callRealMethod(); + } +} diff --git a/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/MethodExtensions.java b/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/MethodExtensions.java new file mode 100644 index 0000000000..c81bcc0a78 --- /dev/null +++ b/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/MethodExtensions.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.testutils.mockito; + +import java.lang.reflect.Method; +import java.lang.reflect.Parameter; +import java.lang.reflect.Type; + +/** + * Nicer shorter toString() for {@link Method} than it's default. + * + *

Without modifiers, return type, FQN of class and exceptions; instead with parameter names (if javac -parameters). + * + * @author Michael Vorburger + */ +public final class MethodExtensions { + + private MethodExtensions() { + } + + public static String toString(Method method) { + StringBuilder sb = new StringBuilder(); + sb.append(method.getName()); + + // copy/paste from java.lang.reflect.Executable.sharedToGenericString(int, boolean) + sb.append('('); + Type[] params = method.getGenericParameterTypes(); + Parameter[] parameters = method.getParameters(); // NEW + for (int j = 0; j < params.length; j++) { + String param = params[j].getTypeName(); + if (method.isVarArgs() && j == params.length - 1) { // replace T[] with T... + param = param.replaceFirst("\\[\\]$", "..."); + } + sb.append(param); + // NEW + if (parameters[j].isNamePresent()) { + sb.append(' '); + sb.append(parameters[j].getName()); + } + // NEW END + if (j < (params.length - 1)) { + sb.append(", "); // NEW ", " instead of ',' + } + } + sb.append(')'); + + return sb.toString(); + } + +} diff --git a/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/MoreAnswers.java b/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/MoreAnswers.java new file mode 100644 index 0000000000..ce0089bf37 --- /dev/null +++ b/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/MoreAnswers.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.testutils.mockito; + +import org.mockito.AdditionalAnswers; +import org.mockito.Answers; +import org.mockito.stubbing.Answer; + +/** + * More {@link Answer} variants. + * + * @see Answers + * @see AdditionalAnswers + * + * @author Michael Vorburger + */ +@SuppressWarnings("unchecked") +public final class MoreAnswers { + + private static final CallsRealOrExceptionAnswer REAL_OR_EXCEPTION + = new CallsRealOrExceptionAnswer(); + + private static final ThrowsMethodExceptionAnswer EXCEPTION + = new ThrowsMethodExceptionAnswer(); + + private MoreAnswers() { + } + + /** + * Returns Mockito Answer (default) which forwards method calls or throws an UnstubbedMethodException. + * + * @see CallsRealOrExceptionAnswer + */ + public static Answer realOrException() { + return (Answer) REAL_OR_EXCEPTION; + } + + /** + * Returns Mockito Answer (default) which throws an UnstubbedMethodException. + * + * @see ThrowsMethodExceptionAnswer + */ + public static Answer exception() { + return (Answer) EXCEPTION; + } + +} diff --git a/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/ThrowsMethodExceptionAnswer.java b/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/ThrowsMethodExceptionAnswer.java new file mode 100644 index 0000000000..f5af1bfc42 --- /dev/null +++ b/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/ThrowsMethodExceptionAnswer.java @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.testutils.mockito; + +import com.google.common.annotations.Beta; +import java.io.Serializable; +import org.mockito.Mockito; +import org.mockito.internal.stubbing.answers.ThrowsException; +import org.mockito.internal.stubbing.answers.ThrowsExceptionClass; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; + +/** + * Mockito Answer which for un-stubbed methods throws an + * UnstubbedMethodException (instead of Mockito's default of returning null). + * + *

+ * Usage: + * + * 

+ * import static ...testutils.mockito.MoreAnswers.exception;
+ *
+ * Mockito.mock(YourInterface.class, exception())
+ *
+ * + * @see Mockito#mock(Class, Answer) + * + * @see ThrowsException + * @see ThrowsExceptionClass + * + * @author Michael Vorburger + */ +@Beta +public class ThrowsMethodExceptionAnswer implements Answer, Serializable { + private static final long serialVersionUID = -7316574192253912318L; + + /** + * Use {@link MoreAnswers} to obtain an instance. + */ + ThrowsMethodExceptionAnswer() { + } + + @Override + public Void answer(InvocationOnMock invocation) throws Throwable { + throw new UnstubbedMethodException(invocation.getMethod()); + } + +} diff --git a/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/UnstubbedMethodException.java b/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/UnstubbedMethodException.java new file mode 100644 index 0000000000..5e84a02036 --- /dev/null +++ b/common/testutils/src/main/java/org/opendaylight/yangtools/testutils/mockito/UnstubbedMethodException.java @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2016 Red Hat and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.testutils.mockito; + +import java.lang.reflect.Method; +import org.mockito.internal.util.MockUtil; + +/** + * Exception to be thrown on unstubbed method calls. + * + * @author Michael Vorburger + */ +public class UnstubbedMethodException extends UnsupportedOperationException { + private static final long serialVersionUID = 1L; + + public UnstubbedMethodException(Method method) { + super(MethodExtensions.toString(method) + " is not stubbed in mock of " + method.getDeclaringClass().getName()); + } + + public UnstubbedMethodException(Method method, Object mockAbstractFakeObject) { + super(MethodExtensions.toString(method) + " is not implemented in " + + new MockUtil().getMockName(mockAbstractFakeObject).toString()); + } +} diff --git a/common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MethodExtensionsTest.java b/common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MethodExtensionsTest.java new file mode 100644 index 0000000000..a48538ca98 --- /dev/null +++ b/common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MethodExtensionsTest.java @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.testutils.mockito.tests; + +import static com.google.common.truth.Truth.assertThat; + +import java.lang.reflect.Method; +import org.junit.Test; +import org.opendaylight.yangtools.testutils.mockito.MethodExtensions; + +public class MethodExtensionsTest { + + public void fooBar(int index, T element) { + } + + @Test + public void betterToString() throws Exception { + Method method = MethodExtensionsTest.class.getMethod("fooBar", Integer.TYPE, Object.class); + assertThat(MethodExtensions.toString(method)).isEqualTo("fooBar(int index, T element)"); + } + +} diff --git a/common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MikitoTest.java b/common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MikitoTest.java new file mode 100644 index 0000000000..7708a8779a --- /dev/null +++ b/common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MikitoTest.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.testutils.mockito.tests; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; +import static org.opendaylight.yangtools.testutils.mockito.MoreAnswers.realOrException; + +import java.io.File; +import org.junit.Test; +import org.mockito.Mockito; +import org.opendaylight.yangtools.testutils.mockito.UnstubbedMethodException; + +/** + * Test to illustrate the use of the REAL_OR_EXCEPTION. + * + *

Also useful as example to contrast this approach illustrated in the MockitoExampleTutorialTest. + * + * @see MockitoExampleTutorialTest + * + * @author Michael Vorburger + */ +public class MikitoTest { + + interface SomeService { + + void foo(); + + String bar(String arg); + + // Most methods on real world services have complex input (and output objects), not just int or String + int foobar(File file); + } + + @Test + public void usingMikitoToCallStubbedMethod() { + SomeService service = Mockito.mock(MockSomeService.class, realOrException()); + assertEquals(123, service.foobar(new File("hello.txt"))); + assertEquals(0, service.foobar(new File("belo.txt"))); + } + + @Test + public void usingMikitoToCallUnstubbedMethodAndExpectException() { + MockSomeService service = Mockito.mock(MockSomeService.class, realOrException()); + try { + service.foo(); + fail(); + } catch (UnstubbedMethodException e) { + assertThat(e.getMessage()).isEqualTo("foo() is not implemented in mockSomeService"); + } + } + + abstract static class MockSomeService implements SomeService { + @Override + public int foobar(File file) { + if (file.getName().equals("hello.txt")) { + return 123; + } else { + return 0; + } + } + } + +} diff --git a/common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MockitoExampleTutorialTest.java b/common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MockitoExampleTutorialTest.java new file mode 100644 index 0000000000..0896717eca --- /dev/null +++ b/common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MockitoExampleTutorialTest.java @@ -0,0 +1,110 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.testutils.mockito.tests; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.fail; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; +import static org.opendaylight.yangtools.testutils.mockito.MoreAnswers.exception; + +import java.io.File; +import org.junit.Test; +import org.opendaylight.yangtools.testutils.mockito.UnstubbedMethodException; + +/** + * Test to illustrate the basic use of Mockito VS the EXCEPTION_ANSWER. + * + *

Also useful as example to contrast this approach with the REAL_OR_EXCEPTION + * approach illustrated in the MikitoTest. + * + * @see MikitoTest + * + * @author Michael Vorburger + */ +public class MockitoExampleTutorialTest { + + interface SomeService { + + void foo(); + + String bar(String arg); + + // Most methods on real world services have complex input (and output objects), not just int or String + int foobar(File file); + } + + @Test + public void usingMockitoWithoutStubbing() { + SomeService service = mock(SomeService.class); + assertNull(service.bar("hulo")); + } + + @Test + public void usingMockitoToStubSimpleCase() { + SomeService service = mock(SomeService.class); + when(service.foobar(any())).thenReturn(123); + assertEquals(123, service.foobar(new File("hello.txt"))); + } + + @Test + public void usingMockitoToStubComplexCase() { + SomeService service = mock(SomeService.class); + when(service.foobar(any())).thenAnswer(invocation -> { + // Urgh! This is ugly.. (Mockito 2.0 may be better, see http://site.mockito.org/mockito/docs/current/org/mockito/ArgumentMatcher.html) + File file = (File) invocation.getArgumentAt(0, File.class); + if (file.getName().equals("hello.txt")) { + return 123; + } else { + return 0; + } + }); + assertEquals(0, service.foobar(new File("belo.txt"))); + } + + @Test(expected = UnstubbedMethodException.class) + public void usingMockitoExceptionException() { + SomeService service = mock(SomeService.class, exception()); + service.foo(); + } + + @Test + public void usingMockitoNoExceptionIfStubbed() { + SomeService service = mock(SomeService.class, exception()); + // NOT when(s.foobar(any())).thenReturn(123) BUT must be like this: + doReturn(123).when(service).foobar(any()); + assertEquals(123, service.foobar(new File("hello.txt"))); + try { + service.foo(); + fail("expected NotImplementedException"); + } catch (UnstubbedMethodException e) { + // OK + } + } + + @Test + public void usingMockitoToStubComplexCaseAndExceptionIfNotStubbed() { + SomeService service = mock(SomeService.class, exception()); + doAnswer(invocation -> { + // Urgh! This is ugly. Mockito may be better, see http://site.mockito.org/mockito/docs/current/org/mockito/ArgumentMatcher.html + File file = (File) invocation.getArguments()[0]; + if (file.getName().equals("hello.txt")) { + return 123; + } else { + return 0; + } + }).when(service).foobar(any()); + assertEquals(123, service.foobar(new File("hello.txt"))); + assertEquals(0, service.foobar(new File("belo.txt"))); + } + +} diff --git a/common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MockitoUnstubbedMethodExceptionAnswerTest.java b/common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MockitoUnstubbedMethodExceptionAnswerTest.java new file mode 100644 index 0000000000..2b1296f663 --- /dev/null +++ b/common/testutils/src/test/java/org/opendaylight/yangtools/testutils/mockito/tests/MockitoUnstubbedMethodExceptionAnswerTest.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2016 Red Hat, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.testutils.mockito.tests; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.fail; +import static org.opendaylight.yangtools.testutils.mockito.MoreAnswers.exception; + +import java.io.Closeable; +import java.io.IOException; +import org.junit.Test; +import org.mockito.Mockito; +import org.opendaylight.yangtools.testutils.mockito.UnstubbedMethodException; + +public class MockitoUnstubbedMethodExceptionAnswerTest { + + @Test + public void testAnswering() throws IOException { + Closeable mock = Mockito.mock(Closeable.class, exception()); + try { + mock.close(); + fail(); + } catch (UnstubbedMethodException e) { + assertThat(e.getMessage()).isEqualTo("close() is not stubbed in mock of java.io.Closeable"); + } + + } + +} diff --git a/common/util/pom.xml b/common/util/pom.xml index 93f1b9329e..f3e71bb582 100644 --- a/common/util/pom.xml +++ b/common/util/pom.xml @@ -26,7 +26,7 @@ org.opendaylight.yangtools yangtools-artifacts - 1.1.0-SNAPSHOT + ${project.version} import pom -- 2.36.6