diff options
author | Maros Marsalek <mmarsale@cisco.com> | 2016-11-10 13:31:25 +0100 |
---|---|---|
committer | Marek Gradzki <mgradzki@cisco.com> | 2016-11-19 21:29:39 +0100 |
commit | 175197da8ea43335df3daeba4c6296fcd83a057c (patch) | |
tree | 110298a990c6191933c2ad65d1a06333bab76cee /vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp | |
parent | 1813bf59fa53e8eb913d34b212d45b227dead799 (diff) |
Post split cleanup
- change groupIds
- change packages
- update poms
Change-Id: I343c5a292a67de1dd50687870ca4ab5b7276e93e
Signed-off-by: Maros Marsalek <mmarsale@cisco.com>
Signed-off-by: Marek Gradzki <mgradzki@cisco.com>
Diffstat (limited to 'vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp')
7 files changed, 547 insertions, 0 deletions
diff --git a/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/read/JvppDumpExecutorTest.java b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/read/JvppDumpExecutorTest.java new file mode 100644 index 000000000..1259e89c8 --- /dev/null +++ b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/read/JvppDumpExecutorTest.java @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * 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 io.fd.hc2vpp.common.test.read; + +import static org.mockito.Matchers.anyLong; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor; +import io.fd.hc2vpp.common.test.util.FutureProducer; +import io.fd.vpp.jvpp.VppInvocationException; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import org.junit.Before; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +/** + * Generic test for implementation of {@link EntityDumpExecutor} + * + * @param <T> implementation of {@link EntityDumpExecutor} + */ +public abstract class JvppDumpExecutorTest<T extends EntityDumpExecutor<?, ?>> implements FutureProducer { + + @Mock + protected FutureJVppCore api; + + private T executor; + + @Before + public void setUpParent() { + MockitoAnnotations.initMocks(this); + this.executor = initExecutor(); + } + + protected abstract T initExecutor(); + + protected T getExecutor() { + return this.executor; + } + + /** + * Return pre-stubed mock that will throw {@link TimeoutException}, + * while performing desired method + */ + protected FutureJVppCore doThrowTimeoutExceptionWhen() + throws InterruptedException, ExecutionException, TimeoutException { + + CompletableFuture failedFuture = mock(CompletableFuture.class); + when(failedFuture.toCompletableFuture()).thenReturn(failedFuture); + when(failedFuture.get(anyLong(), eq(TimeUnit.SECONDS))) + .thenThrow(new TimeoutException("Exception invoked by " + JvppDumpExecutorTest.class.getName())); + + return doReturn(failedFuture).when(api); + } + + /** + * Return pre-stubed mock that will throw {@link VppInvocationException}, + * while performing desired method + */ + protected FutureJVppCore doThrowFailExceptionWhen() { + return doReturn(failedFuture()).when(api); + } + + /** + * Return pre-stubed mock that will return specified result + * while performing desired method + */ + protected <U> FutureJVppCore doReturnResponseWhen(U replyDump) { + return doReturn(future(replyDump)).when(api); + } +} diff --git a/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/read/ListReaderCustomizerTest.java b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/read/ListReaderCustomizerTest.java new file mode 100644 index 000000000..3c11b2d3c --- /dev/null +++ b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/read/ListReaderCustomizerTest.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * 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 io.fd.hc2vpp.common.test.read; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer; +import java.lang.reflect.Method; +import java.util.List; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.Identifiable; +import org.opendaylight.yangtools.yang.binding.Identifier; + +/** + * Generic test for classes implementing {@link ListReaderCustomizer} interface. + * + * @param <D> Specific DataObject derived type (Identifiable), that is handled by this customizer + * @param <K> Specific Identifier for handled type (D) + * @param <B> Specific Builder for handled type (D) + */ +public abstract class ListReaderCustomizerTest<D extends DataObject & Identifiable<K>, K extends Identifier<D>, B extends Builder<D>> extends + ReaderCustomizerTest<D, B> { + + protected ListReaderCustomizerTest( + final Class<D> dataObjectClass, + final Class<? extends Builder<? extends DataObject>> parentBuilderClass) { + super(dataObjectClass, parentBuilderClass); + } + + @Override + protected ListReaderCustomizer<D, K, B> getCustomizer() { + return ListReaderCustomizer.class.cast(super.getCustomizer()); + } + + @Override + public void testMerge() throws Exception { + final Builder<? extends DataObject> parentBuilder = mock(parentBuilderClass); + final List<D> value = (List<D>) mock(List.class); + getCustomizer().merge(parentBuilder, value); + + final Method method = parentBuilderClass.getMethod("set" + dataObjectClass.getSimpleName(), List.class); + method.invoke(verify(parentBuilder), value); + } +} diff --git a/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/read/ReaderCustomizerTest.java b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/read/ReaderCustomizerTest.java new file mode 100644 index 000000000..d403dce55 --- /dev/null +++ b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/read/ReaderCustomizerTest.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * 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 io.fd.hc2vpp.common.test.read; + +import static org.junit.Assert.assertNotNull; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +import io.fd.honeycomb.translate.MappingContext; +import io.fd.honeycomb.translate.ModificationCache; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.hc2vpp.common.test.util.FutureProducer; +import io.fd.hc2vpp.common.test.util.NamingContextHelper; +import java.lang.reflect.Method; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; + +/** + * Generic test for classes implementing {@link ReaderCustomizer} interface. + * + * @param <D> Specific DataObject derived type (Identifiable), that is handled by this customizer + * @param <B> Specific Builder for handled type (D) + */ +public abstract class ReaderCustomizerTest<D extends DataObject, B extends Builder<D>> implements FutureProducer, + NamingContextHelper { + + @Mock + protected FutureJVppCore api; + @Mock + protected ReadContext ctx; + @Mock + protected MappingContext mappingContext; + + protected final Class<? extends Builder<? extends DataObject>> parentBuilderClass; + protected final Class<D> dataObjectClass; + protected ModificationCache cache; + protected ReaderCustomizer<D, B> customizer; + + public ReaderCustomizerTest( + final Class<D> dataObjectClass, + final Class<? extends Builder<? extends DataObject>> parentBuilderClass) { + this.dataObjectClass = dataObjectClass; + this.parentBuilderClass = parentBuilderClass; + } + + @Before + public final void setUpParent() throws Exception { + MockitoAnnotations.initMocks(this); + cache = new ModificationCache(); + Mockito.doReturn(cache).when(ctx).getModificationCache(); + Mockito.doReturn(mappingContext).when(ctx).getMappingContext(); + setUp(); + customizer = initCustomizer(); + } + + /** + * Optional setup for subclasses. Invoked before customizer is initialized. + */ + protected void setUp() throws Exception { + } + + protected abstract ReaderCustomizer<D, B> initCustomizer(); + + protected ReaderCustomizer<D, B> getCustomizer() { + return customizer; + } + + @Test + public void testGetBuilder() throws Exception { + assertNotNull(customizer.getBuilder(InstanceIdentifier.create(dataObjectClass))); + } + + @Test + public void testMerge() throws Exception { + final Builder<? extends DataObject> parentBuilder = mock(parentBuilderClass); + final D value = mock(dataObjectClass); + getCustomizer().merge(parentBuilder, value); + + final Method method = parentBuilderClass.getMethod("set" + dataObjectClass.getSimpleName(), dataObjectClass); + method.invoke(verify(parentBuilder), value); + } +} diff --git a/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/util/FutureProducer.java b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/util/FutureProducer.java new file mode 100644 index 000000000..2bedb9507 --- /dev/null +++ b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/util/FutureProducer.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * 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 io.fd.hc2vpp.common.test.util; + +import java.util.concurrent.CompletableFuture; +import javax.annotation.Nonnull; +import io.fd.vpp.jvpp.VppCallbackException; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; + +/** + * <p>VPP translation test helper, that produces instances of {@link CompletableFuture} with desired results.</p> + * <p>Useful when stubbing {@link FutureJVppCore} methods: <br>{@code when(api.showVersion(any())).thenReturn(future(new + * ShowVersionReply()));}</p> + */ +public interface FutureProducer { + + /** + * Returns {@link CompletableFuture} with desired result. + * + * @param result returned when {@link CompletableFuture#get()} is invoked + * @param <T> the result type of returned future + */ + default <T> CompletableFuture<T> future(@Nonnull final T result) { + final CompletableFuture<T> future = new CompletableFuture<>(); + future.complete(result); + return future; + } + + /** + * Returns {@link CompletableFuture} with provided {@link Exception} as a result. + * + * @param exception to be thrown when {@link CompletableFuture#get()} is invoked + * @param <T> the result type of returned future + */ + default <T> CompletableFuture<T> failedFuture(@Nonnull final Exception exception) { + final CompletableFuture<T> future = new CompletableFuture<>(); + future.completeExceptionally(exception); + return future; + } + + /** + * Returns {@link CompletableFuture} with VppCallbackException(retval = -1) as a cause. + * + * @param <T> the result type of returned future + */ + default <T> CompletableFuture<T> failedFuture() { + return failedFuture(new VppCallbackException("test-call", 1 /* ctxId */, -1 /* retval */)); + } +} diff --git a/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/util/InterfaceDumpHelper.java b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/util/InterfaceDumpHelper.java new file mode 100644 index 000000000..81d29c8f4 --- /dev/null +++ b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/util/InterfaceDumpHelper.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * 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 io.fd.hc2vpp.common.test.util; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.when; + +import java.util.Collections; +import javax.annotation.Nonnull; +import io.fd.vpp.jvpp.core.dto.SwInterfaceDetails; +import io.fd.vpp.jvpp.core.dto.SwInterfaceDetailsReplyDump; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; + +/** + * VPP translation test helper, that helps stubbing {@link FutureJVppCore#swInterfaceDump}. + */ +public interface InterfaceDumpHelper extends FutureProducer { + + /** + * Stubs swInterfaceDump to return given list of interfaces. + * + * @param api vppApi reference + * @param interfaces list of interface details to be returned + */ + default void whenSwInterfaceDumpThenReturn(@Nonnull final FutureJVppCore api, + final SwInterfaceDetails... interfaces) { + final SwInterfaceDetailsReplyDump reply = new SwInterfaceDetailsReplyDump(); + Collections.addAll(reply.swInterfaceDetails, interfaces); + when(api.swInterfaceDump(any())).thenReturn(future(reply)); + } +} diff --git a/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/util/NamingContextHelper.java b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/util/NamingContextHelper.java new file mode 100644 index 000000000..719339cbf --- /dev/null +++ b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/util/NamingContextHelper.java @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * 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 io.fd.hc2vpp.common.test.util; + +import static org.mockito.Mockito.doReturn; + +import com.google.common.base.Optional; +import com.google.common.collect.Lists; +import io.fd.honeycomb.translate.MappingContext; +import java.util.List; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.Contexts; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.NamingContext; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.NamingContextKey; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.Mappings; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.MappingsBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.mappings.Mapping; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.mappings.MappingBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.mappings.MappingKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; + +/** + * Utility that helps stubbing {@link io.fd.hc2vpp.common.translate.util.NamingContext} methods. + */ +// TODO(HONEYCOMB-226): the class needs to be refactored or even removed after extracting interface from NamingContext +public interface NamingContextHelper { + + /** + * Creates {@link Mapping} for given data. + * + * @param name to be mapped + * @param index to be mapped + * @return name to index mapping + */ + default Optional<Mapping> mapping(@Nonnull final String name, final int index) { + return Optional.of(new MappingBuilder().setName(name).setIndex(index).build()); + } + + /** + * Creates {@link KeyedInstanceIdentifier} for {@link Mapping} in {@link NamingContext}. + * + * @param name name of the mapping + * @param namingContextName name of the naming context + * @return identifier for the mapping + */ + default KeyedInstanceIdentifier<Mapping, MappingKey> mappingIid(@Nonnull final String name, + @Nonnull final String namingContextName) { + return InstanceIdentifier.create(Contexts.class).child(NamingContext.class, + new NamingContextKey(namingContextName)).child(Mappings.class).child(Mapping.class, new MappingKey(name)); + } + + /** + * Stubs {@link MappingContext#read} to include given mapping in {@link NamingContext}. + * + * @param mappingContext mock instance of {@link MappingContext} + * @param name name of the mapping + * @param index index to be mapped + * @param namingContextName name of the naming context + */ + default void defineMapping(@Nonnull final MappingContext mappingContext, @Nonnull final String name, + final int index, @Nonnull final String namingContextName) { + final KeyedInstanceIdentifier<Mapping, MappingKey> mappingIid = mappingIid(name, namingContextName); + final InstanceIdentifier<Mappings> mappingsIid = mappingIid.firstIdentifierOf(Mappings.class); + + final Optional<Mapping> singleMapping = mapping(name, index); + final List<Mapping> list = Common.getMappingList(mappingContext, mappingsIid); + list.add(singleMapping.get()); + + doReturn(Optional.of(new MappingsBuilder().setMapping(list).build())).when(mappingContext).read(mappingsIid); + doReturn(singleMapping).when(mappingContext).read(mappingIid); + } + + /** + * Stubs {@link MappingContext#read} for given {@link NamingContext} to return {@link Optional#absent} for provided + * name. + * + * @param mappingContext mock instance of {@link MappingContext} + * @param name name of the mapping + * @param namingContextName name of the naming context + */ + default void noMappingDefined(@Nonnull final MappingContext mappingContext, @Nonnull final String name, + @Nonnull final String namingContextName) { + final InstanceIdentifier<Mappings> iid = mappingIid(name, namingContextName).firstIdentifierOf(Mappings.class); + final List<Mapping> list = Common.getMappingList(mappingContext, iid); + + doReturn(Optional.of(new MappingsBuilder().setMapping(list).build())).when(mappingContext).read(iid); + doReturn(Optional.absent()).when(mappingContext).read(mappingIid(name, namingContextName)); + } + + final class Common { + private static List<Mapping> getMappingList(@Nonnull final MappingContext mappingContext, + @Nonnull final InstanceIdentifier<Mappings> mappingsIid) { + final Optional<Mappings> previousMappings = mappingContext.read(mappingsIid); + final MappingsBuilder mappingsBuilder; + if (previousMappings != null && previousMappings.isPresent()) { + mappingsBuilder = new MappingsBuilder(previousMappings.get()); + } else { + mappingsBuilder = new MappingsBuilder(); + mappingsBuilder.setMapping(Lists.newArrayList()); + } + return mappingsBuilder.getMapping(); + } + } +} diff --git a/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/write/WriterCustomizerTest.java b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/write/WriterCustomizerTest.java new file mode 100644 index 000000000..7067a0c39 --- /dev/null +++ b/vpp-common/vpp-translate-test/src/main/java/io/fd/hc2vpp/common/test/write/WriterCustomizerTest.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * 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 io.fd.hc2vpp.common.test.write; + +import io.fd.honeycomb.translate.MappingContext; +import io.fd.honeycomb.translate.ModificationCache; +import io.fd.honeycomb.translate.spi.write.WriterCustomizer; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.hc2vpp.common.test.util.FutureProducer; +import io.fd.hc2vpp.common.test.util.NamingContextHelper; +import org.junit.Before; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; + +/** + * Generic test for classes implementing {@link WriterCustomizer} interface. + */ +public abstract class WriterCustomizerTest implements FutureProducer, + NamingContextHelper { + + @Mock + protected FutureJVppCore api; + @Mock + protected WriteContext writeContext; + @Mock + protected MappingContext mappingContext; + + protected ModificationCache cache; + + protected WriterCustomizerTest() { + } + + @Before + public final void setUpParent() throws Exception { + MockitoAnnotations.initMocks(this); + cache = new ModificationCache(); + Mockito.doReturn(cache).when(writeContext).getModificationCache(); + Mockito.doReturn(mappingContext).when(writeContext).getMappingContext(); + setUp(); + } + + /** + * Optional setup for subclasses. Invoked after parent initialization. + */ + protected void setUp() throws Exception { + } +} |