method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
RestoringInitializer implements DataTreeInitializer { @Override public void initialize() throws InitializeException { LOG.debug("Starting restoration of {} from {} using {}", dataTree, path, restorationType); if (!Files.exists(path)) { LOG.debug("Persist file {} does not exist. Skipping restoration", path); return; } try { final ContainerNode containerNode = jsonReader.readData(schemaService.getGlobalContext(), path); final DOMDataTreeWriteTransaction domDataWriteTransaction = dataTree.newWriteOnlyTransaction(); for (DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild : containerNode .getValue()) { final YangInstanceIdentifier iid = YangInstanceIdentifier.create(dataContainerChild.getIdentifier()); LOG.trace("Restoring {} from {}", iid, path); switch (restorationType) { case Merge: domDataWriteTransaction.merge(datastoreType, iid, dataContainerChild); break; case Put: domDataWriteTransaction.put(datastoreType, iid, dataContainerChild); break; default: throw new InitializeException( "Unable to initialize data using " + restorationType + " restoration strategy. Unsupported"); } } domDataWriteTransaction.commit().get(); LOG.debug("Data from {} restored successfully", path); } catch (IOException | InterruptedException | ExecutionException ex) { throw new InitializeException("Unable to restore data from " + path, ex); } } RestoringInitializer(@Nonnull final DOMSchemaService schemaService,
@Nonnull final Path path,
@Nonnull final DOMDataBroker dataTree,
@Nonnull final RestorationType restorationType,
@Nonnull final LogicalDatastoreType datastoreType,
@Nonnull final JsonReader jsonReader); RestoringInitializer(@Nonnull final DOMSchemaService schemaService,
@Nonnull final Path path,
@Nonnull final DOMDataBroker dataTree,
@Nonnull final RestorationType restorationType,
@Nonnull final LogicalDatastoreType datastoreType); @Override void initialize(); }### Answer:
@Test public void testMergeConfig() throws Exception { final RestoringInitializer init = new RestoringInitializer(schemaService, path, dataTree, RestoringInitializer.RestorationType.Merge, LogicalDatastoreType.CONFIGURATION, jsonReader); init.initialize(); verify(writeTx).merge(LogicalDatastoreType.CONFIGURATION, YangInstanceIdentifier.create(nodeId), data); }
@Test public void testNoRestore() throws Exception { Files.delete(path); final RestoringInitializer init = new RestoringInitializer(schemaService, path, dataTree, RestoringInitializer.RestorationType.Merge, LogicalDatastoreType.CONFIGURATION, jsonReader); init.initialize(); verifyZeroInteractions(writeTx); }
@Test(expected = DataTreeInitializer.InitializeException.class) public void testFail() throws Exception { when(jsonReader.readData(schemaContext, path)).thenThrow(new IOException("t")); final RestoringInitializer init = new RestoringInitializer(schemaService, path, dataTree, RestoringInitializer.RestorationType.Merge, LogicalDatastoreType.CONFIGURATION, jsonReader); init.initialize(); }
@Test public void testPutOper() throws Exception { final RestoringInitializer init = new RestoringInitializer(schemaService, path, dataTree, RestoringInitializer.RestorationType.Put, LogicalDatastoreType.OPERATIONAL, jsonReader); init.initialize(); verify(schemaService).getGlobalContext(); verify(jsonReader).readData(schemaContext, path); verify(dataTree).newWriteOnlyTransaction(); verify(writeTx).put(LogicalDatastoreType.OPERATIONAL, YangInstanceIdentifier.create(nodeId), data); verify(writeTx).commit(); } |
### Question:
ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { delegateWriteTx.merge(store, path, data); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx,
@Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }### Answer:
@Test public void testMerge() { readWriteTx.merge(store, path, data); verify(writeTx).merge(store, path, data); } |
### Question:
ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) { delegateWriteTx.delete(store, path); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx,
@Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }### Answer:
@Test public void testDelete() { readWriteTx.delete(store, path); verify(writeTx).delete(store, path); } |
### Question:
ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<? extends CommitInfo> commit() { return delegateWriteTx.commit(); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx,
@Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }### Answer:
@Test public void testCommit() { readWriteTx.commit(); verify(writeTx).commit(); } |
### Question:
ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.read(store, path); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx,
@Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }### Answer:
@Test public void testRead() { readWriteTx.read(store, path); verify(readTx).read(store, path); } |
### Question:
ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { return delegateReadTx.exists(store, path); } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx,
@Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }### Answer:
@Test public void testExists() { readWriteTx.exists(store, path); verify(readTx).exists(store, path); } |
### Question:
ReadWriteTransaction implements DOMDataTreeReadWriteTransaction, ValidableTransaction { @Override public Object getIdentifier() { return this; } ReadWriteTransaction(@Nonnull final DOMDataTreeReadTransaction delegateReadTx,
@Nonnull final ValidableTransaction delegateWriteTx); @Override boolean cancel(); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path); @Override FluentFuture<? extends CommitInfo> commit(); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }### Answer:
@Test public void testGetIdentifier() { assertNotNull(readWriteTx.getIdentifier()); } |
### Question:
ReadOnlyTransaction implements DOMDataTreeReadTransaction { @Override public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final YangInstanceIdentifier path) { LOG.debug("ReadOnlyTransaction.exists() store={}, path={}", store, path); ListenableFuture<Boolean> listenableFuture = Futures.transform(read(store, path), IS_NODE_PRESENT, MoreExecutors.directExecutor()); return FluentFuture.from(listenableFuture); } private ReadOnlyTransaction(@Nullable final DataModification configData,
@Nullable final ReadableDataManager operationalData); @Override synchronized void close(); @Override synchronized FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Nonnull @Override Object getIdentifier(); }### Answer:
@Test public void testExists() { final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); final FluentFuture<Optional<NormalizedNode<?, ?>>> future = mock(FluentFuture.class); when(operationalData.read(path)).thenReturn(future); readOnlyTx.exists(LogicalDatastoreType.OPERATIONAL, path); verify(operationalData).read(path); } |
### Question:
ReadOnlyTransaction implements DOMDataTreeReadTransaction { @Nonnull @Override public Object getIdentifier() { return this; } private ReadOnlyTransaction(@Nullable final DataModification configData,
@Nullable final ReadableDataManager operationalData); @Override synchronized void close(); @Override synchronized FluentFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Override FluentFuture<Boolean> exists(final LogicalDatastoreType store,
final YangInstanceIdentifier path); @Nonnull @Override Object getIdentifier(); }### Answer:
@Test public void testGetIdentifier() { assertNotNull(readOnlyTx.getIdentifier()); } |
### Question:
ModifiableDataTreeDelegator extends ModifiableDataTreeManager { @Override public DataModification newModification() { return new DelegatingConfigSnapshot(super.newModification()); } ModifiableDataTreeDelegator(@Nonnull final BindingNormalizedNodeSerializer serializer,
@Nonnull final DataTree dataTree,
@Nonnull final SchemaContext schema,
@Nonnull final WriterRegistry writerRegistry,
@Nonnull final DataBroker contextBroker); @Override DataModification newModification(); }### Answer:
@Test public void testRead() throws Exception { final ContainerNode topContainer = getTopContainer("topContainer"); addNodeToTree(dataTree, topContainer, TOP_CONTAINER_ID); final FluentFuture<Optional<NormalizedNode<?, ?>>> read = configDataTree.read(TOP_CONTAINER_ID); final FluentFuture<Optional<NormalizedNode<?, ?>>> read2 = configDataTree.newModification().read(TOP_CONTAINER_ID); final Optional<NormalizedNode<?, ?>> normalizedNodeOptional = read.get(); final Optional<NormalizedNode<?, ?>> normalizedNodeOptional2 = read2.get(); assertEquals(normalizedNodeOptional, normalizedNodeOptional2); assertTrue(normalizedNodeOptional.isPresent()); assertEquals(topContainer, normalizedNodeOptional.get()); assertEquals(dataTree.takeSnapshot().readNode(TOP_CONTAINER_ID), normalizedNodeOptional); }
@Test public void testValidateTwice() throws Exception { final MapNode nestedList = getNestedList("listEntry", "listValue"); final DataModification dataModification = configDataTree.newModification(); dataModification.write(NESTED_LIST_ID, nestedList); dataModification.validate(); dataModification.validate(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> map = HashMultimap.create(); map.put(DEFAULT_ID, DataObjectUpdate.create(DEFAULT_ID, null, DEFAULT_DATA_OBJECT)); final WriterRegistry.DataObjectUpdates updates = new WriterRegistry.DataObjectUpdates(map, ImmutableMultimap.of()); verify(writer, times(2)).validateModifications(eq(updates), any(WriteContext.class)); }
@Test public void testCommitSuccessful() throws Exception { final MapNode nestedList = getNestedList("listEntry", "listValue"); final DataModification dataModification = configDataTree.newModification(); dataModification.write(NESTED_LIST_ID, nestedList); dataModification.validate(); dataModification.commit(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> map = HashMultimap.create(); map.put(DEFAULT_ID, DataObjectUpdate.create(DEFAULT_ID, null, DEFAULT_DATA_OBJECT)); verify(writer).processModifications(eq(new WriterRegistry.DataObjectUpdates(map, ImmutableMultimap.of())), any(WriteContext.class)); assertEquals(nestedList, dataTree.takeSnapshot().readNode(NESTED_LIST_ID).get()); } |
### Question:
WriteTransaction implements ValidableTransaction { @Override public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.put() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.write(path, data)); } private WriteTransaction(@Nullable final DataModification configModification,
@Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }### Answer:
@Test public void testPut() { writeTx.put(LogicalDatastoreType.CONFIGURATION, path, data); verify(configSnapshot).write(path, data); }
@Test(expected = IllegalArgumentException.class) public void testPutOperational() { writeTx.put(LogicalDatastoreType.OPERATIONAL, path, data); verify(configSnapshot).write(path, data); } |
### Question:
WriteTransaction implements ValidableTransaction { @Override public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) { LOG.debug("WriteTransaction.merge() store={}, path={}, data={}", store, path, data); checkIsNew(); handleOperation(store, (modification) -> modification.merge(path, data)); } private WriteTransaction(@Nullable final DataModification configModification,
@Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }### Answer:
@Test public void testMerge() { writeTx.merge(LogicalDatastoreType.CONFIGURATION, path, data); verify(configSnapshot).merge(path, data); } |
### Question:
WriteTransaction implements ValidableTransaction { @Override public boolean cancel() { if (status != TransactionStatus.NEW) { return false; } else { if (configModification != null) { configModification.close(); } status = TransactionStatus.CANCELED; return true; } } private WriteTransaction(@Nullable final DataModification configModification,
@Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }### Answer:
@Test public void testCancel() { assertTrue(writeTx.cancel()); } |
### Question:
WriteTransaction implements ValidableTransaction { @Override public void delete(LogicalDatastoreType store, final YangInstanceIdentifier path) { LOG.debug("WriteTransaction.delete() store={}, path={}", store, path); checkIsNew(); handleOperation(store, (modification) -> modification.delete(path)); } private WriteTransaction(@Nullable final DataModification configModification,
@Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }### Answer:
@Test public void testDelete() { writeTx.delete(LogicalDatastoreType.CONFIGURATION, path); verify(configSnapshot).delete(path); } |
### Question:
WriteTransaction implements ValidableTransaction { @Override public @NonNull FluentFuture<? extends CommitInfo> commit() { LOG.trace("WriteTransaction.commit()"); checkIsNew(); try { doCommit(); } catch (Exception e) { status = TransactionStatus.FAILED; LOG.error("Submit failed", e); return FluentFuture .from(Futures.immediateFailedFuture( new TransactionCommitFailedException("Failed to validate DataTreeModification", e))); } return FluentFuture.from(Futures.immediateFuture(null)); } private WriteTransaction(@Nullable final DataModification configModification,
@Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }### Answer:
@Test public void testSubmit() throws Exception { writeTx.commit(); verify(configSnapshot).commit(); }
@Test public void testSubmitFailed() throws Exception { doThrow(mock(ValidationFailedException.class)).when(configSnapshot).commit(); final FluentFuture<? extends CommitInfo> future = writeTx.commit(); try { future.get(); } catch (Exception e) { assertTrue(e.getCause() instanceof TransactionCommitFailedException); return; } fail("Expected exception to be thrown"); }
@Test public void testCommit() throws TranslationException { writeTx.commit(); verify(configSnapshot).commit(); } |
### Question:
WriteTransaction implements ValidableTransaction { @Override public Object getIdentifier() { return this; } private WriteTransaction(@Nullable final DataModification configModification,
@Nullable final DataModification operationalModification); @Override void put(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data); @Override boolean cancel(); @Override void delete(LogicalDatastoreType store, final YangInstanceIdentifier path); @Override @NonNull FluentFuture<? extends CommitInfo> commit(); @Override Object getIdentifier(); @Override FluentFuture<Void> validate(); }### Answer:
@Test public void testGetIdentifier() { assertNotNull(writeTx.getIdentifier()); } |
### Question:
DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeReadWriteTransaction newReadWriteTransaction() { LOG.trace("DataBroker({}).newReadWriteTransaction()", this); return transactionFactory.newReadWriteTransaction(); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree,
@Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }### Answer:
@Test public void testNewReadWriteTransaction() { final DOMDataTreeReadWriteTransaction readWriteTx = broker.newReadWriteTransaction(); final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); readWriteTx.read(LogicalDatastoreType.CONFIGURATION, path); verify(configSnapshot).read(path); verify(confiDataTree).newModification(); } |
### Question:
DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeWriteTransaction newWriteOnlyTransaction() { LOG.trace("DataBroker({}).newWriteTransaction()", this); return transactionFactory.newWriteTransaction(); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree,
@Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }### Answer:
@Test public void testNewWriteOnlyTransaction() { broker.newWriteOnlyTransaction(); verify(confiDataTree).newModification(); } |
### Question:
DataBroker implements DOMDataBroker, Closeable { @Override public DOMDataTreeReadTransaction newReadOnlyTransaction() { LOG.trace("DataBroker({}).newReadTransaction()", this); return transactionFactory.newReadTransaction(); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree,
@Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }### Answer:
@Test public void testNewReadOnlyTransaction() { final DOMDataTreeReadTransaction readTx = broker.newReadOnlyTransaction(); final YangInstanceIdentifier path = mock(YangInstanceIdentifier.class); readTx.read(LogicalDatastoreType.CONFIGURATION, path); verify(configSnapshot).read(path); } |
### Question:
DataBroker implements DOMDataBroker, Closeable { @Override public DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener) { throw new UnsupportedOperationException("Not supported"); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree,
@Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testCreateTransactionChain() { final DOMTransactionChainListener listener = mock(DOMTransactionChainListener.class); broker.createTransactionChain(listener); } |
### Question:
DataBroker implements DOMDataBroker, Closeable { @Override public @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions() { return ImmutableClassToInstanceMap.of(DOMDataTransactionValidator.class, tx -> ((ValidableTransaction) tx).validate()); } DataBroker(final TransactionFactory transactionFactory); @Override DOMDataTreeReadTransaction newReadOnlyTransaction(); @Override DOMDataTreeReadWriteTransaction newReadWriteTransaction(); @Override DOMDataTreeWriteTransaction newWriteOnlyTransaction(); @Override DOMTransactionChain createTransactionChain(final DOMTransactionChainListener listener); @Override @NonNull ClassToInstanceMap<DOMDataBrokerExtension> getExtensions(); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager configDataTree,
@Nonnull final ReadableDataManager operationalDataTree); @Nonnull static DataBroker create(@Nonnull final ModifiableDataManager operationalDataTree); @Override void close(); }### Answer:
@Test public void testGetSupportedExtensions() { final @NonNull ClassToInstanceMap<DOMDataBrokerExtension> supportedExtensions = broker.getExtensions(); assertEquals(1, supportedExtensions.size()); assertNotNull(supportedExtensions.get(DOMDataTransactionValidator.class)); } |
### Question:
FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @VisibleForTesting @Override protected ImmutableMap<InstanceIdentifier<?>, Writer<? extends DataObject>> getMappedHandlers() { return super.getMappedHandlers(); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override WriterRegistry build(); }### Answer:
@Test public void testRelationsBefore() throws Exception { final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder(new YangDAG()); flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject3.class)); flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject4.class)); flatWriterRegistryBuilder.addBefore(mockWriter(DataObjects.DataObject2.class), Lists.newArrayList(DataObjects.DataObject3.IID, DataObjects.DataObject4.IID)); flatWriterRegistryBuilder.addBefore(mockWriter(DataObjects.DataObject1.class), DataObjects.DataObject2.IID); final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = flatWriterRegistryBuilder.getMappedHandlers(); final ArrayList<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet()); assertEquals(DataObjects.DataObject1.IID, typesInList.get(0)); assertEquals(DataObjects.DataObject2.IID, typesInList.get(1)); assertThat(typesInList.get(2), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID))); assertThat(typesInList.get(3), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID))); }
@Test public void testRelationsAfter() throws Exception { final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder(new YangDAG()); flatWriterRegistryBuilder.add(mockWriter(DataObjects.DataObject1.class)); flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject2.class), DataObjects.DataObject1.IID); flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject3.class), DataObjects.DataObject2.IID); flatWriterRegistryBuilder.addAfter(mockWriter(DataObjects.DataObject4.class), Lists.newArrayList(DataObjects.DataObject2.IID, DataObjects.DataObject3.IID)); final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = flatWriterRegistryBuilder.getMappedHandlers(); final List<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet()); assertEquals(DataObjects.DataObject1.IID, typesInList.get(0)); assertEquals(DataObjects.DataObject2.IID, typesInList.get(1)); assertThat(typesInList.get(2), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID))); assertThat(typesInList.get(3), anyOf(equalTo(DataObjects.DataObject3.IID), equalTo(DataObjects.DataObject4.IID))); }
@Test public void testAddSubtreeWriter() throws Exception { final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder(new YangDAG()); flatWriterRegistryBuilder.subtreeAdd( Sets.newHashSet(DataObjects.DataObject4.DataObject41.IID, DataObjects.DataObject4.DataObject41.IID), mockWriter(DataObjects.DataObject4.class)); final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = flatWriterRegistryBuilder.getMappedHandlers(); final ArrayList<InstanceIdentifier<?>> typesInList = Lists.newArrayList(mappedWriters.keySet()); assertEquals(DataObjects.DataObject4.IID, typesInList.get(0)); assertEquals(1, typesInList.size()); } |
### Question:
ReadableDataTreeDelegator implements ReadableDataManager { private Optional<NormalizedNode<?, ?>> readNode(final YangInstanceIdentifier yangInstanceIdentifier, final ReadContext ctx) throws ReadFailedException { LOG.debug("OperationalDataTree.readNode(), yangInstanceIdentifier={}", yangInstanceIdentifier); final InstanceIdentifier<?> path = serializer.fromYangInstanceIdentifier(yangInstanceIdentifier); checkNotNull(path, "Invalid instance identifier %s. Cannot create BA equivalent.", yangInstanceIdentifier); LOG.debug("OperationalDataTree.readNode(), path={}", path); final Optional<? extends DataObject> dataObject = readerRegistry.read(path, ctx); ctx.getModificationCache().close(); if (dataObject.isPresent()) { final NormalizedNode<?, ?> value = toNormalizedNodeFunction(path).apply(dataObject.get()); return Optional.ofNullable(value); } else { return Optional.empty(); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer,
@Nonnull final SchemaContext globalContext,
@Nonnull final ReaderRegistry readerRegistry,
@Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(
@Nonnull final YangInstanceIdentifier yangInstanceIdentifier); }### Answer:
@Test public void testReadNode() throws Exception { final YangInstanceIdentifier yangId = mock(YangInstanceIdentifier.class); final YangInstanceIdentifier.PathArgument pArg = mock(YangInstanceIdentifier.PathArgument.class); doReturn(pArg).when(yangId).getLastPathArgument(); doReturn(Collections.singletonList(pArg)).when(yangId).getPathArguments(); doReturn(QName.create("namespace", "2012-12-12", "local")).when(pArg).getNodeType(); doReturn(id).when(serializer).fromYangInstanceIdentifier(yangId); final DataObject dataObject = mock(DataObject.class); doReturn(Optional.of(dataObject)).when(reader).read(same(id), any(ReadContext.class)); when(serializer.toNormalizedNode(id, dataObject)).thenReturn(entry); final DataContainerChild<?, ?> expectedValue = mock(DataContainerChild.class); doReturn(expectedValue).when(entry).getValue(); final FluentFuture<Optional<NormalizedNode<?, ?>>> future = operationalData.read(yangId); verify(serializer).fromYangInstanceIdentifier(yangId); verify(reader).read(same(id), any(ReadContext.class)); final Optional<NormalizedNode<?, ?>> result = future.get(); assertTrue(result.isPresent()); assertEquals(expectedValue, result.get()); } |
### Question:
ReadableDataTreeDelegator implements ReadableDataManager { @VisibleForTesting static DataContainerChild<?, ?> wrapListIntoMixinNode( final Collection<NormalizedNode<?, ?>> normalizedRootElements, final ListSchemaNode listSchema) { if (listSchema.getKeyDefinition().isEmpty()) { final CollectionNodeBuilder<UnkeyedListEntryNode, UnkeyedListNode> listBuilder = Builders.unkeyedListBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((UnkeyedListEntryNode) normalizedRootElement); } return listBuilder.build(); } else { final CollectionNodeBuilder<MapEntryNode, ? extends MapNode> listBuilder = listSchema.isUserOrdered() ? Builders.orderedMapBuilder() : Builders.mapBuilder(); listBuilder.withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(listSchema.getQName())); for (NormalizedNode<?, ?> normalizedRootElement : normalizedRootElements) { listBuilder.withChild((MapEntryNode) normalizedRootElement); } return listBuilder.build(); } } ReadableDataTreeDelegator(@Nonnull BindingNormalizedNodeSerializer serializer,
@Nonnull final SchemaContext globalContext,
@Nonnull final ReaderRegistry readerRegistry,
@Nonnull final org.opendaylight.mdsal.binding.api.DataBroker contextBroker); @Override FluentFuture<Optional<NormalizedNode<?, ?>>> read(
@Nonnull final YangInstanceIdentifier yangInstanceIdentifier); }### Answer:
@Test public void testWrapMixin() throws Exception { final QName nodeQName = QName.create("namespace", "node"); final QName keyQName = QName.create("namespace", "key"); final List<NormalizedNode<?, ?>> mapNodes = Lists.newArrayList("one", "two", "three").stream() .map(value -> ImmutableNodes.mapEntry(nodeQName, keyQName, value)) .collect(Collectors.toList()); final ListSchemaNode listSchema = mock(ListSchemaNode.class); doReturn(Collections.singletonList(keyQName)).when(listSchema).getKeyDefinition(); doReturn(true).when(listSchema).isUserOrdered(); doReturn(nodeQName).when(listSchema).getQName(); final DataContainerChild<?, ?> dataContainerChild = ReadableDataTreeDelegator.wrapListIntoMixinNode(mapNodes, listSchema); assertArrayEquals(mapNodes.toArray(), ((UnmodifiableCollection) dataContainerChild.getValue()).toArray()); } |
### Question:
FlatWriterRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Writer<? extends DataObject>, WriterRegistry> implements ModifiableWriterRegistryBuilder, WriterRegistryBuilder { @Override public WriterRegistry build() { final ImmutableMap<InstanceIdentifier<?>, Writer<?>> mappedWriters = getMappedHandlers(); LOG.debug("Building writer registry with writers: {}", mappedWriters.keySet().stream() .map(InstanceIdentifier::getTargetType) .map(Class::getSimpleName) .collect(Collectors.joining(", "))); LOG.trace("Building writer registry with writers: {}", mappedWriters); return new FlatWriterRegistry(mappedWriters); } FlatWriterRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override WriterRegistry build(); }### Answer:
@Test public void testBuild() throws Exception { final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder(new YangDAG()); final Writer<? extends DataObject> writer = mockWriter(DataObjects.DataObject3.class); flatWriterRegistryBuilder.add(writer); final WriterRegistry build = flatWriterRegistryBuilder.build(); final InstanceIdentifier<DataObjects.DataObject3> id = InstanceIdentifier.create(DataObjects.DataObject3.class); final DataObjectUpdate update = mock(DataObjectUpdate.class); doReturn(id).when(update).getId(); final DataObjects.DataObject3 before = mock(DataObjects.DataObject3.class); final DataObjects.DataObject3 after = mock(DataObjects.DataObject3.class); when(update.getDataBefore()).thenReturn(before); when(update.getDataAfter()).thenReturn(after); WriterRegistry.DataObjectUpdates updates = new WriterRegistry.DataObjectUpdates( Multimaps.forMap(Collections.singletonMap(id, update)), Multimaps.forMap(Collections.emptyMap())); final WriteContext ctx = mock(WriteContext.class); build.processModifications(updates, ctx); verify(writer).processModification(id, before, after, ctx); }
@Test(expected = IllegalArgumentException.class) public void testBuildUnknownWriter() throws Exception { final FlatWriterRegistryBuilder flatWriterRegistryBuilder = new FlatWriterRegistryBuilder(new YangDAG()); final Writer<? extends DataObject> writer = mockWriter(DataObjects.DataObject3.class); flatWriterRegistryBuilder.add(writer); final WriterRegistry build = flatWriterRegistryBuilder.build(); final InstanceIdentifier<DataObjects.DataObject1> id2 = InstanceIdentifier.create(DataObjects.DataObject1.class); final DataObjectUpdate update2 = mock(DataObjectUpdate.class); final WriterRegistry.DataObjectUpdates updates = new WriterRegistry.DataObjectUpdates( Multimaps.forMap(Collections.singletonMap(id2, update2)), Multimaps.forMap(Collections.emptyMap())); build.processModifications(updates, mock(WriteContext.class)); } |
### Question:
YangModuleWhitelistReader extends JAXBContextHolder { @Nonnull public YangModuleWhitelist read(@Nonnull final Path path) { final Unmarshaller unmarshaller = createUnmarshaller(); return YangModuleWhitelist.class.cast(readWhitelist(path, unmarshaller)); } YangModuleWhitelistReader(); @Nonnull YangModuleWhitelist read(@Nonnull final Path path); }### Answer:
@Test public void read() throws Exception { final YangModuleWhitelist whitelist = reader.read( Paths.get(this.getClass().getClassLoader().getResource("expected-whitelist.xml").getPath())); assertNotNull(whitelist); final List<Module> modules = whitelist.getModules(); assertEquals(2, modules.size()); final Module moduleA = new Module(); final Module moduleB = new Module(); moduleA.setPckg("module.a.package"); moduleA.setDescription("desc"); moduleB.setPckg("module.b.package"); assertTrue(modules.containsAll(ImmutableSet.of(moduleA, moduleB))); } |
### Question:
YangModuleWhitelistWriter extends JAXBContextHolder { public void write(@Nonnull final YangModuleWhitelist whitelist, @Nonnull final Path outPath, final boolean formatOutput) { Objects.requireNonNull(whitelist, "Cannot white null whitelist"); final Marshaller marshaller = createMarshaller(getCtx()); setupPrettyPrint(marshaller, formatOutput); whiteWhitelist(whitelist, outPath, marshaller); } YangModuleWhitelistWriter(); void write(@Nonnull final YangModuleWhitelist whitelist,
@Nonnull final Path outPath,
final boolean formatOutput); }### Answer:
@Test public void write() throws Exception { final Module moduleA = new Module(); final Module moduleB = new Module(); moduleA.setPckg("module.a.package"); moduleA.setDescription("desc"); moduleB.setPckg("module.b.package"); final YangModuleWhitelist whitelist = new YangModuleWhitelist(); whitelist.setModules(ImmutableList.of(moduleA, moduleB)); writer.write(whitelist, path, false); final String output = Files.readAllLines(path).stream().collect(Collectors.joining()); final String expectedOutput = Resources .toString(this.getClass().getClassLoader().getResource("expected-whitelist.xml"), StandardCharsets.UTF_8); assertEquals(expectedOutput, output); } |
### Question:
SubtreeWriter implements Writer<D> { static Writer<?> createForWriter(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Writer<? extends DataObject> writer) { return new SubtreeWriter<>(writer, handledChildren); } private SubtreeWriter(final Writer<D> delegate, final Set<InstanceIdentifier<?>> handledTypes); private SubtreeWriter(final Writer<D> delegate); @Override void validate(@Nonnull final InstanceIdentifier<? extends DataObject> id,
@Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter,
@Nonnull final WriteContext ctx); @Override void processModification(
@Nonnull final InstanceIdentifier<? extends DataObject> id,
@Nullable final DataObject dataBefore,
@Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override boolean supportsDirectUpdate(); @Override boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier); @Override @Nonnull InstanceIdentifier<D> getManagedDataObjectType(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testSubtreeWriterCreationFail() throws Exception { SubtreeWriter.createForWriter(Collections.singleton(InstanceIdentifier.create(DataObject.class)), writer); }
@Test(expected = IllegalArgumentException.class) public void testSubtreeWriterCreationFailInvalidIid() throws Exception { SubtreeWriter.createForWriter(Collections.singleton(DataObjects.DataObject4.IID), writer); } |
### Question:
SubtreeWriter implements Writer<D> { @Override public boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier) { if (isWildcarded) { final Class<D> parent = delegate.getManagedDataObjectType().getTargetType(); for (InstanceIdentifier.PathArgument pathArgument : instanceIdentifier.getPathArguments()) { if (pathArgument.getType().equals(parent)) { return true; } } return false; } return handledChildTypes.parallelStream() .filter(childIiD -> instanceIdentifier.getTargetType().equals(childIiD.getTargetType())) .anyMatch(instanceIdentifier1 -> isPathEqual(instanceIdentifier, instanceIdentifier1)); } private SubtreeWriter(final Writer<D> delegate, final Set<InstanceIdentifier<?>> handledTypes); private SubtreeWriter(final Writer<D> delegate); @Override void validate(@Nonnull final InstanceIdentifier<? extends DataObject> id,
@Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter,
@Nonnull final WriteContext ctx); @Override void processModification(
@Nonnull final InstanceIdentifier<? extends DataObject> id,
@Nullable final DataObject dataBefore,
@Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx); @Override boolean supportsDirectUpdate(); @Override boolean canProcess(@Nonnull final InstanceIdentifier<? extends DataObject> instanceIdentifier); @Override @Nonnull InstanceIdentifier<D> getManagedDataObjectType(); }### Answer:
@Test public void testCanHandleChild() throws Exception { final SubtreeWriter<?> forWriter = createSubtreeWriter(); InstanceIdentifier<DataObjects.DataObject4.DataObject41.DataObject411> testIid = InstanceIdentifier.create( DataObjects.DataObject4.class).child(DataObjects.DataObject4.DataObject41.class).child( DataObjects.DataObject4.DataObject41.DataObject411.class); assertTrue(forWriter.canProcess(testIid)); } |
### Question:
FlatWriterRegistry implements WriterRegistry { @Override public void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx) throws DataValidationFailedException { validateModifications(updates.getDeletes(), ctx); validateModifications(updates.getUpdates(), ctx); } FlatWriterRegistry(@Nonnull final ImmutableMap<InstanceIdentifier<?>, Writer<?>> writersById); @Override void validateModifications(@Nonnull final DataObjectUpdates updates, @Nonnull final WriteContext ctx); @Override void processModifications(@Nonnull final DataObjectUpdates updates,
@Nonnull final WriteContext ctx); @Override boolean writerSupportsUpdate(@Nonnull final InstanceIdentifier<?> type); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testValidateMissingWriter() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); addUpdate(updates, DataObject1.class); addUpdate(updates, DataObject2.class); flatWriterRegistry.validateModifications(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx); }
@Test public void testValidateSingleWriter() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); final InstanceIdentifier<DataObject1> iid = InstanceIdentifier.create(DataObject1.class); final InstanceIdentifier<DataObject1> iid2 = InstanceIdentifier.create(DataObject1.class); final DataObject1 dataObject = mock(DataObject1.class); updates.put(DataObject1.IID, DataObjectUpdate.create(iid, dataObject, dataObject)); updates.put(DataObject1.IID, DataObjectUpdate.create(iid2, dataObject, dataObject)); flatWriterRegistry .validateModifications(new WriterRegistry.DataObjectUpdates(updates, ImmutableMultimap.of()), ctx); verify(writer1).validate(iid, dataObject, dataObject, ctx); verify(writer1).validate(iid2, dataObject, dataObject, ctx); verifyNoMoreInteractions(writer1); verifyZeroInteractions(writer2); }
@Test public void testValidateMultipleWriters() throws Exception { final FlatWriterRegistry flatWriterRegistry = new FlatWriterRegistry(ImmutableMap.of(DataObject1.IID, writer1, DataObject2.IID, writer2)); final Multimap<InstanceIdentifier<?>, DataObjectUpdate.DataObjectDelete> deletes = HashMultimap.create(); final Multimap<InstanceIdentifier<?>, DataObjectUpdate> updates = HashMultimap.create(); final InstanceIdentifier<DataObject1> iid = InstanceIdentifier.create(DataObject1.class); final DataObject1 dataObject = mock(DataObject1.class); deletes.put(DataObject1.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid, dataObject, null))); updates.put(DataObject1.IID, DataObjectUpdate.create(iid, null, dataObject)); final InstanceIdentifier<DataObject2> iid2 = InstanceIdentifier.create(DataObject2.class); final DataObject2 dataObject2 = mock(DataObject2.class); deletes.put(DataObject2.IID, ((DataObjectUpdate.DataObjectDelete) DataObjectUpdate.create(iid2, dataObject2, null))); updates.put(DataObject2.IID, DataObjectUpdate.create(iid2, dataObject2, dataObject2)); flatWriterRegistry.validateModifications(new WriterRegistry.DataObjectUpdates(updates, deletes), ctx); verify(writer1).validate(iid, dataObject, null, ctx); verify(writer1).validate(iid, null, dataObject, ctx); verify(writer2).validate(iid2, dataObject2, null, ctx); verify(writer2).validate(iid2, dataObject2, dataObject2, ctx); verifyNoMoreInteractions(writer1); verifyNoMoreInteractions(writer2); } |
### Question:
GenericListWriter extends
AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D data, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.writeCurrentAttributes(id, data, ctx); } catch (RuntimeException e) { throw new WriteFailedException.CreateFailedException(id, data, e); } } GenericListWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final ListWriterCustomizer<D, K> customizer); GenericListWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final ListWriterCustomizer<D, K> customizer,
@Nonnull final Validator<D> validator); }### Answer:
@Test(expected = WriteFailedException.CreateFailedException.class) public void testWriteFail() throws Exception { doThrow(new IllegalStateException("test")).when(customizer).writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); writer = new GenericListWriter<>(DATA_OBJECT_ID, customizer); writer.writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); } |
### Question:
GenericListWriter extends
AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final D dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.updateCurrentAttributes(id, dataBefore, dataAfter, ctx); } catch (RuntimeException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } } GenericListWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final ListWriterCustomizer<D, K> customizer); GenericListWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final ListWriterCustomizer<D, K> customizer,
@Nonnull final Validator<D> validator); }### Answer:
@Test(expected = WriteFailedException.UpdateFailedException.class) public void testUpdateFail() throws Exception { doThrow(new IllegalStateException("test")).when(customizer) .updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); writer = new GenericListWriter<>(DATA_OBJECT_ID, customizer); writer.updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); } |
### Question:
GenericListWriter extends
AbstractGenericWriter<D> implements ListWriter<D, K> { @Override protected void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.deleteCurrentAttributes(id, dataBefore, ctx); } catch (RuntimeException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } GenericListWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final ListWriterCustomizer<D, K> customizer); GenericListWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final ListWriterCustomizer<D, K> customizer,
@Nonnull final Validator<D> validator); }### Answer:
@Test(expected = WriteFailedException.DeleteFailedException.class) public void testDeleteFail() throws Exception { doThrow(new IllegalStateException("test")).when(customizer) .deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); writer = new GenericListWriter<>(DATA_OBJECT_ID, customizer); writer.deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); } |
### Question:
GenericWriter extends AbstractGenericWriter<D> { @Override protected void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D data, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.writeCurrentAttributes(id, data, ctx); } catch (RuntimeException e) { throw new WriteFailedException.CreateFailedException(id, data, e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final WriterCustomizer<D> customizer,
@Nonnull final Validator<D> validator); }### Answer:
@Test(expected = WriteFailedException.CreateFailedException.class) public void testWriteFail() throws Exception { doThrow(new IllegalStateException("test")).when(customizer).writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); writer = new GenericWriter<>(DATA_OBJECT_ID, customizer); writer.writeCurrentAttributes(DATA_OBJECT_ID, after, ctx); } |
### Question:
GenericWriter extends AbstractGenericWriter<D> { @Override protected void updateCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final D dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.updateCurrentAttributes(id, dataBefore, dataAfter, ctx); } catch (RuntimeException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final WriterCustomizer<D> customizer,
@Nonnull final Validator<D> validator); }### Answer:
@Test(expected = WriteFailedException.UpdateFailedException.class) public void testUpdateFail() throws Exception { doThrow(new IllegalStateException("test")).when(customizer) .updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); writer = new GenericWriter<>(DATA_OBJECT_ID, customizer); writer.updateCurrentAttributes(DATA_OBJECT_ID, before, after, ctx); } |
### Question:
WriteFailedException extends TranslationException { @Nonnull public InstanceIdentifier<?> getFailedId() { return failedId; } WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId,
@Nonnull final String message,
@Nonnull final Throwable cause); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId,
@Nonnull final String message); WriteFailedException(@Nonnull final InstanceIdentifier<?> failedId,
@Nonnull final Throwable cause); @Nonnull InstanceIdentifier<?> getFailedId(); }### Answer:
@Test public void testCreateFailed() throws Exception { final WriteFailedException.CreateFailedException cause = new WriteFailedException.CreateFailedException(id, dataAfter); final WriteFailedException.CreateFailedException createFailedException = new WriteFailedException.CreateFailedException(id, dataAfter, cause); assertEquals(createFailedException.getFailedId(), id); assertEquals(createFailedException.getData(), dataAfter); assertEquals(createFailedException.getCause(), cause); assertThat(createFailedException.getMessage(), CoreMatchers.containsString("Failed to create")); }
@Test public void testUpdateFailed() throws Exception { final WriteFailedException.UpdateFailedException cause = new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter); final WriteFailedException.UpdateFailedException createFailedException = new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, cause); assertEquals(createFailedException.getFailedId(), id); assertEquals(createFailedException.getDataBefore(), dataBefore); assertEquals(createFailedException.getDataAfter(), dataAfter); assertEquals(createFailedException.getCause(), cause); assertThat(createFailedException.getMessage(), CoreMatchers.containsString("Failed to update")); }
@Test public void testDeleteFailed() throws Exception { final WriteFailedException.DeleteFailedException cause = new WriteFailedException.DeleteFailedException(id); final WriteFailedException.DeleteFailedException createFailedException = new WriteFailedException.DeleteFailedException(id, cause); assertEquals(createFailedException.getFailedId(), id); assertEquals(createFailedException.getCause(), cause); assertThat(createFailedException.getMessage(), CoreMatchers.containsString("Failed to delete")); } |
### Question:
GenericWriter extends AbstractGenericWriter<D> { @Override protected void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataBefore, @Nonnull final WriteContext ctx) throws WriteFailedException { try { customizer.deleteCurrentAttributes(id, dataBefore, ctx); } catch (RuntimeException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final WriterCustomizer<D> customizer,
@Nonnull final Validator<D> validator); }### Answer:
@Test(expected = WriteFailedException.DeleteFailedException.class) public void testDeleteFail() throws Exception { doThrow(new IllegalStateException("test")).when(customizer) .deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); writer = new GenericWriter<>(DATA_OBJECT_ID, customizer); writer.deleteCurrentAttributes(DATA_OBJECT_ID, before, ctx); } |
### Question:
GenericWriter extends AbstractGenericWriter<D> { static boolean isUpdateSupported(final @Nonnull WriterCustomizer<?> customizer) { try { final Class<? extends WriterCustomizer> customizerClass = customizer.getClass(); final Class<?> updateDeclaringClass = customizerClass .getMethod(UPDATE_M, InstanceIdentifier.class, DataObject.class, DataObject.class, WriteContext.class) .getDeclaringClass(); final boolean supportsUpdate = !WriterCustomizer.class.equals(updateDeclaringClass); LOG.debug("Customizer {} update support : {}|Update declaring class {}", customizerClass, supportsUpdate, updateDeclaringClass); return supportsUpdate; } catch (NoSuchMethodException e) { throw new IllegalStateException("Unable to detect if customizer supports update", e); } } GenericWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final WriterCustomizer<D> customizer); GenericWriter(@Nonnull final InstanceIdentifier<D> type,
@Nonnull final WriterCustomizer<D> customizer,
@Nonnull final Validator<D> validator); }### Answer:
@Test public void testUpdateSupported() { assertFalse(GenericWriter.isUpdateSupported(new NoopWriters.NonDirectUpdateWriterCustomizer())); assertTrue(GenericWriter.isUpdateSupported(new NoopWriters.DirectUpdateWriterCustomizer())); assertTrue(GenericWriter.isUpdateSupported(new NoopWriters.ParentImplDirectUpdateWriterCustomizer())); } |
### Question:
GenericInitListReader extends GenericListReader<O, K, B> implements InitListReader<O, K, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { LOG.debug("{}: Initializing current: {}", this, id); try { for (K k : getAllIds(id, ctx)) { initSingle(broker, RWUtils.replaceLastInId(id, RWUtils.getCurrentIdItem(id, k)), ctx); } } catch (ReadFailedException e) { LOG.warn("{}: Failed to initialize current, unable to read: {}", this, id, e); throw new InitFailedException(e.getFailedId(), e); } } GenericInitListReader(@Nonnull final InstanceIdentifier<O> id,
@Nonnull final InitializingListReaderCustomizer<O, K, B> customizer); @Override void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx); }### Answer:
@SuppressWarnings("unchecked") @Test public void testInit() throws Exception { final Initialized<TestingData> initialized = Initialized.create(DATA_OBJECT_ID, data); when(getCustomizer().isPresent(any(), any(), any())).thenReturn(true); doReturn(initialized).when(getCustomizer()).init(any(), any(), any()); when(writeTx.commit()).thenReturn(FluentFuture.from(Futures.immediateFuture(null))); when(broker.newWriteOnlyTransaction()).thenReturn(writeTx); getReader().init(broker, DATA_OBJECT_ID, ctx); verify(writeTx, times(2)).merge(CONFIGURATION, DATA_OBJECT_ID, data); verify(writeTx, times(2)).commit(); }
@Test(expected = InitFailedException.class) public void testInitFailed() throws Exception { doThrow(new ReadFailedException(DATA_OBJECT_ID)).when(getCustomizer()) .readCurrentAttributes(any(), any(), any()); getReader().init(broker, DATA_OBJECT_ID, ctx); verifyZeroInteractions(writeTx); } |
### Question:
CompositeReader extends AbstractGenericReader<D, B> implements InitReader<D, B>, DelegatingReader<D, B> { @Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { if (shouldReadCurrent(id)) { LOG.trace("{}: Reading current: {}", this, id); return readCurrent((InstanceIdentifier<D>) id, ctx); } else if (shouldDelegateToChild(id)) { LOG.trace("{}: Reading child: {}", this, id); return readSubtree(id, ctx); } else { LOG.trace("{}: Delegating read: {}", this, id); return delegate.read(id, ctx); } } private CompositeReader(final Reader<D, B> reader,
final ImmutableMap<Class<?>, Reader<? extends DataObject, ? extends Builder<?>>> childReaders); @SuppressWarnings("unchecked") static InstanceIdentifier<D> appendTypeToId(
final InstanceIdentifier<? extends DataObject> parentId, final InstanceIdentifier<D> type); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
@Nonnull final ReadContext ctx); @Override Reader<D, B> getDelegate(); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final B builder,
@Nonnull final ReadContext ctx); @SuppressWarnings("unchecked") @Override void init(final DataBroker broker, final InstanceIdentifier<D> id, final ReadContext ctx); }### Answer:
@Test public void testReadFallback() throws Exception { compositeReader.read(DataObjects.DataObject4.DataObject42.IID, ctx); verify(reader4).read(DataObjects.DataObject4.DataObject42.IID, ctx); verify(reader41, times(0)).read(any(InstanceIdentifier.class), any(ReadContext.class)); } |
### Question:
CompositeReaderRegistry implements ReaderRegistry { @Override @Nonnull public Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll( @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading from all delegates: {}", this); LOG.trace("Reading from all delegates: {}", rootReaders.values()); final Multimap<InstanceIdentifier<? extends DataObject>, DataObject> objects = LinkedListMultimap.create(); for (Reader<? extends DataObject, ? extends Builder<?>> rootReader : rootReaders.values()) { LOG.debug("Reading from delegate: {}", rootReader); if (rootReader instanceof ListReader) { final List<? extends DataObject> listEntries = ((ListReader) rootReader).readList(rootReader.getManagedDataObjectType(), ctx); if (!listEntries.isEmpty()) { objects.putAll(rootReader.getManagedDataObjectType(), listEntries); } } else { final Optional<? extends DataObject> read = rootReader.read(rootReader.getManagedDataObjectType(), ctx); if (read.isPresent()) { objects.putAll(rootReader.getManagedDataObjectType(), Collections.singletonList(read.get())); } } } return objects; } CompositeReaderRegistry(@Nonnull final List<Reader<? extends DataObject, ? extends Builder<?>>> rootReaders); @Override @Nonnull Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll(
@Nonnull final ReadContext ctx); @Override void initAll(@Nonnull final DataBroker broker, @Nonnull final ReadContext ctx); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
@Nonnull final ReadContext ctx); @Override String toString(); }### Answer:
@Test public void testReadAll() throws Exception { reg.readAll(ctx); final InOrder inOrder = inOrder(rootReader3, rootReader4, reader31, reader41); inOrder.verify(rootReader3).read(any(InstanceIdentifier.class), any(ReadContext.class)); inOrder.verify(reader31).read(any(InstanceIdentifier.class), any(ReadContext.class)); inOrder.verify(rootReader4).read(any(InstanceIdentifier.class), any(ReadContext.class)); inOrder.verify(reader41).read(any(InstanceIdentifier.class), any(ReadContext.class)); } |
### Question:
CompositeReaderRegistry implements ReaderRegistry { @Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { final InstanceIdentifier.PathArgument first = checkNotNull( Iterables.getFirst(id.getPathArguments(), null), "Empty id"); final Reader<? extends DataObject, ? extends Builder<?>> reader = rootReaders.get(first.getType()); checkNotNull(reader, "Read failed. Missing reader for %s. Current readers for: %s", id, rootReaders.keySet()); LOG.debug("Reading from delegate: {}", reader); return reader.read(id, ctx); } CompositeReaderRegistry(@Nonnull final List<Reader<? extends DataObject, ? extends Builder<?>>> rootReaders); @Override @Nonnull Multimap<InstanceIdentifier<? extends DataObject>, ? extends DataObject> readAll(
@Nonnull final ReadContext ctx); @Override void initAll(@Nonnull final DataBroker broker, @Nonnull final ReadContext ctx); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
@Nonnull final ReadContext ctx); @Override String toString(); }### Answer:
@Test public void testReadSingleRoot() throws Exception { reg.read(DataObject3.IID, ctx); final InOrder inOrder = inOrder(rootReader3, rootReader4, reader31, reader41); inOrder.verify(rootReader3).read(any(InstanceIdentifier.class), any(ReadContext.class)); inOrder.verify(reader31).read(any(InstanceIdentifier.class), any(ReadContext.class)); verify(rootReader4, times(0)).read(any(InstanceIdentifier.class), any(ReadContext.class)); verify(reader41, times(0)).read(any(InstanceIdentifier.class), any(ReadContext.class)); } |
### Question:
SubtreeReader implements DelegatingReader<D, B> { static <D extends DataObject, B extends Builder<D>> Reader<D, B> createForReader(@Nonnull final Set<InstanceIdentifier<?>> handledChildren, @Nonnull final Reader<D, B> reader) { return (reader instanceof ListReader) ? new SubtreeListReader<>((ListReader) reader, handledChildren) : new SubtreeReader<>(reader, handledChildren); } SubtreeReader(final Reader<D, B> delegate, Set<InstanceIdentifier<?>> handledTypes); @Override @Nonnull Optional<? extends DataObject> read(
@Nonnull final InstanceIdentifier<? extends DataObject> id,
@Nonnull final ReadContext ctx); @Override Reader<D, B> getDelegate(); @Override @Nonnull InstanceIdentifier<D> getManagedDataObjectType(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testCreateInvalid() throws Exception { SubtreeReader.createForReader(Sets.newHashSet(DataObjects.DataObject1.IID), delegate); } |
### Question:
InitSubtreeReader extends SubtreeReader<O, B> implements InitReader<O, B> { @Override public void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx) throws InitFailedException { ((InitReader<O, B>) delegate).init(broker, id, ctx); } private InitSubtreeReader(final InitReader<O, B> delegate,
final Set<InstanceIdentifier<?>> handledTypes); @Override void init(final DataBroker broker, final InstanceIdentifier<O> id, final ReadContext ctx); }### Answer:
@Test public void testInit() throws Exception { final InitReader<DataObject1, Builder<DataObject1>> initSubReader = InitSubtreeReader.createForReader(Sets.newHashSet(DataObject1.DataObject11.IID), delegate); assertFalse(initSubReader instanceof ListReader); initSubReader.init(broker, DataObject1.IID, ctx); verify(delegate).init(broker, DataObject1.IID, ctx); } |
### Question:
CompositeReaderRegistryBuilder extends AbstractSubtreeManagerRegistryBuilderBuilder<Reader<? extends DataObject, ? extends Builder<?>>, ReaderRegistry> implements ModifiableReaderRegistryBuilder, ReaderRegistryBuilder { @Override public <D extends DataObject> void addStructuralReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType) { checkArgument(!Identifiable.class.isAssignableFrom(id.getTargetType()), "Structural readers cannot be used for keyed nodes[node type %s], use addStructuralListReader()", id.getTargetType()); add(GenericReader.createReflexive(id, builderType)); } CompositeReaderRegistryBuilder(@Nonnull final YangDAG yangDAG); @Override void addStructuralReader(@Nonnull InstanceIdentifier<D> id,
@Nonnull Class<? extends Builder<D>> builderType); @Override void addStructuralListReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType, @Nonnull List<K> staticKeys); @Override ReaderRegistry build(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testPreventStructuralReaderForList() { new CompositeReaderRegistryBuilder(new YangDAG()).addStructuralReader(InstanceIdentifier.create(DataObjects.DataObjectK.class), DataObjects.DataObjectKBuilder.class); } |
### Question:
RealtimeMappingContext implements MappingContext { @Override public <T extends DataObject> Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId) { try (ReadTransaction tx = contextBindingBrokerDependency.newReadOnlyTransaction()) { try { return tx.read(LogicalDatastoreType.OPERATIONAL, currentId).get(); } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform read of " + currentId, e); } } } RealtimeMappingContext(final DataBroker contextBindingBrokerDependency); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, final T data); @Override void put(final InstanceIdentifier<T> path, final T data); @Override void close(); }### Answer:
@Test public void testRead() { final FluentFuture<Optional<DataObject>> futureData = FluentFutures.immediateFluentFuture(Optional.of((data))); when(readTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(futureData); assertSame(ctx.read(id).get(), data); verify(broker).newReadOnlyTransaction(); verify(readTx).read(LogicalDatastoreType.OPERATIONAL, id); when(readTx.read(LogicalDatastoreType.OPERATIONAL, id)) .thenReturn(FluentFutures.immediateFluentFuture(Optional.empty())); assertFalse(ctx.read(id).isPresent()); } |
### Question:
RealtimeMappingContext implements MappingContext { @Override public <T extends DataObject> void merge(final InstanceIdentifier<T> path, final T data) { final WriteTransaction writeTx = contextBindingBrokerDependency.newWriteOnlyTransaction(); writeTx.mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, path, data); try { writeTx.commit().get(); } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform merge of " + path, e); } } RealtimeMappingContext(final DataBroker contextBindingBrokerDependency); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, final T data); @Override void put(final InstanceIdentifier<T> path, final T data); @Override void close(); }### Answer:
@Test public void testMerge() { ctx.merge(id, data); verify(broker).newWriteOnlyTransaction(); verify(writeTx).mergeParentStructureMerge(LogicalDatastoreType.OPERATIONAL, id, data); }
@Test(expected = IllegalStateException.class) public void testMergeFailure() throws Exception { when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex)); ctx.merge(id, data); } |
### Question:
RealtimeMappingContext implements MappingContext { @Override public <T extends DataObject> void put(final InstanceIdentifier<T> path, final T data) { final WriteTransaction writeTx = contextBindingBrokerDependency.newWriteOnlyTransaction(); writeTx.mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, path, data); try { writeTx.commit().get(); } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform put of " + path, e); } } RealtimeMappingContext(final DataBroker contextBindingBrokerDependency); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, final T data); @Override void put(final InstanceIdentifier<T> path, final T data); @Override void close(); }### Answer:
@Test public void testPut() { ctx.put(id, data); verify(broker).newWriteOnlyTransaction(); verify(writeTx).mergeParentStructurePut(LogicalDatastoreType.OPERATIONAL, id, data); }
@Test(expected = IllegalStateException.class) public void testPutFailure() { when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex)); ctx.put(id, data); } |
### Question:
RealtimeMappingContext implements MappingContext { @Override public void delete(final InstanceIdentifier<?> path) { final WriteTransaction writeTx = contextBindingBrokerDependency.newWriteOnlyTransaction(); writeTx.delete(LogicalDatastoreType.OPERATIONAL, path); try { writeTx.commit().get(); } catch (InterruptedException | ExecutionException e) { throw new IllegalStateException("Unable to perform delete of " + path, e); } } RealtimeMappingContext(final DataBroker contextBindingBrokerDependency); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, final T data); @Override void put(final InstanceIdentifier<T> path, final T data); @Override void close(); }### Answer:
@Test public void testDelete() { ctx.delete(id); verify(broker).newWriteOnlyTransaction(); verify(writeTx).delete(LogicalDatastoreType.OPERATIONAL, id); }
@Test(expected = IllegalStateException.class) public void testDeleteFailure() { when(writeTx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(ex)); ctx.delete(id); } |
### Question:
YangDAG { public void addVertex(final InstanceIdentifier<?> vertex) { dag.addVertex(vertex); } void addVertex(final InstanceIdentifier<?> vertex); void addEdge(final InstanceIdentifier<?> source, final InstanceIdentifier<?> target); Iterator<InstanceIdentifier<?>> iterator(); }### Answer:
@Test public void testAddVertex() { dag.addVertex(VERTEX_A); final Iterator<InstanceIdentifier<?>> it = dag.iterator(); assertEquals(VERTEX_A, it.next()); assertFalse(it.hasNext()); } |
### Question:
YangDAG { public void addEdge(final InstanceIdentifier<?> source, final InstanceIdentifier<?> target) { try { dag.addDagEdge(source, target); } catch (DirectedAcyclicGraph.CycleFoundException e) { throw new IllegalArgumentException(String.format( "Unable to add writer with relation: %s -> %s. Loop detected", source, target), e); } } void addVertex(final InstanceIdentifier<?> vertex); void addEdge(final InstanceIdentifier<?> source, final InstanceIdentifier<?> target); Iterator<InstanceIdentifier<?>> iterator(); }### Answer:
@Test public void testAddEdge() { dag.addVertex(VERTEX_A); dag.addVertex(VERTEX_B); dag.addEdge(VERTEX_A, VERTEX_B); final Iterator<InstanceIdentifier<?>> it = dag.iterator(); assertEquals(VERTEX_A, it.next()); assertEquals(VERTEX_B, it.next()); assertFalse(it.hasNext()); } |
### Question:
BindingBrokerWriter implements Writer<D> { @Override public void processModification(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter, @Nonnull final WriteContext ctx) throws WriteFailedException { final WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction(); writeTransaction.put(CONFIGURATION, (InstanceIdentifier<DataObject>) id, dataAfter); final FluentFuture<? extends CommitInfo> result = writeTransaction.commit(); try { result.get(); } catch (InterruptedException | ExecutionException ex) { throw new WriteFailedException(id, ex); } } BindingBrokerWriter(final InstanceIdentifier<D> instanceIdentifier, final DataBroker dataBroker); @Nonnull @Override InstanceIdentifier<D> getManagedDataObjectType(); @Override void processModification(@Nonnull final InstanceIdentifier<? extends DataObject> id,
@Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter,
@Nonnull final WriteContext ctx); @Override boolean supportsDirectUpdate(); }### Answer:
@Test(expected = io.fd.honeycomb.translate.write.WriteFailedException.class) public void testFailedWrite() throws Exception { when(tx.commit()).thenReturn(FluentFutures.immediateFailedFluentFuture(new InterruptedException("failing"))); bbWriter.processModification(id, data, data, ctx); } |
### Question:
JsonUtils { public static void writeJsonRoot(@Nonnull final NormalizedNode<?, ?> rootData, @Nonnull final SchemaContext schemaContext, @Nonnull final OutputStream outputStream) throws IOException { final JsonWriter jsonWriter = createJsonWriter(outputStream, true); final NormalizedNodeStreamWriter streamWriter = JSONNormalizedNodeStreamWriter .createNestedWriter(JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getShared(schemaContext), SchemaPath.ROOT, null, jsonWriter); final NormalizedNodeWriter normalizedNodeWriter = NormalizedNodeWriter.forStreamWriter(streamWriter, true); jsonWriter.beginObject(); writeChildren(normalizedNodeWriter,(ContainerNode) rootData); jsonWriter.endObject(); jsonWriter.flush(); normalizedNodeWriter.close(); jsonWriter.close(); } private JsonUtils(); static void writeJsonRoot(@Nonnull final NormalizedNode<?, ?> rootData,
@Nonnull final SchemaContext schemaContext,
@Nonnull final OutputStream outputStream); static ContainerNode readJsonRoot(@Nonnull final SchemaContext schemaContext,
@Nonnull final InputStream stream); static ContainerNode readJson(@Nonnull final SchemaContext schemaContext,
@Nonnull final InputStream stream,
@Nonnull final SchemaNode parentSchema); static ContainerNode readContainerEntryJson(@Nonnull final SchemaContext schemaContext,
@Nonnull final InputStream stream,
@Nonnull final SchemaNode parentSchema,
@Nonnull final YangInstanceIdentifier.NodeIdentifier nodeIdentifier); static MapEntryNode readListEntryFromJson(@Nonnull final SchemaContext schemaContext,
@Nonnull final InputStream stream,
@Nonnull final SchemaNode parentSchema,
@Nonnull final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier); }### Answer:
@Test public void testPersist() throws Exception { NormalizedNode<?, ?> data = getData("testing"); JsonUtils.writeJsonRoot(data, schemaContext, Files.newOutputStream(tmpPersistFile, StandardOpenOption.CREATE)); assertTrue(Files.exists(tmpPersistFile)); String persisted = new String(Files.readAllBytes(tmpPersistFile)); String expected = new String(ByteStreams.toByteArray(getClass().getResourceAsStream("/expected-persisted-output.txt"))); assertEquals(expected, persisted); data = getData("testing2"); JsonUtils.writeJsonRoot(data, schemaContext, Files.newOutputStream(tmpPersistFile, StandardOpenOption.CREATE)); persisted = new String(Files.readAllBytes(tmpPersistFile)); assertEquals(expected.replace("testing", "testing2"), persisted); assertTrue(Files.exists(tmpPersistFile)); } |
### Question:
JsonUtils { public static ContainerNode readJsonRoot(@Nonnull final SchemaContext schemaContext, @Nonnull final InputStream stream) { return readJson(schemaContext, stream, schemaContext); } private JsonUtils(); static void writeJsonRoot(@Nonnull final NormalizedNode<?, ?> rootData,
@Nonnull final SchemaContext schemaContext,
@Nonnull final OutputStream outputStream); static ContainerNode readJsonRoot(@Nonnull final SchemaContext schemaContext,
@Nonnull final InputStream stream); static ContainerNode readJson(@Nonnull final SchemaContext schemaContext,
@Nonnull final InputStream stream,
@Nonnull final SchemaNode parentSchema); static ContainerNode readContainerEntryJson(@Nonnull final SchemaContext schemaContext,
@Nonnull final InputStream stream,
@Nonnull final SchemaNode parentSchema,
@Nonnull final YangInstanceIdentifier.NodeIdentifier nodeIdentifier); static MapEntryNode readListEntryFromJson(@Nonnull final SchemaContext schemaContext,
@Nonnull final InputStream stream,
@Nonnull final SchemaNode parentSchema,
@Nonnull final YangInstanceIdentifier.NodeIdentifierWithPredicates nodeIdentifier); }### Answer:
@Test public void testRestore() throws Exception { final ContainerNode normalizedNodeOptional = JsonUtils .readJsonRoot(schemaContext, getClass().getResourceAsStream("/expected-persisted-output.txt")); assertEquals(getData("testing"), normalizedNodeOptional); }
@Test(expected = IllegalArgumentException.class) public void testRestoreInvalidFile() throws Exception { JsonUtils.readJsonRoot(schemaContext, getClass().getResourceAsStream("/test-persistence.yang")); } |
### Question:
KeepaliveReaderWrapper implements DelegatingReader<D, B>,Runnable, Closeable { @Override public void close() { scheduledFuture.cancel(false); } KeepaliveReaderWrapper(@Nonnull final Reader<D, B> delegate,
@Nonnull final ScheduledExecutorService executor,
@Nonnull final Class<? extends Exception> exception,
@Nonnegative final int delayInSeconds,
@Nonnull final KeepaliveFailureListener failureListener); @Override void run(); @Override void close(); @Override Reader<D, B> getDelegate(); }### Answer:
@Test(timeout = 10000) public void testKeepalive() throws Exception { final CapturingFailListener listener = new CapturingFailListener(); final KeepaliveReaderWrapper<DataObject, Builder<DataObject>> keepaliveWrapper = new KeepaliveReaderWrapper<>(delegate, exec, TestingException.class, 1, listener); keepaliveWrapper.readCurrentAttributes(id, builder, ctx); verify(delegate).readCurrentAttributes(id, builder, ctx); keepaliveWrapper.getBuilder(id); verify(delegate).getBuilder(id); assertTrue(listener.getTriggerFuture().get()); verify(delegate).read(any(InstanceIdentifier.class), any(ReadContext.class)); keepaliveWrapper.close(); }
@Test(timeout = 10000) public void testKeepaliveCancel() throws Exception { final CapturingFailListener listener = new CapturingFailListener(); final KeepaliveReaderWrapper<DataObject, Builder<DataObject>> keepaliveWrapper = new KeepaliveReaderWrapper<>(delegate, exec, TestingException.class, 100000, listener); keepaliveWrapper.close(); assertFalse(listener.getTriggerFuture().isDone()); } |
### Question:
TypeAwareIdentifierCacheKeyFactory implements CacheKeyFactory<U> { @Override public String createKey(@Nonnull final InstanceIdentifier<?> actualContextIdentifier, @Nullable final U dumpParams) { checkNotNull(actualContextIdentifier, "Cannot construct key for null InstanceIdentifier"); if (additionalKeyTypes.isEmpty()) { return String .join(KEY_PARTS_SEPARATOR, type.getTypeName(), params(dumpParams), actualContextIdentifier.getTargetType().toString()); } checkArgument(isUniqueKeyConstructable(actualContextIdentifier), "Unable to construct unique key, required key types : %s, provided paths : %s", additionalKeyTypes, actualContextIdentifier.getPathArguments()); return String .join(KEY_PARTS_SEPARATOR, type.getTypeName(), additionalKeys(actualContextIdentifier), params(dumpParams), actualContextIdentifier.getTargetType().toString()); } TypeAwareIdentifierCacheKeyFactory(@Nonnull final Class<?> type); TypeAwareIdentifierCacheKeyFactory(@Nonnull final Class<?> type,
@Nonnull final Set<Class<? extends DataObject>> additionalKeyTypes); @Override String createKey(@Nonnull final InstanceIdentifier<?> actualContextIdentifier, @Nullable final U dumpParams); @Override Class<?> getCachedDataType(); }### Answer:
@Test public void createKeyBothKeyedComplex() { final String key = complexKeyFactory.createKey(identifierBothKeyed, NO_PARAMS); verifyComplexKey(key, NO_PARAMS_KEY); }
@Test public void createKeyBothKeyedComplexWithParams() { final String key = complexIntegerKeyFactory.createKey(identifierBothKeyed, 123); verifyComplexKey(key, "123"); }
@Test(expected = IllegalArgumentException.class) public void createKeyOneMissingComplex() { complexKeyFactory.createKey(identifierOneMissing, NO_PARAMS); }
@Test(expected = IllegalArgumentException.class) public void createKeyNoneKeyedComplex() { complexKeyFactory.createKey(identifierNoneKeyed, NO_PARAMS); }
@Test public void createKeyBothKeyedSimple() { final String key = simpleKeyFactory.createKey(identifierBothKeyed, NO_PARAMS); verifySimpleKey(key); }
@Test public void createKeyOneMissingSimple() { final String key = simpleKeyFactory.createKey(identifierOneMissing, NO_PARAMS); verifySimpleKey(key); }
@Test public void createKeyNoneKeyedSimple() { final String key = simpleKeyFactory.createKey(identifierNoneKeyed, NO_PARAMS); verifySimpleKey(key); } |
### Question:
DataObjectUpdate { private DataObjectUpdate(@Nonnull final InstanceIdentifier<?> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter) { this.id = checkNotNull(id); this.dataAfter = dataAfter; this.dataBefore = dataBefore; } private DataObjectUpdate(@Nonnull final InstanceIdentifier<?> id,
@Nullable final DataObject dataBefore,
@Nullable final DataObject dataAfter); DataObject getDataBefore(); DataObject getDataAfter(); InstanceIdentifier<?> getId(); static DataObjectUpdate create(@Nonnull final InstanceIdentifier<?> id,
@Nullable final DataObject dataBefore,
@Nullable final DataObject dataAfter); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); DataObjectUpdate reverse(); }### Answer:
@Test public void testDataObjectUpdate() throws Exception { final DataObjectUpdate dataObjectUpdate = DataObjectUpdate.create(id, first, second); assertEquals(id, dataObjectUpdate.getId()); assertEquals(first, dataObjectUpdate.getDataBefore()); assertEquals(second, dataObjectUpdate.getDataAfter()); final DataObjectUpdate reverse = dataObjectUpdate.reverse(); assertEquals(dataObjectUpdate, reverse); assertEquals(dataObjectUpdate.hashCode(), reverse.hashCode()); assertEquals(dataObjectUpdate, reverse.reverse()); } |
### Question:
DumpCacheManager { public Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ModificationCache cache) throws ReadFailedException { return getDump(identifier, cache, null); } private DumpCacheManager(DumpCacheManagerBuilder<T, U> builder); Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier,
@Nonnull final ModificationCache cache); Optional<T> getDump(@Nonnull final InstanceIdentifier<?> identifier,
@Nonnull final ModificationCache cache, final U dumpParams); }### Answer:
@Test public void testCaching() throws ReadFailedException { final IpDetailsReplyDump stage1Data = new IpDetailsReplyDump(); final String key = cacheKeyFactory.createKey(identifier, NO_PARAMS); when(executor.executeDump(identifier, NO_PARAMS)).thenReturn(new IpDetailsReplyDump()); final Optional<IpDetailsReplyDump> stage1Optional = managerNegative.getDump(identifier, cache); assertEquals(true, stage1Optional.isPresent()); assertEquals(stage1Data, stage1Optional.get()); assertEquals(true, cache.containsKey(key)); assertEquals(stage1Data, cache.get(key)); IpDetailsReplyDump stage2LoadedDump = new IpDetailsReplyDump(); when(executor.executeDump(identifier, NO_PARAMS)).thenReturn(stage2LoadedDump); final Optional<IpDetailsReplyDump> stage2Optional = managerPositive.getDump(identifier, cache); assertEquals(true, stage2Optional.isPresent()); assertEquals(stage2LoadedDump, stage2Optional.get()); IpDetailsReplyDump stage3LoadedDump = new IpDetailsReplyDump(); when(executor.executeDump(identifier, NO_PARAMS)).thenReturn(stage3LoadedDump); final Optional<IpDetailsReplyDump> stage3Optional = managerPositive.getDump(identifier, cache); assertEquals(true, stage3Optional.isPresent()); assertEquals(stage2LoadedDump, stage3Optional.get()); }
@Test public void testPostprocessing() throws ReadFailedException { IpDetailsReplyDump dump = new IpDetailsReplyDump(); IpDetails details = new IpDetails(); details.swIfIndex = 2; dump.ipDetails.add(details); when(executor.executeDump(identifier, null)).thenReturn(dump); Optional<IpDetailsReplyDump> optionalDump = managerPositiveWithPostProcessing.getDump(identifier, cache); assertEquals(true, optionalDump.isPresent()); assertEquals(1, optionalDump.get().ipDetails.size()); assertEquals(7, optionalDump.get().ipDetails.get(0).swIfIndex); }
@Test public void testSameKeyDifferentTypes() throws ReadFailedException { final DumpCacheManager<String, Void> stringManager = new DumpCacheManager.DumpCacheManagerBuilder<String, Void>() .withExecutor((InstanceIdentifier, Void) -> "value") .acceptOnly(String.class) .build(); final DumpCacheManager<Integer, Void> intManager = new DumpCacheManager.DumpCacheManagerBuilder<Integer, Void>() .acceptOnly(Integer.class) .withExecutor((InstanceIdentifier, Void) -> 3).build(); final Optional<String> stringDump = stringManager.getDump(identifier, cache); final Optional<Integer> integerDump = intManager.getDump(identifier, cache); assertTrue(stringDump.isPresent()); assertTrue(integerDump.isPresent()); assertEquals("value", stringDump.get()); assertEquals(3, integerDump.get().intValue()); }
@Test public void testCachingWithDifferentParams() throws ReadFailedException { final DumpCacheManager<Integer, Integer> manager = new DumpCacheManager.DumpCacheManagerBuilder<Integer, Integer>() .withExecutor((iid, param) -> param) .acceptOnly(Integer.class) .build(); final Optional<Integer> dump1 = manager.getDump(identifier, cache, 1); final Optional<Integer> dump2 = manager.getDump(identifier, cache, 2); assertEquals(1, dump1.get().intValue()); assertEquals(2, dump2.get().intValue()); } |
### Question:
ReflexiveListReaderCustomizer extends ReflexiveReaderCustomizer<C, B> implements ListReaderCustomizer<C, K, B> { @Override public void readCurrentAttributes(final InstanceIdentifier<C> id, final B builder, final ReadContext context) throws ReadFailedException { final Optional<Method> method = ReflectionUtils.findMethodReflex(builder.getClass(), "withKey", Collections.singletonList(keyType), builder.getClass()); checkArgument(method.isPresent(), "Unable to build withKey for %s", builder); try { method.get().invoke(builder, ((KeyedInstanceIdentifier)id).getKey()); } catch (IllegalAccessException | InvocationTargetException e) { throw new IllegalArgumentException("Unable to build withKey for " + builder, e); } } ReflexiveListReaderCustomizer(@Nonnull final Class<C> typeClass, @Nonnull final Class<B> builderClass,
@Nonnull final List<K> staticKeys); @Override void readCurrentAttributes(final InstanceIdentifier<C> id, final B builder, final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final C readValue); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final List<C> readData); @Nonnull @Override List<K> getAllIds(@Nonnull InstanceIdentifier<C> id, @Nonnull ReadContext context); }### Answer:
@Test @SuppressWarnings("unchecked") public void testReadCurrentAttributes() throws ReadFailedException { final TestingListObject.TestingListKey keyOne = new TestingListObject.TestingListKey("1"); final TestingListObject.TestingListKey keyTwo = new TestingListObject.TestingListKey("2"); final List<TestingListObject.TestingListKey> staticKeys = Arrays.asList(keyOne, keyTwo); final ReflexiveListReaderCustomizer<TestingListObject, TestingListObject.TestingListKey, TestingListObjectBuilder> customizer = new ReflexiveListReaderCustomizer<>(TestingListObject.class, TestingListObjectBuilder.class, staticKeys); final TestingListObjectBuilder builder = new TestingListObjectBuilder(); final InstanceIdentifier<TestingListObject> id = (InstanceIdentifier<TestingListObject>) InstanceIdentifier.create( Collections.singletonList(InstanceIdentifier.IdentifiableItem.of(TestingListObject.class, keyOne))); customizer.readCurrentAttributes(id, builder, readContext); assertEquals(keyOne, builder.getKey()); } |
### Question:
ReflexiveListReaderCustomizer extends ReflexiveReaderCustomizer<C, B> implements ListReaderCustomizer<C, K, B> { @Nonnull @Override public List<K> getAllIds(@Nonnull InstanceIdentifier<C> id, @Nonnull ReadContext context) throws ReadFailedException { return staticKeys; } ReflexiveListReaderCustomizer(@Nonnull final Class<C> typeClass, @Nonnull final Class<B> builderClass,
@Nonnull final List<K> staticKeys); @Override void readCurrentAttributes(final InstanceIdentifier<C> id, final B builder, final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final C readValue); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final List<C> readData); @Nonnull @Override List<K> getAllIds(@Nonnull InstanceIdentifier<C> id, @Nonnull ReadContext context); }### Answer:
@Test public void testGetAllIds() throws ReadFailedException { final TestingListObject.TestingListKey keyOne = new TestingListObject.TestingListKey("1"); final TestingListObject.TestingListKey keyTwo = new TestingListObject.TestingListKey("2"); final List<TestingListObject.TestingListKey> staticKeys = Arrays.asList(keyOne, keyTwo); final ReflexiveListReaderCustomizer<TestingListObject, TestingListObject.TestingListKey, TestingListObjectBuilder> customizer = new ReflexiveListReaderCustomizer<>(TestingListObject.class, TestingListObjectBuilder.class, staticKeys); final List<TestingListObject.TestingListKey> allIds = customizer.getAllIds(InstanceIdentifier.create(TestingListObject.class), readContext); assertThat(allIds, hasSize(2)); assertThat(allIds, contains(keyOne, keyTwo)); } |
### Question:
BindingBrokerReader implements Reader<D, B> { @Nonnull @Override public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { try (final ReadTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction()) { final FluentFuture<? extends Optional<? extends DataObject>> read = readOnlyTransaction.read(datastoreType, id); try { return read.get(); } catch (InterruptedException | ExecutionException ex) { throw new ReadFailedException(id, ex); } } } BindingBrokerReader(final InstanceIdentifier<D> instanceIdentifier,
final DataBroker dataBroker,
final LogicalDatastoreType datastoreType,
final Class<B> builderClass); @Override boolean isPresent(final InstanceIdentifier<D> id, final D built, final ReadContext ctx); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
@Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final D readValue); @Nonnull @Override B getBuilder(final InstanceIdentifier<D> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id,
@Nonnull final B builder,
@Nonnull final ReadContext ctx); @Nonnull @Override InstanceIdentifier<D> getManagedDataObjectType(); }### Answer:
@Test public void testRead() throws Exception { assertEquals(id, bbReader.getManagedDataObjectType()); assertNotNull(bbReader.getBuilder(id)); final Optional<? extends DataObject> read = bbReader.read(id, ctx); assertSame(data, read.get()); verify(broker).newReadOnlyTransaction(); }
@Test(expected = io.fd.honeycomb.translate.read.ReadFailedException.class) public void testFailedRead() throws Exception { when(tx.read(LogicalDatastoreType.CONFIGURATION, id)) .thenReturn(FluentFutures.immediateFailedFluentFuture(new ReadFailedException("failing"))); bbReader.read(id, ctx); } |
### Question:
DataObjectUpdate { public static DataObjectUpdate create(@Nonnull final InstanceIdentifier<?> id, @Nullable final DataObject dataBefore, @Nullable final DataObject dataAfter) { checkArgument(!(dataBefore == null && dataAfter == null), "Both before and after data are null"); if (dataBefore != null) { checkArgument(id.getTargetType().isAssignableFrom(dataBefore.getClass())); } if (dataAfter != null) { checkArgument(id.getTargetType().isAssignableFrom(dataAfter.getClass())); } return dataAfter == null ? new DataObjectDelete(id, dataBefore) : new DataObjectUpdate(id, dataBefore, dataAfter); } private DataObjectUpdate(@Nonnull final InstanceIdentifier<?> id,
@Nullable final DataObject dataBefore,
@Nullable final DataObject dataAfter); DataObject getDataBefore(); DataObject getDataAfter(); InstanceIdentifier<?> getId(); static DataObjectUpdate create(@Nonnull final InstanceIdentifier<?> id,
@Nullable final DataObject dataBefore,
@Nullable final DataObject dataAfter); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); DataObjectUpdate reverse(); }### Answer:
@Test public void testDataObjectDelete() throws Exception { final DataObjectUpdate dataObjectUpdate = DataObjectUpdate.create(id, first, null); assertTrue(DataObjectUpdate.DataObjectDelete.class.isAssignableFrom(dataObjectUpdate.getClass())); } |
### Question:
BindingBrokerReader implements Reader<D, B> { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final B builder, @Nonnull final ReadContext ctx) throws ReadFailedException { throw new UnsupportedOperationException("Not supported"); } BindingBrokerReader(final InstanceIdentifier<D> instanceIdentifier,
final DataBroker dataBroker,
final LogicalDatastoreType datastoreType,
final Class<B> builderClass); @Override boolean isPresent(final InstanceIdentifier<D> id, final D built, final ReadContext ctx); @Nonnull @Override Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id,
@Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final D readValue); @Nonnull @Override B getBuilder(final InstanceIdentifier<D> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<D> id,
@Nonnull final B builder,
@Nonnull final ReadContext ctx); @Nonnull @Override InstanceIdentifier<D> getManagedDataObjectType(); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testReadCurrentAttrs() throws Exception { bbReader.readCurrentAttributes(id, new DataObjectBuilder(), ctx); } |
### Question:
ReflexiveReaderCustomizer extends NoopReaderCustomizer<C, B> { @Override public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final C readValue) { if (Augmentation.class.isAssignableFrom(typeClass)) { mergeAugmentation(parentBuilder, (Class<? extends Augmentation<?>>) typeClass, readValue); } else { mergeRegular(parentBuilder, readValue); } } ReflexiveReaderCustomizer(final Class<C> typeClass, final Class<B> builderClass); @Nonnull @Override B getBuilder(@Nonnull InstanceIdentifier<C> id); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final C readValue); }### Answer:
@Test public void testReflexCustomizerAugment() throws Exception { final ReflexiveReaderCustomizer<TestingAugmentation, TestingAugmentBuilder> reflexReaderCustomizer = new ReflexiveReaderCustomizer<>(TestingAugmentation.class, TestingAugmentBuilder.class); final TestingBuilderParent parentBuilder = new TestingBuilderParent(); final TestingAugmentation readValue = new TestingAugmentation(); reflexReaderCustomizer.merge(parentBuilder, readValue); assertEquals(readValue, parentBuilder.getAugmentation()); }
@Test public void testReflexCustomizerList() throws Exception { final ReflexiveListReaderCustomizer<TestingListObject, TestingListObject.TestingListKey, TestingListBuilder> reflexReaderCustomizer = new ReflexiveListReaderCustomizer<TestingListObject, TestingListObject.TestingListKey, TestingListBuilder> (TestingListObject.class, TestingListBuilder.class, Collections.singletonList(new TestingListObject.TestingListKey())); final TestingBuilderParent parentBuilder = new TestingBuilderParent(); final List<TestingListObject> readValue = Lists.newArrayList(new TestingListObject(), new TestingListObject()); reflexReaderCustomizer.merge(parentBuilder, readValue); assertEquals(readValue, parentBuilder.getTestingListObject()); final TestingListObject single = new TestingListObject(); reflexReaderCustomizer.merge(parentBuilder, single); assertEquals(Collections.singletonList(single), parentBuilder.getTestingListObject()); } |
### Question:
TransactionMappingContext implements MappingContext { @Override public <T extends DataObject> Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId) { try { return readWriteTransaction.read(LogicalDatastoreType.OPERATIONAL, currentId).get(); } catch (InterruptedException | ExecutionException ex) { throw new IllegalStateException("Unable to perform read", ex); } } TransactionMappingContext(final ReadWriteTransaction readWriteTransaction); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, T data); @Override void put(final InstanceIdentifier<T> path, T data); FluentFuture<? extends CommitInfo> commit(); @Override void close(); }### Answer:
@Test public void testRead() throws Exception { final FluentFuture<Optional<DataObject>> futureData = FluentFutures.immediateFluentFuture(Optional.of((data))); when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(futureData); assertSame(ctx.read(id).get(), data); verify(writeTx).read(LogicalDatastoreType.OPERATIONAL, id); when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)) .thenReturn(FluentFutures.immediateFluentFuture(Optional.empty())); assertFalse(ctx.read(id).isPresent()); }
@Test(expected = IllegalStateException.class) public void testReadFailure() throws Exception { final FluentFuture<Optional<DataObject>> futureData = FluentFutures.immediateFailedFluentFuture(ex); when(writeTx.read(LogicalDatastoreType.OPERATIONAL, id)).thenReturn(futureData); assertSame(ctx.read(id).get(), data); } |
### Question:
TransactionMappingContext implements MappingContext { @Override public <T extends DataObject> void merge(final InstanceIdentifier<T> path, T data) { readWriteTransaction.merge(LogicalDatastoreType.OPERATIONAL, path, data, true); } TransactionMappingContext(final ReadWriteTransaction readWriteTransaction); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, T data); @Override void put(final InstanceIdentifier<T> path, T data); FluentFuture<? extends CommitInfo> commit(); @Override void close(); }### Answer:
@Test public void testMerge() throws Exception { ctx.merge(id, data); verify(writeTx).merge(LogicalDatastoreType.OPERATIONAL, id, data, true); } |
### Question:
TransactionMappingContext implements MappingContext { @Override public <T extends DataObject> void put(final InstanceIdentifier<T> path, T data) { readWriteTransaction.put(LogicalDatastoreType.OPERATIONAL, path, data, true); } TransactionMappingContext(final ReadWriteTransaction readWriteTransaction); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, T data); @Override void put(final InstanceIdentifier<T> path, T data); FluentFuture<? extends CommitInfo> commit(); @Override void close(); }### Answer:
@Test public void testPut() throws Exception { ctx.put(id, data); verify(writeTx).put(LogicalDatastoreType.OPERATIONAL, id, data, true); } |
### Question:
TransactionMappingContext implements MappingContext { @Override public void delete(final InstanceIdentifier<?> path) { readWriteTransaction.delete(LogicalDatastoreType.OPERATIONAL, path); } TransactionMappingContext(final ReadWriteTransaction readWriteTransaction); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, T data); @Override void put(final InstanceIdentifier<T> path, T data); FluentFuture<? extends CommitInfo> commit(); @Override void close(); }### Answer:
@Test public void testDelete() throws Exception { ctx.delete(id); verify(writeTx).delete(LogicalDatastoreType.OPERATIONAL, id); } |
### Question:
TransactionMappingContext implements MappingContext { @Override public void close() { readWriteTransaction.cancel(); } TransactionMappingContext(final ReadWriteTransaction readWriteTransaction); @Override Optional<T> read(@Nonnull final InstanceIdentifier<T> currentId); @Override void delete(final InstanceIdentifier<?> path); @Override void merge(final InstanceIdentifier<T> path, T data); @Override void put(final InstanceIdentifier<T> path, T data); FluentFuture<? extends CommitInfo> commit(); @Override void close(); }### Answer:
@Test public void testClose() throws Exception { ctx.close(); verify(writeTx).cancel(); } |
### Question:
ModificationCache implements AutoCloseable { public Object get(final Object o) { return map.get(o); } ModificationCache(); Object get(final Object o); boolean containsKey(final Object o); Object put(final Object o, final Object o2); @Override void close(); }### Answer:
@Test public void get() throws Exception { final Object o = new Object(); assertNull(cache.get(o)); assertFalse(cache.containsKey(o)); assertNull(cache.put(o, o)); assertTrue(cache.containsKey(o)); assertEquals(o, cache.get(o)); assertEquals(o, cache.put(o, o)); cache.close(); assertFalse(cache.containsKey(o)); } |
### Question:
ProtocolCustomizer implements ListWriterCustomizer<Protocol, ProtocolKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String protocolName = dataAfter.getName(); checkArgument(protocolInstanceName.equals(protocolName), "Only single protocol named %s is supported, but %s was given", protocolInstanceName, protocolName); final Class<? extends InstallProtocolType> identifier = dataAfter.getIdentifier(); checkArgument(BGP.class.equals(identifier), "Only BGP protocol type is supported, but %s was given", identifier); } ProtocolCustomizer(@Nonnull final String protocolInstanceName); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id,
@Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id,
@Nonnull final Protocol dataBefore, @Nonnull final Protocol dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id,
@Nonnull final Protocol dataBefore, @Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWrite() throws WriteFailedException { final Protocol protocol = new ProtocolBuilder().setName(INSTANCE_NAME).setIdentifier(BGP.class).build(); customizer.writeCurrentAttributes(ID, protocol, ctx); }
@Test(expected = IllegalArgumentException.class) public void testWriteInvalidProtocolName() throws WriteFailedException { final Protocol protocol = new ProtocolBuilder().setName("some-other-name").setIdentifier(BGP.class).build(); customizer.writeCurrentAttributes(ID, protocol, ctx); }
@Test(expected = IllegalArgumentException.class) public void testWriteInvalidProtocolType() throws WriteFailedException { final Protocol protocol = new ProtocolBuilder().setName(INSTANCE_NAME).build(); customizer.writeCurrentAttributes(ID, protocol, ctx); } |
### Question:
ProtocolCustomizer implements ListWriterCustomizer<Protocol, ProtocolKey> { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataBefore, @Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, new UnsupportedOperationException("Network instance protocol update is not supported")); } ProtocolCustomizer(@Nonnull final String protocolInstanceName); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id,
@Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id,
@Nonnull final Protocol dataBefore, @Nonnull final Protocol dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id,
@Nonnull final Protocol dataBefore, @Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = WriteFailedException.UpdateFailedException.class) public void testUpdate() throws WriteFailedException { customizer.updateCurrentAttributes(ID, mock(Protocol.class), mock(Protocol.class), ctx); } |
### Question:
ProtocolCustomizer implements ListWriterCustomizer<Protocol, ProtocolKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id, @Nonnull final Protocol dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { throw new WriteFailedException.DeleteFailedException(id, new UnsupportedOperationException("Network instance protocol delete is not supported")); } ProtocolCustomizer(@Nonnull final String protocolInstanceName); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id,
@Nonnull final Protocol dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id,
@Nonnull final Protocol dataBefore, @Nonnull final Protocol dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Protocol> id,
@Nonnull final Protocol dataBefore, @Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = WriteFailedException.DeleteFailedException.class) public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(ID, mock(Protocol.class), ctx); } |
### Question:
NetworkInstanceCustomizer implements ListWriterCustomizer<NetworkInstance, NetworkInstanceKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String instanceName = dataAfter.getName(); checkArgument(networkInstanceName.equals(instanceName), "Only single network instance named %s is supported, but %s was given", networkInstanceName, instanceName); } NetworkInstanceCustomizer(@Nonnull final String networkInstanceName); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id,
@Nonnull final NetworkInstance dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id,
@Nonnull final NetworkInstance dataBefore,
@Nonnull final NetworkInstance dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id,
@Nonnull final NetworkInstance dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWrite() throws WriteFailedException { final NetworkInstance networkInstance = new NetworkInstanceBuilder().setName(INSTANCE_NAME).build(); customizer.writeCurrentAttributes(ID, networkInstance, ctx); }
@Test(expected = IllegalArgumentException.class) public void testWriteInvalidInstanceName() throws WriteFailedException { final NetworkInstance networkInstance = new NetworkInstanceBuilder().setName("some-other-name").build(); customizer.writeCurrentAttributes(ID, networkInstance, ctx); } |
### Question:
NetworkInstanceCustomizer implements ListWriterCustomizer<NetworkInstance, NetworkInstanceKey> { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataBefore, @Nonnull final NetworkInstance dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, new UnsupportedOperationException("Network instance update is not supported")); } NetworkInstanceCustomizer(@Nonnull final String networkInstanceName); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id,
@Nonnull final NetworkInstance dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id,
@Nonnull final NetworkInstance dataBefore,
@Nonnull final NetworkInstance dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id,
@Nonnull final NetworkInstance dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = WriteFailedException.UpdateFailedException.class) public void testUpdate() throws WriteFailedException { customizer.updateCurrentAttributes(ID, mock(NetworkInstance.class), mock(NetworkInstance.class), ctx); } |
### Question:
NetworkInstanceCustomizer implements ListWriterCustomizer<NetworkInstance, NetworkInstanceKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id, @Nonnull final NetworkInstance dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { throw new WriteFailedException.DeleteFailedException(id, new UnsupportedOperationException("Network instance delete is not supported")); } NetworkInstanceCustomizer(@Nonnull final String networkInstanceName); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id,
@Nonnull final NetworkInstance dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id,
@Nonnull final NetworkInstance dataBefore,
@Nonnull final NetworkInstance dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NetworkInstance> id,
@Nonnull final NetworkInstance dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = WriteFailedException.DeleteFailedException.class) public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(ID, mock(NetworkInstance.class), ctx); } |
### Question:
NotificationProducerTracker implements DOMNotificationSubscriptionListener, AutoCloseable { @Override public synchronized void onSubscriptionChanged(final Set<SchemaPath> set) { LOG.debug("Subscriptions changed. Current subscriptions: {}", set); final Set<QName> currentSubscriptions = set.stream().map(SchemaPath::getLastComponent).collect(Collectors.toSet()); final Set<QName> startedQNames = getStartedQNames(alreadyStartedProducers); final Sets.SetView<QName> newSubscriptions = Sets.difference(currentSubscriptions, startedQNames); LOG.debug("Subscriptions changed. New subscriptions: {}", newSubscriptions); final Sets.SetView<QName> deletedSubscriptions = Sets.difference(startedQNames, currentSubscriptions); LOG.debug("Subscriptions changed. Deleted subscriptions: {}", deletedSubscriptions); newSubscriptions.stream().forEach(newSub -> { if(!registry.getNotificationQNameToProducer().containsKey(newSub)) { return; } final ManagedNotificationProducer producer = registry.getNotificationQNameToProducer().get(newSub); if(alreadyStartedProducers.contains(producer)) { return; } LOG.debug("Starting notification producer: {}", producer); producer.start(collector); alreadyStartedProducers.add(producer); }); deletedSubscriptions.stream().forEach(newSub -> { checkState(registry.getNotificationQNameToProducer().containsKey(newSub)); final ManagedNotificationProducer producer = registry.getNotificationQNameToProducer().get(newSub); checkState(alreadyStartedProducers.contains(producer)); LOG.debug("Stopping notification producer: {}", producer); producer.stop(); alreadyStartedProducers.remove(producer); }); } NotificationProducerTracker(@Nonnull final NotificationProducerRegistry registry,
@Nonnull final NotificationCollector collector,
@Nonnull final DOMNotificationSubscriptionListenerRegistry notificationRouter); @Override synchronized void onSubscriptionChanged(final Set<SchemaPath> set); @Override synchronized void close(); }### Answer:
@Test public void name() throws Exception { final NotificationProducerTracker notificationProducerTracker = new NotificationProducerTracker(registry, collector, subscriptionRegistry); verify(subscriptionRegistry).registerSubscriptionListener(notificationProducerTracker); final Set<SchemaPath> subscriptions = Sets.newHashSet(); subscriptions.add(SchemaPath.create(true, NetconfSessionStart.QNAME)); notificationProducerTracker.onSubscriptionChanged(subscriptions); verify(producer).start(collector); notificationProducerTracker.onSubscriptionChanged(Sets.newHashSet()); verify(producer).stop(); } |
### Question:
FibTableCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Table, TableKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Table> instanceIdentifier, @Nonnull final Table table, @Nonnull final WriteContext writeContext) throws WriteFailedException { bindFibTableRequest(table).write(instanceIdentifier); } FibTableCustomizer(@Nonnull final FutureJVppCore vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Table> instanceIdentifier,
@Nonnull final Table table,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Table> instanceIdentifier,
@Nonnull final Table table,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWriteSimple(@InjectTestData(resourcePath = "/fib.json", id = FIB_PATH) FibTables tables) throws WriteFailedException { TableKey key = new TableKey(Ipv4.class, new VniReference(0L)); Table data = tables.getTable().stream().filter(table -> table.key().equals(key)).findAny().get(); customizer.writeCurrentAttributes(FibManagementIIds.FM_FIB_TABLES .child(Table.class, key), data, writeContext); final IpTableAddDel request = new IpTableAddDel(); request.isAdd = 1; request.isIpv6 = 0; request.tableId = 0; request.name = IPV4_VRF_0.getBytes(); verify(api).ipTableAddDel(request); } |
### Question:
LocatorContextManagerImpl implements LocatorContextManager { @Override public void addLocator(@Nonnull final String name, @Nonnull Ipv6Prefix ipv6Prefix, @Nonnull final MappingContext ctx) { final KeyedInstanceIdentifier<Srv6LocatorMapping, Srv6LocatorMappingKey> mappingIid = getLocatorIid(name); final Srv6LocatorMappingBuilder builder = new Srv6LocatorMappingBuilder() .withKey(new Srv6LocatorMappingKey(name)).setPrefix(ipv6Prefix).setName(name); ctx.put(mappingIid, builder.build()); } LocatorContextManagerImpl(@Nonnull final Integer defaultLocatorLength); @Override void addLocator(@Nonnull final String name, @Nonnull Ipv6Prefix ipv6Prefix,
@Nonnull final MappingContext ctx); @Override boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override Ipv6Prefix getLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); }### Answer:
@Test public void addLocatorTest() { LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64); contextManager.addLocator(LOCATOR.getName(), LOCATOR_PREFIX, ctx.getMappingContext()); verify(mappingContext, times(1)).put(any(), locMappingCaptor.capture()); Srv6LocatorMapping mapping = locMappingCaptor.getValue(); Assert.assertEquals(mapping.getPrefix(), LOCATOR_PREFIX); Assert.assertEquals(mapping.getName(), LOCATOR.getName()); } |
### Question:
LocatorContextManagerImpl implements LocatorContextManager { @Override public boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) { final Optional<Srv6LocatorMapping> read = ctx.read(getLocatorIid(name)); return read.isPresent(); } LocatorContextManagerImpl(@Nonnull final Integer defaultLocatorLength); @Override void addLocator(@Nonnull final String name, @Nonnull Ipv6Prefix ipv6Prefix,
@Nonnull final MappingContext ctx); @Override boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override Ipv6Prefix getLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); }### Answer:
@Test public void containsLocatorTest() { LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64); boolean containsLocator = contextManager.containsLocator(LOCATOR.getName(), ctx.getMappingContext()); Assert.assertTrue(containsLocator); } |
### Question:
LocatorContextManagerImpl implements LocatorContextManager { @Override public Ipv6Prefix getLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) { final Optional<Srv6LocatorMapping> read = ctx.read(getLocatorIid(name)); if (read.isPresent()) { return read.get().getPrefix(); } Ipv6Prefix ipv6Prefix = new Ipv6Prefix(getArtificialName(name)); addLocator(getArtificialName(name), ipv6Prefix, ctx); return ipv6Prefix; } LocatorContextManagerImpl(@Nonnull final Integer defaultLocatorLength); @Override void addLocator(@Nonnull final String name, @Nonnull Ipv6Prefix ipv6Prefix,
@Nonnull final MappingContext ctx); @Override boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override Ipv6Prefix getLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); }### Answer:
@Test public void getLocatorTest() { LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64); Ipv6Prefix locator = contextManager.getLocator(LOCATOR.getName(), ctx.getMappingContext()); Assert.assertEquals(LOCATOR_PREFIX, locator); } |
### Question:
LocatorContextManagerImpl implements LocatorContextManager { @Override public void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) { ctx.delete(getLocatorIid(name)); } LocatorContextManagerImpl(@Nonnull final Integer defaultLocatorLength); @Override void addLocator(@Nonnull final String name, @Nonnull Ipv6Prefix ipv6Prefix,
@Nonnull final MappingContext ctx); @Override boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override Ipv6Prefix getLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); @Override void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx); }### Answer:
@Test public void removeLocatorTest() { MappingContext mappingContext = ctx.getMappingContext(); LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64); contextManager.removeLocator(LOCATOR.getName(), mappingContext); verify(mappingContext, times(1)).delete(iidCaptor.capture()); Assert.assertEquals(LOCATOR.getName(), iidCaptor.getValue().firstKeyOf(Srv6LocatorMapping.class).getName()); } |
### Question:
EncapsulationSourceCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Encapsulation> { @Override public void writeCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier, @Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext) throws WriteFailedException { bindEncapsulationSourceWriteRequest(encapsulation).write(instanceIdentifier); } EncapsulationSourceCustomizer(@Nonnull FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier,
@Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier,
@Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext); }### Answer:
@Test public void writeCurrentAttributesTest() throws WriteFailedException { sourceCustomizer.writeCurrentAttributes(Srv6IIds.RT_SRV6_ENCAP, encapsulation, ctx); verify(api, Mockito.times(1)).srSetEncapSource(requestCaptor.capture()); Assert.assertTrue(Arrays.equals(BSID_BYTES, requestCaptor.getValue().encapsSource)); } |
### Question:
EncapsulationSourceCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Encapsulation> { @Override public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier, @Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext) throws WriteFailedException { bindEncapsulationSourceDeleteRequest().delete(instanceIdentifier); } EncapsulationSourceCustomizer(@Nonnull FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier,
@Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Encapsulation> instanceIdentifier,
@Nonnull Encapsulation encapsulation, @Nonnull WriteContext writeContext); }### Answer:
@Test public void deleteCurrentAttributesTest() throws WriteFailedException { sourceCustomizer.deleteCurrentAttributes(Srv6IIds.RT_SRV6_ENCAP, encapsulation, ctx); verify(api, Mockito.times(1)).srSetEncapSource(requestCaptor.capture()); Assert.assertNull(requestCaptor.getValue().encapsSource); } |
### Question:
SidCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Sid, SidKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier, @Nonnull final Sid localSid, @Nonnull final WriteContext writeContext) throws WriteFailedException { InstanceIdentifier<Locator> locatorIid = RWUtils.cutId(instanceIdentifier, Locator.class); Optional<Locator> locatorOpt = writeContext.readAfter(locatorIid); Table vrfTable = getVrfTable(instanceIdentifier, writeContext, locatorIid, locatorOpt); LocalSidFunctionRequest request = bindRequest(extractLocPrefix(instanceIdentifier, locatorOpt, localSid), localSid, vrfTable.getTableId().getValue().intValue(), writeContext); request.write(instanceIdentifier); } SidCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LocalSidFunctionWriteBindingRegistry bindingRegistry); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier,
@Nonnull final Sid localSid, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier,
@Nonnull final Sid localSid, @Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = NullPointerException.class) public void writeCurrentAttributesNullTest() throws WriteFailedException { SidCustomizer customizer = new SidCustomizer(api, WRITE_REGISTRY); Sid localSid = getSidNull(); customizer.writeCurrentAttributes(SID_A_101, localSid, ctx); verify(api, times(0)).srLocalsidAddDel(any()); } |
### Question:
SidCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Sid, SidKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier, @Nonnull final Sid localSid, @Nonnull final WriteContext writeContext) throws WriteFailedException { InstanceIdentifier<Locator> locatorIid = RWUtils.cutId(instanceIdentifier, Locator.class); Optional<Locator> locatorOpt = writeContext.readBefore(locatorIid); Table vrfTable = getVrfTable(instanceIdentifier, writeContext, locatorIid, locatorOpt); LocalSidFunctionRequest request = bindRequest(extractLocPrefix(instanceIdentifier, locatorOpt, localSid), localSid, vrfTable.getTableId().getValue().intValue(), writeContext); request.delete(instanceIdentifier); } SidCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LocalSidFunctionWriteBindingRegistry bindingRegistry); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier,
@Nonnull final Sid localSid, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier,
@Nonnull final Sid localSid, @Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = NullPointerException.class) public void deleteCurrentAttributesNullTest() throws WriteFailedException { SidCustomizer customizer = new SidCustomizer(api, WRITE_REGISTRY); Sid localSid = getSidNull(); customizer.deleteCurrentAttributes(SID_A_101, localSid, ctx); verify(api, times(0)).srLocalsidAddDel(any()); } |
### Question:
SidCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Sid, SidKey> { Ipv6Address resolveSidAddress(@Nonnull final Prefix locPrefix, @Nonnull Sid localSid) { com.googlecode.ipv6.IPv6Address ip = com.googlecode.ipv6.IPv6Address.fromString(locPrefix.getAddress().getValue()); IPv6NetworkMask mask = IPv6NetworkMask.fromPrefixLength(locPrefix.getLength().getValue()); ip = ip.maskWithNetworkMask(mask); String locIp = ip.add(localSid.getOpcode().getValue().intValue()).toString(); return new Ipv6Address(locIp); } SidCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LocalSidFunctionWriteBindingRegistry bindingRegistry); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier,
@Nonnull final Sid localSid, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Sid> instanceIdentifier,
@Nonnull final Sid localSid, @Nonnull final WriteContext writeContext); }### Answer:
@Test public void resolveSidAddressTest() { Sid localSid = getSidNull(); SidCustomizer customizer = new SidCustomizer(api, WRITE_REGISTRY); Prefix locPrefix = new PrefixBuilder().setAddress(new Ipv6Address("a::")).setLength(new Srv6LocatorLen( (short) 64)).build(); Ipv6Address ipv6Address = customizer.resolveSidAddress(locPrefix, localSid); assertTrue((IP_ADDRESS.equals(ipv6Address))); } |
### Question:
Srv6Customizer implements WriterCustomizer<Srv6> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Srv6> instanceIdentifier, @Nonnull final Srv6 srv6, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Writing SRV6 configuration is not supported by VPP. SRV6 is always enabled"); throw new WriteFailedException.CreateFailedException(instanceIdentifier, srv6, new UnsupportedOperationException("Changing SRV6 configuration is not supported by VPP.")); } @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Srv6> instanceIdentifier,
@Nonnull final Srv6 srv6,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Srv6> instanceIdentifier,
@Nonnull final Srv6 srv6,
@Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = WriteFailedException.class) public void writeCurrentAttributesNullTest() throws WriteFailedException { Srv6Customizer customizer = new Srv6Customizer(); Srv6 srv6 = new Srv6Builder().setEnable(true).build(); customizer.writeCurrentAttributes(Srv6IIds.RT_SRV6, srv6, ctx); } |
### Question:
PrefixCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Prefix, PrefixKey>, JvppReplyConsumer, ByteDataTranslator, Ipv6Translator { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id, @Nonnull final Prefix dataBefore, @Nonnull final Prefix dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Updating Prefix {} before={} after={}", id, dataBefore, dataAfter); setPrefix(id, dataAfter, writeContext, false); } PrefixCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id,
@Nonnull final Prefix dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id,
@Nonnull final Prefix dataBefore, @Nonnull final Prefix dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id,
@Nonnull final Prefix dataBefore, @Nonnull final WriteContext writeContext); }### Answer:
@Test public void testUpdate(@InjectTestData(resourcePath = "/ra/complexPrefix.json", id = RA_PATH) PrefixList prefixList) throws WriteFailedException { final Prefix data = getPrefix(prefixList); customizer.updateCurrentAttributes(IID, mock(Prefix.class), data, writeContext); final SwInterfaceIp6NdRaPrefix request = new SwInterfaceIp6NdRaPrefix(); request.swIfIndex = IFC_INDEX; request.prefix = getPrefix( new byte[]{0x20, 0x01, 0x0d, (byte) 0xb8, 0x0a, 0x0b, 0x12, (byte) 0xf0, 0, 0, 0, 0, 0, 0, 0, 0x02}, (byte) 64); request.noAdvertise = 1; request.noAutoconfig = 1; request.valLifetime = -1; request.prefLifetime = 604800; verify(api).swInterfaceIp6NdRaPrefix(request); } |
### Question:
Srv6Customizer implements WriterCustomizer<Srv6> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Srv6> instanceIdentifier, @Nonnull final Srv6 srv6, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Deleting SRV6 configuration is not supported by VPP. SRV6 is always enabled"); throw new WriteFailedException.DeleteFailedException(instanceIdentifier, new UnsupportedOperationException("Changing SRV6 configuration is not supported by VPP.")); } @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Srv6> instanceIdentifier,
@Nonnull final Srv6 srv6,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Srv6> instanceIdentifier,
@Nonnull final Srv6 srv6,
@Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = WriteFailedException.class) public void deleteCurrentAttributesNullTest() throws WriteFailedException { Srv6Customizer customizer = new Srv6Customizer(); Srv6 srv6 = new Srv6Builder().setEnable(true).build(); customizer.deleteCurrentAttributes(Srv6IIds.RT_SRV6, srv6, ctx); } |
### Question:
PolicyCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Policy, PolicyKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> instanceIdentifier, @Nonnull final Policy policy, @Nonnull final WriteContext writeContext) throws WriteFailedException { if (policy.getCandidatePaths() != null && !policy.getCandidatePaths().getCandidatePath().isEmpty()) { bindDeleteRequest(policy.getCandidatePaths().getCandidatePath(), writeContext).delete(instanceIdentifier); Ipv6Address bsid = Srv6Util.extractBsid(instanceIdentifier, writeContext, false); Preconditions.checkNotNull(bsid, "BSID must not be null"); policyContext.removePolicy(bsid, writeContext.getMappingContext()); } } PolicyCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final PolicyContextManager policyContext,
@Nonnull final CandidatePathContextManager candidateContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> instanceIdentifier,
@Nonnull final Policy policy,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Policy> instanceIdentifier,
@Nonnull final Policy policy, @Nonnull final WriteContext writeContext); }### Answer:
@Test public void deleteCurrentAttributesTest() throws WriteFailedException { PolicyCustomizer customizer = new PolicyCustomizer(api, policyCtx, candidatePathCtx); customizer.deleteCurrentAttributes(Srv6PolicyIIds.SR_TE_PLS.child(Policy.class, POLICY_KEY), policies.getPolicy().get(0), ctx); verify(api, times(1)).srPolicyDel(requestcaptorDel.capture()); SrPolicyDel srPolicy = requestcaptorDel.getValue(); Assert.assertArrayEquals(AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(BSID_ADR)), srPolicy.bsidAddr.addr); } |
### Question:
PrefixCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Prefix, PrefixKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> instanceIdentifier, @Nonnull final Prefix prefix, @Nonnull final WriteContext writeContext) throws WriteFailedException { writePrefixes(instanceIdentifier, prefix, writeContext, true).write(instanceIdentifier); } PrefixCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> instanceIdentifier,
@Nonnull final Prefix prefix,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> instanceIdentifier,
@Nonnull final Prefix prefix,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void writeCurrentAttributesV6Test() throws WriteFailedException { PrefixCustomizer customizer = new PrefixCustomizer(api); customizer.writeCurrentAttributes(L3_STEER_V6_IID, L3_STEERING_V6, ctx); verify(api, times(1)).srSteeringAddDel(requestcaptor.capture()); SrSteeringAddDel srSteering = requestcaptor.getValue(); testSrSteeringAddDelValidity(srSteering, ByteDataTranslator.BYTE_FALSE, (byte) 6, true, BSID_ADR, IPV6_PREFIX); }
@Test public void writeCurrentAttributesV4Test() throws WriteFailedException { PrefixCustomizer customizer = new PrefixCustomizer(api); customizer.writeCurrentAttributes(L3_STEER_V4_IID, L3_STEERING_V4, ctx); verify(api, times(1)).srSteeringAddDel(requestcaptor.capture()); SrSteeringAddDel srSteering = requestcaptor.getValue(); testSrSteeringAddDelValidity(srSteering, ByteDataTranslator.BYTE_FALSE, (byte) 4, false, BSID_ADR, IPV4_PREFIX); } |
### Question:
PrefixCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Prefix, PrefixKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> instanceIdentifier, @Nonnull final Prefix prefix, @Nonnull final WriteContext writeContext) throws WriteFailedException { writePrefixes(instanceIdentifier, prefix, writeContext, false).delete(instanceIdentifier); } PrefixCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> instanceIdentifier,
@Nonnull final Prefix prefix,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> instanceIdentifier,
@Nonnull final Prefix prefix,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void deleteCurrentAttributesV6Test() throws WriteFailedException { PrefixCustomizer customizer = new PrefixCustomizer(api); customizer.deleteCurrentAttributes(L3_STEER_V6_IID, L3_STEERING_V6, ctx); verify(api, times(1)).srSteeringAddDel(requestcaptor.capture()); SrSteeringAddDel srSteering = requestcaptor.getValue(); testSrSteeringAddDelValidity(srSteering, ByteDataTranslator.BYTE_TRUE, (byte) 6, true, BSID_ADR, IPV6_PREFIX); }
@Test public void deleteCurrentAttributesV4Test() throws WriteFailedException { PrefixCustomizer customizer = new PrefixCustomizer(api); customizer.deleteCurrentAttributes(L3_STEER_V4_IID, L3_STEERING_V4, ctx); verify(api, times(1)).srSteeringAddDel(requestcaptor.capture()); SrSteeringAddDel srSteering = requestcaptor.getValue(); testSrSteeringAddDelValidity(srSteering, ByteDataTranslator.BYTE_TRUE, (byte) 4, false, BSID_ADR, IPV4_PREFIX); } |
### Question:
InterfacesConfigCustomizer extends FutureJVppCustomizer implements
ListWriterCustomizer<Interface, InterfaceKey> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier, @Nonnull final Interface anInterface, @Nonnull final WriteContext writeContext) throws WriteFailedException { if (anInterface.getConfig() != null) { writeInterfaces(instanceIdentifier, anInterface.getConfig(), writeContext, true); } } InterfacesConfigCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier,
@Nonnull final Interface anInterface, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier,
@Nonnull final Interface anInterface, @Nonnull final WriteContext writeContext); }### Answer:
@Test public void writeCurrentAttributesTest() throws WriteFailedException { InterfacesConfigCustomizer customizer = new InterfacesConfigCustomizer(api, interfaceContext); customizer.writeCurrentAttributes(L2_STEER_IID, L2_STEERING, ctx); verify(api, times(1)).srSteeringAddDel(requestcaptor.capture()); SrSteeringAddDel srSteering = requestcaptor.getValue(); testRequestValidity(srSteering, ByteDataTranslator.BYTE_FALSE); } |
### Question:
InterfacesConfigCustomizer extends FutureJVppCustomizer implements
ListWriterCustomizer<Interface, InterfaceKey> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier, @Nonnull final Interface anInterface, @Nonnull final WriteContext writeContext) throws WriteFailedException { if (anInterface.getConfig() != null) { writeInterfaces(instanceIdentifier, anInterface.getConfig(), writeContext, false); } } InterfacesConfigCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier,
@Nonnull final Interface anInterface, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier,
@Nonnull final Interface anInterface, @Nonnull final WriteContext writeContext); }### Answer:
@Test public void deleteCurrentAttributesV6Test() throws WriteFailedException { InterfacesConfigCustomizer customizer = new InterfacesConfigCustomizer(api, interfaceContext); customizer.deleteCurrentAttributes(L2_STEER_IID, L2_STEERING, ctx); verify(api, times(1)).srSteeringAddDel(requestcaptor.capture()); SrSteeringAddDel srSteering = requestcaptor.getValue(); testRequestValidity(srSteering, ByteDataTranslator.BYTE_TRUE); } |
### Question:
PrefixesConfigCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Config> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Config> instanceIdentifier, @Nonnull final Config config, @Nonnull final WriteContext writeContext) throws WriteFailedException { writePrefixes(instanceIdentifier, config, writeContext, true); } PrefixesConfigCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Config> instanceIdentifier,
@Nonnull final Config config,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Config> instanceIdentifier,
@Nonnull final Config config,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void writeCurrentAttributes() throws WriteFailedException { PrefixesConfigCustomizer customizer = new PrefixesConfigCustomizer(api); customizer.writeCurrentAttributes(PREFIXES_CFG_IID, CONFIG, ctx); verify(api, times(2)).srSteeringAddDel(requestcaptor.capture()); List<SrSteeringAddDel> srSteerings = requestcaptor.getAllValues(); testSrSteeringAddDelValidity(srSteerings.get(0), ByteDataTranslator.BYTE_FALSE, L3SteeringRequest.VPP_IPV6_TYPE, true, BSID_ADR, DEFAULT_IPV6_PREFIX); testSrSteeringAddDelValidity(srSteerings.get(1), ByteDataTranslator.BYTE_FALSE, L3SteeringRequest.VPP_IPV4_TYPE, false, BSID_ADR, DEFAULT_IPV4_PREFIX); } |
### Question:
PrefixCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Prefix, PrefixKey>, JvppReplyConsumer, ByteDataTranslator, Ipv6Translator { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id, @Nonnull final Prefix dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Removing Prefix {} dataBefore={}", id, dataBefore); setPrefix(id, dataBefore, writeContext, true); } PrefixCustomizer(@Nonnull final FutureJVppCore jvpp, @Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id,
@Nonnull final Prefix dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id,
@Nonnull final Prefix dataBefore, @Nonnull final Prefix dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Prefix> id,
@Nonnull final Prefix dataBefore, @Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDelete(@InjectTestData(resourcePath = "/ra/simplePrefix.json", id = RA_PATH) PrefixList prefixList) throws WriteFailedException { final Prefix data = getPrefix(prefixList); customizer.deleteCurrentAttributes(IID, data, writeContext); final SwInterfaceIp6NdRaPrefix request = new SwInterfaceIp6NdRaPrefix(); request.swIfIndex = IFC_INDEX; request.prefix = getPrefix( new byte[]{0x20, 0x01, 0x0d, (byte) 0xb8, 0x0a, 0x0b, 0x12, (byte) 0xf0, 0, 0, 0, 0, 0, 0, 0, 0x02}, (byte) 64); request.isNo = 1; verify(api).swInterfaceIp6NdRaPrefix(request); } |
### Question:
PrefixesConfigCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Config> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Config> instanceIdentifier, @Nonnull final Config config, @Nonnull final WriteContext writeContext) throws WriteFailedException { writePrefixes(instanceIdentifier, config, writeContext, false); } PrefixesConfigCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Config> instanceIdentifier,
@Nonnull final Config config,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Config> instanceIdentifier,
@Nonnull final Config config,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void deleteCurrentAttributes() throws WriteFailedException { PrefixesConfigCustomizer customizer = new PrefixesConfigCustomizer(api); customizer.deleteCurrentAttributes(PREFIXES_CFG_IID, CONFIG, ctx); verify(api, times(2)).srSteeringAddDel(requestcaptor.capture()); List<SrSteeringAddDel> srSteerings = requestcaptor.getAllValues(); testSrSteeringAddDelValidity(srSteerings.get(0), ByteDataTranslator.BYTE_TRUE, L3SteeringRequest.VPP_IPV6_TYPE, true, BSID_ADR, DEFAULT_IPV6_PREFIX); testSrSteeringAddDelValidity(srSteerings.get(1), ByteDataTranslator.BYTE_TRUE, L3SteeringRequest.VPP_IPV4_TYPE, false, BSID_ADR, DEFAULT_IPV4_PREFIX); } |
### Question:
SidCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<Sid, SidKey, SidBuilder> { @Nonnull @Override public List<SidKey> getAllIds(@Nonnull InstanceIdentifier<Sid> instanceIdentifier, @Nonnull ReadContext readContext) throws ReadFailedException { return new LocalSidReadRequest(getFutureJVpp(), locatorContext, registry) .readAllKeys(instanceIdentifier, readContext); } SidCustomizer(@Nonnull final FutureJVppCore futureJVppCore, LocalSidFunctionReadBindingRegistry registry,
@Nonnull final LocatorContextManager locatorContext); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<Sid> instanceIdentifier,
@Nonnull Sid sid,
@Nonnull ReadContext readContext); @Nonnull @Override List<SidKey> getAllIds(@Nonnull InstanceIdentifier<Sid> instanceIdentifier, @Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<Sid> list); @Nonnull @Override SidBuilder getBuilder(@Nonnull InstanceIdentifier<Sid> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<Sid> instanceIdentifier,
@Nonnull SidBuilder sidBuilder,
@Nonnull ReadContext readContext); }### Answer:
@Test public void getAllIdsTest() throws ReadFailedException { SrLocalsidsDetails srLocalsidsDetails = new SrLocalsidsDetails(); srLocalsidsDetails.behavior = 1; Srv6Sid sid = new Srv6Sid(); sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR)); srLocalsidsDetails.addr = sid; replyDump.srLocalsidsDetails.add(srLocalsidsDetails); SidCustomizer customizer = new SidCustomizer(api, READ_REGISTRY, locatorContext); List<SidKey> allIds = customizer.getAllIds(SID_A_101, readCtx); Assert.assertNotNull(allIds); Assert.assertFalse(allIds.isEmpty()); Assert.assertTrue(allIds.contains(SID_A_101.firstKeyOf(Sid.class))); } |
### Question:
LocalSidReadRequest extends JVppRequest implements ReadRequest<Sid, SidKey, SidBuilder> { @Override @Nonnull public List<SidKey> readAllKeys(@Nonnull InstanceIdentifier<Sid> identifier, @Nonnull ReadContext ctx) throws ReadFailedException { final LocatorKey key = Preconditions.checkNotNull(identifier.firstKeyOf(Locator.class), "Identifier does not have %s ", LocatorKey.class); String locator = key.getName(); return dumpManager.getDump(identifier, ctx.getModificationCache()).orElse(STATIC_EMPTY_REPLY).srLocalsidsDetails .stream() .filter(detail -> arrayToIpv6AddressNoZone(detail.addr.addr).getValue().contains(locator)) .map(srLocalsidsDetails -> extractOpCode(arrayToIpv6AddressNoZone(srLocalsidsDetails.addr.addr), ctx.getMappingContext(), locator)) .map(SidKey::new) .collect(Collectors.toList()); } LocalSidReadRequest(final FutureJVppCore api,
final LocatorContextManager locatorContext,
final LocalSidFunctionReadBindingRegistry registry); @Override @Nonnull List<SidKey> readAllKeys(@Nonnull InstanceIdentifier<Sid> identifier, @Nonnull ReadContext ctx); @Override void readSpecific(@Nonnull InstanceIdentifier<Sid> identifier, @Nonnull ReadContext ctx,
@Nonnull SidBuilder builder); }### Answer:
@Test public void readAllKeysTest() throws ReadFailedException { SrLocalsidsDetails srLocalsidsDetails = new SrLocalsidsDetails(); Srv6Sid sid = new Srv6Sid(); sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR)); srLocalsidsDetails.addr = sid; SrLocalsidsDetails srLocalsidsDetails2 = new SrLocalsidsDetails(); Srv6Sid sid2 = new Srv6Sid(); sid2.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR_2)); srLocalsidsDetails2.addr = sid2; replyDump.srLocalsidsDetails.add(srLocalsidsDetails); replyDump.srLocalsidsDetails.add(srLocalsidsDetails2); final LocalSidReadRequest request = new LocalSidReadRequest(api, locatorContext, READ_REGISTRY); request.checkValid(); List<SidKey> sidKeys = request.readAllKeys(ID_SID, readCtx); Assert.assertFalse(sidKeys.isEmpty()); Assert.assertEquals(2, sidKeys.size()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.