method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
AfPacketValidator implements Validator<AfPacket> { @Override public void validateUpdate(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore, @Nonnull final AfPacket dataAfter, @Nonnull final WriteContext writeContext) throws UpdateValidationFailedException { try { validateAfPacket(dataAfter); } catch (Exception e) { throw new UpdateValidationFailedException(id, dataBefore, dataAfter, e); } } AfPacketValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore,
@Nonnull final AfPacket dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testUpdateSuccessful() throws UpdateValidationFailedException { validator.validateUpdate(ID, afPacket(IFACE_NAME), afPacket(IFACE_NAME), writeContext); } |
### Question:
AfPacketValidator implements Validator<AfPacket> { @Override public void validateDelete(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore, @Nonnull final WriteContext writeContext) throws DeleteValidationFailedException { try { validateAfPacket(dataBefore); } catch (Exception e) { throw new DeleteValidationFailedException(id, e); } } AfPacketValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore,
@Nonnull final AfPacket dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<AfPacket> id, @Nonnull final AfPacket dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDeleteSuccessful() throws DeleteValidationFailedException { validator.validateDelete(ID, afPacket(IFACE_NAME), writeContext); } |
### Question:
RewriteCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Rewrite>, ByteDataTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Rewrite> id, @Nonnull final Rewrite dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String subifName = getSubInterfaceName(id); LOG.debug("Disabling tag rewrite for interface {}", subifName); final Rewrite rewrite = new RewriteBuilder().build(); setTagRewrite(id, subifName, rewrite, writeContext); } RewriteCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(final InstanceIdentifier<Rewrite> id, final Rewrite dataAfter,
final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Rewrite> id,
@Nonnull final Rewrite dataBefore,
@Nonnull final Rewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Rewrite> id,
@Nonnull final Rewrite dataBefore, @Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDelete() throws Exception { whenL2InterfaceVlanTagRewriteThenSuccess(); customizer.deleteCurrentAttributes(VLAN_IID, null, writeContext); verifyL2InterfaceVlanTagRewriteDeleteWasInvoked(); }
@Test public void testDeleteFailed() throws Exception { whenL2InterfaceVlanTagRewriteThenFailure(); try { customizer.deleteCurrentAttributes(VLAN_IID, null, writeContext); } catch (WriteFailedException e) { Assert.assertTrue(e.getCause() instanceof VppBaseCallException); verifyL2InterfaceVlanTagRewriteDeleteWasInvoked(); return; } fail("WriteFailedException.DeleteFailedException was expected"); } |
### Question:
VxlanCustomizer extends AbstractInterfaceTypeCustomizer<Vxlan> implements JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String swIfName = id.firstKeyOf(Interface.class).getName(); deleteVxlanTunnel(id, swIfName, dataBefore, writeContext); } VxlanCustomizer(@Nonnull final FutureJVppCore vppApi,
@Nonnull final NamingContext interfaceNamingContext,
@Nonnull final DisabledInterfacesManager interfaceDisableContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Vxlan> id, @Nonnull final Vxlan dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDeleteCurrentAttributes() throws Exception { final Vxlan vxlan = generateVxlan(); whenVxlanAddDelTunnelThenSuccess(); defineMapping(mappingContext, ifaceName, 1, "test-instance"); customizer.deleteCurrentAttributes(id, vxlan, writeContext); verifyVxlanDeleteWasInvoked(vxlan); verify(mappingContext).delete(eq(mappingIid(ifaceName, "test-instance"))); verify(disableContext).disableInterface(1, mappingContext); }
@Test public void testDeleteCurrentAttributesaFailed() throws Exception { final Vxlan vxlan = generateVxlan(); whenVxlanAddDelTunnelThenFailure(); defineMapping(mappingContext, ifaceName, 1, "test-instance"); try { customizer.deleteCurrentAttributes(id, vxlan, writeContext); } catch (WriteFailedException.DeleteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verifyVxlanDeleteWasInvoked(vxlan); verify(mappingContext, times(0)).delete(eq(mappingIid(ifaceName, "test-instance"))); return; } fail("WriteFailedException.DeleteFailedException was expected"); } |
### Question:
SubInterfaceL2Customizer extends FutureJVppCustomizer implements WriterCustomizer<L2> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String subInterfaceName = getSubInterfaceName(id); final int subInterfaceIndex = interfaceContext.getIndex(subInterfaceName, writeContext.getMappingContext()); setL2(id, subInterfaceIndex, subInterfaceName, dataAfter, writeContext); } SubInterfaceL2Customizer(final FutureJVppCore vppApi, final NamingContext interfaceContext,
final NamingContext bridgeDomainContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore,
@Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWrite() throws WriteFailedException { final boolean bvi = true; when(api.swInterfaceSetL2Bridge(any())).thenReturn(future(new SwInterfaceSetL2BridgeReply())); customizer.writeCurrentAttributes(IID, l2(bvi), writeContext); verify(api).swInterfaceSetL2Bridge(bridgeRequest(bvi, true)); } |
### Question:
SubInterfaceL2Customizer extends FutureJVppCustomizer implements WriterCustomizer<L2> { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String subInterfaceName = getSubInterfaceName(id); final int subInterfaceIndex = interfaceContext.getIndex(subInterfaceName, writeContext.getMappingContext()); setL2(id, subInterfaceIndex, subInterfaceName, dataAfter, writeContext); } SubInterfaceL2Customizer(final FutureJVppCore vppApi, final NamingContext interfaceContext,
final NamingContext bridgeDomainContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore,
@Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testUpdate() throws WriteFailedException { final boolean bvi = false; when(api.swInterfaceSetL2Bridge(any())).thenReturn(future(new SwInterfaceSetL2BridgeReply())); customizer.updateCurrentAttributes(IID, l2(true), l2(bvi), writeContext); verify(api).swInterfaceSetL2Bridge(bridgeRequest(bvi, true)); } |
### Question:
SubInterfaceL2Customizer extends FutureJVppCustomizer implements WriterCustomizer<L2> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String subInterfaceName = getSubInterfaceName(id); final int subInterfaceIndex = interfaceContext.getIndex(subInterfaceName, writeContext.getMappingContext()); deleteL2(id, subInterfaceIndex, subInterfaceName, dataBefore, writeContext); } SubInterfaceL2Customizer(final FutureJVppCore vppApi, final NamingContext interfaceContext,
final NamingContext bridgeDomainContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore,
@Nonnull final L2 dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<L2> id, @Nonnull final L2 dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDelete() throws WriteFailedException { final boolean bvi = true; when(api.swInterfaceSetL2Bridge(any())).thenReturn(future(new SwInterfaceSetL2BridgeReply())); customizer.deleteCurrentAttributes(IID, l2(bvi), writeContext); verify(api).swInterfaceSetL2Bridge(bridgeRequest(bvi, false)); } |
### Question:
SubInterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<SubInterface, SubInterfaceKey>, ByteDataTranslator, JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataBefore, @Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String subIfaceName = getSubInterfaceName(id.firstKeyOf(Interface.class).getName(), Math.toIntExact(dataAfter.getIdentifier())); setInterfaceState(id, interfaceContext.getIndex(subIfaceName, writeContext.getMappingContext()), booleanToByte(dataAfter.isEnabled())); } SubInterfaceCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id,
@Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id,
@Nonnull final SubInterface dataBefore, @Nonnull final SubInterface dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id,
@Nonnull final SubInterface dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testUpdate() throws Exception { final List<Tag> tags = Arrays.asList(STAG_100, CTAG_200); final SubInterface before = generateSubInterface(false, tags); final SubInterface after = generateSubInterface(true, tags); final InstanceIdentifier<SubInterface> id = getSubInterfaceId(SUPER_IF_NAME, SUBIF_INDEX); whenSwInterfaceSetFlagsThenSuccess(); customizer.updateCurrentAttributes(id, before, after, writeContext); verifySwInterfaceSetFlagsWasInvoked(generateSwInterfaceEnableRequest(SUBIF_INDEX)); } |
### Question:
SubInterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<SubInterface, SubInterfaceKey>, ByteDataTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id, @Nonnull final SubInterface dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException.DeleteFailedException { throw new UnsupportedOperationException("Sub interface delete is not supported"); } SubInterfaceCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id,
@Nonnull final SubInterface dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id,
@Nonnull final SubInterface dataBefore, @Nonnull final SubInterface dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<SubInterface> id,
@Nonnull final SubInterface dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testDelete() throws Exception { final SubInterface subInterface = generateSubInterface(false, Arrays.asList(STAG_100, CTAG_200)); customizer.deleteCurrentAttributes(null, subInterface, writeContext); } |
### Question:
PbbRewriteValidator implements Validator<PbbRewrite> { @Override public void validateWrite(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.CreateValidationFailedException { try { validatePbbRewrite(id, dataAfter, false); } catch(Exception e) { throw new DataValidationFailedException.CreateValidationFailedException(id, dataAfter, e); } } PbbRewriteValidator(@Nonnull final NamingContext interfaceNamingContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore,
@Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWriteSuccessful() throws CreateValidationFailedException { validator.validateWrite(validId, validData(), writeContext); }
@Test(expected = CreateValidationFailedException.class) public void testWriteFailedInvalidIID() throws CreateValidationFailedException { validator.validateWrite(invalidId, validData(), writeContext); } |
### Question:
PbbRewriteCustomizer extends FutureJVppCustomizer implements WriterCustomizer<PbbRewrite>, MacTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id, @Nonnull final PbbRewrite dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { try { setPbbRewrite(id, dataBefore, writeContext, true); } catch (TimeoutException | VppBaseCallException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } PbbRewriteCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceNamingContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id,
@Nonnull final PbbRewrite dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id,
@Nonnull final PbbRewrite dataBefore, @Nonnull final PbbRewrite dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<PbbRewrite> id,
@Nonnull final PbbRewrite dataBefore, @Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDelete() throws WriteFailedException { whenRewriteThenSuccess(); customizer.deleteCurrentAttributes(validId, PbbRewriteValidatorTest.validData(), writeContext); verifyRewriteRequest(desiredDisableResult()); }
@Test public void testDeleteFailedCallFailed() { whenRewriteThenFail(); final PbbRewrite validData = PbbRewriteValidatorTest.validData(); try { customizer.deleteCurrentAttributes(validId, validData, writeContext); } catch (Exception e) { assertTrue(e instanceof WriteFailedException.DeleteFailedException); assertTrue(e.getCause() instanceof VppCallbackException); assertEquals(validId, ((WriteFailedException.DeleteFailedException) e).getFailedId()); return; } fail("Test should have failed"); } |
### Question:
InterfacesStatisticsCustomizer implements WriterCustomizer<Statistics> { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier, @Nonnull final Statistics statisticsCollection, @Nonnull final WriteContext writeContext) throws WriteFailedException { enableDisableStatistics(statisticsCollection); } InterfacesStatisticsCustomizer(final InterfaceStatisticsManager statisticsManager); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier,
@Nonnull final Statistics statisticsCollection,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> id,
@Nonnull final Statistics dataBefore,
@Nonnull final Statistics dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier,
@Nonnull final Statistics statisticsCollection,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWrite() throws WriteFailedException { customizer.writeCurrentAttributes(IID, enableStats(true), writeContext); Assert.assertTrue(statsManager.isStatisticsEnabled()); } |
### Question:
InterfacesStatisticsCustomizer implements WriterCustomizer<Statistics> { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> id, @Nonnull final Statistics dataBefore, @Nonnull final Statistics dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { enableDisableStatistics(dataAfter); } InterfacesStatisticsCustomizer(final InterfaceStatisticsManager statisticsManager); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier,
@Nonnull final Statistics statisticsCollection,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> id,
@Nonnull final Statistics dataBefore,
@Nonnull final Statistics dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier,
@Nonnull final Statistics statisticsCollection,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testUpdatetoEnabled() throws WriteFailedException { customizer.updateCurrentAttributes(IID, enableStats(true), enableStats(false), writeContext); Assert.assertFalse(statsManager.isStatisticsEnabled()); }
@Test public void testUpdateToDisabled() throws WriteFailedException { customizer.updateCurrentAttributes(IID, enableStats(false), enableStats(true), writeContext); Assert.assertTrue(statsManager.isStatisticsEnabled()); } |
### Question:
InterfacesStatisticsCustomizer implements WriterCustomizer<Statistics> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier, @Nonnull final Statistics statisticsCollection, @Nonnull final WriteContext writeContext) throws WriteFailedException { statisticsManager.disableStatistics(); } InterfacesStatisticsCustomizer(final InterfaceStatisticsManager statisticsManager); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier,
@Nonnull final Statistics statisticsCollection,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> id,
@Nonnull final Statistics dataBefore,
@Nonnull final Statistics dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Statistics> instanceIdentifier,
@Nonnull final Statistics statisticsCollection,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(IID, enableStats(true), writeContext); Assert.assertFalse(statsManager.isStatisticsEnabled()); } |
### Question:
TapV2Customizer extends AbstractInterfaceTypeCustomizer<TapV2> implements MacTranslator, Ipv4Translator, Ipv6Translator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<TapV2> id, @Nonnull final TapV2 dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String ifcName = id.firstKeyOf(Interface.class).getName(); final int index; try { index = interfaceContext.getIndex(ifcName, writeContext.getMappingContext()); } catch (IllegalArgumentException e) { throw new WriteFailedException.DeleteFailedException(id, e); } deleteTapV2(id, ifcName, index, dataBefore, writeContext); } TapV2Customizer(final FutureJVppCore vppApi, final NamingContext interfaceContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<TapV2> id, @Nonnull final TapV2 dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDelete() throws Exception { final TapCreateV2Reply t = new TapCreateV2Reply(); t.swIfIndex = 0; doReturn(future(t)).when(api).tapCreateV2(any(TapCreateV2.class)); doReturn(future(new TapDeleteV2Reply())).when(api).tapDeleteV2(any(TapDeleteV2.class)); tapCustomizer.writeCurrentAttributes(getTapId("tap-v2"), getTapData("tap-v2"), writeContext); defineMapping(mappingContext, "tap-v2", 1, IFC_TEST_INSTANCE); tapCustomizer.deleteCurrentAttributes(getTapId("tap-v2"), getTapData("tap-v2"), writeContext); verify(api).tapCreateV2(any(TapCreateV2.class)); verify(api).tapDeleteV2(any(TapDeleteV2.class)); verify(mappingContext).delete(eq(mappingIid("tap-v2", IFC_TEST_INSTANCE))); } |
### Question:
InterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Interface, InterfaceKey>, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { setInterface(id, dataAfter, writeContext); } InterfaceCustomizer(final FutureJVppCore vppApi, final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
@Nonnull final Interface dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
@Nonnull final Interface dataBefore,
@Nonnull final Interface dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
@Nonnull final Interface dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWrite() throws WriteFailedException { final boolean enabled = true; when(api.swInterfaceSetFlags(any())).thenReturn(future(new SwInterfaceSetFlagsReply())); customizer.writeCurrentAttributes(IID, iface(enabled), writeContext); verify(api).swInterfaceSetFlags(expectedRequest(enabled)); }
@Test public void testWriteFailed() { final boolean enabled = false; when(api.swInterfaceSetFlags(any())).thenReturn(failedFuture()); try { customizer.writeCurrentAttributes(IID, iface(enabled), writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verify(api).swInterfaceSetFlags(expectedRequest(enabled)); return; } fail("WriteFailedException expected"); } |
### Question:
InterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Interface, InterfaceKey>, JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { updateInterface(id, dataAfter, writeContext); } InterfaceCustomizer(final FutureJVppCore vppApi, final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
@Nonnull final Interface dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
@Nonnull final Interface dataBefore,
@Nonnull final Interface dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
@Nonnull final Interface dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testUpdate() throws WriteFailedException { when(api.swInterfaceSetFlags(any())).thenReturn(future(new SwInterfaceSetFlagsReply())); customizer.updateCurrentAttributes(IID, iface(false), iface(true), writeContext); verify(api).swInterfaceSetFlags(expectedRequest(true)); }
@Test public void testUpdateFailed() { when(api.swInterfaceSetFlags(any())).thenReturn(failedFuture()); try { customizer.updateCurrentAttributes(IID, iface(false), iface(true), writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verify(api).swInterfaceSetFlags(expectedRequest(true)); return; } fail("WriteFailedException expected"); } |
### Question:
InterfaceCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Interface, InterfaceKey>, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, @Nonnull final Interface dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException.DeleteFailedException { if (LOCAL0_NAME.equals(dataBefore.getName())) { throw new WriteFailedException.DeleteFailedException(id, new UnsupportedOperationException("Removing " + LOCAL0_NAME + " interface is not supported")); } } InterfaceCustomizer(final FutureJVppCore vppApi, final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
@Nonnull final Interface dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
@Nonnull final Interface dataBefore,
@Nonnull final Interface dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id,
@Nonnull final Interface dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDelete() throws WriteFailedException { customizer.deleteCurrentAttributes(IID, mock(Interface.class), writeContext); verifyZeroInteractions(api); }
@Test(expected = WriteFailedException.DeleteFailedException.class) public void testDeleteLocal0() throws WriteFailedException { final Interface ifc = mock(Interface.class); when(ifc.getName()).thenReturn(LOCAL0_IFC_NAME); customizer.deleteCurrentAttributes(LOCAL0_IID, ifc, writeContext); } |
### Question:
InterfaceRoutingValidator implements Validator<Routing> { @Override public void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext) throws UpdateValidationFailedException { try { checkVrfIds(dataAfter); checkInterfaceAddressConf(id, writeContext, true); } catch (Exception e) { throw new UpdateValidationFailedException(id, dataBefore, dataAfter, e); } } InterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore,
@Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testUpdateSuccessful() throws UpdateValidationFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); validator.validateUpdate(ID, routing(VRF_ID, true, false), routing(VRF_ID, true, true), writeContext); } |
### Question:
InterfaceRoutingValidator implements Validator<Routing> { @Override public void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext) throws DeleteValidationFailedException { try { checkVrfIds(dataBefore); checkInterfaceAddressConf(id, writeContext, false); } catch (Exception e) { throw new DeleteValidationFailedException(id, e); } } InterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore,
@Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDeleteSuccessful() throws DeleteValidationFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); validator.validateDelete(ID, routing(VRF_ID, true, false), writeContext); } |
### Question:
InterfaceRoutingCustomizer extends RoutingCustomizer implements WriterCustomizer<Routing> { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String ifName = id.firstKeyOf(Interface.class).getName(); setRouting(id, ifName, dataAfter, writeContext); } InterfaceRoutingCustomizer(@Nonnull final FutureJVppCore vppApi,
@Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id,
@Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id,
@Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id,
@Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = WriteFailedException.class) public void testUpdateFailed() throws WriteFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); when(api.swInterfaceSetTable(any())).thenReturn(failedFuture()); customizer.updateCurrentAttributes(IID, routing(123L), routing(321L), writeContext); } |
### Question:
InterfaceRoutingCustomizer extends RoutingCustomizer implements WriterCustomizer<Routing> { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String ifName = id.firstKeyOf(Interface.class).getName(); disableRouting(id, ifName, writeContext); } InterfaceRoutingCustomizer(@Nonnull final FutureJVppCore vppApi,
@Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id,
@Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id,
@Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Routing> id,
@Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDelete() throws WriteFailedException { when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); when(api.swInterfaceSetTable(any())).thenReturn(future(new SwInterfaceSetTableReply())); customizer.deleteCurrentAttributes(IID, routing(123), writeContext); verify(api).swInterfaceSetTable(expectedRequest(0)); }
@Test(expected = WriteFailedException.DeleteFailedException.class) public void testDeleteFailed() throws WriteFailedException { when(writeContext.readAfter(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); when(api.swInterfaceSetTable(any())).thenReturn(failedFuture()); customizer.deleteCurrentAttributes(IID, routing(123), writeContext); } |
### Question:
SubInterfaceRoutingValidator implements Validator<Routing> { @Override public void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext) throws CreateValidationFailedException { try { checkInterfaceAddressConf(id, writeContext, true); } catch (Exception e) { throw new CreateValidationFailedException(id, dataAfter, e); } } SubInterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore,
@Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWriteSuccessful() throws CreateValidationFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); validator.validateWrite(ID, getRouting(), writeContext); }
@Test(expected = CreateValidationFailedException.class) public void testWriteFailedV4AddressPresent() throws CreateValidationFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.of(v4AddressPresent())); validator.validateWrite(ID, getRouting(), writeContext); }
@Test(expected = CreateValidationFailedException.class) public void testWriteFailedV6AddressPresent() throws CreateValidationFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.of(v6AddressPresent())); validator.validateWrite(ID, getRouting(), writeContext); } |
### Question:
SubInterfaceRoutingValidator implements Validator<Routing> { @Override public void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext) throws UpdateValidationFailedException { try { checkInterfaceAddressConf(id, writeContext, true); } catch (Exception e) { throw new UpdateValidationFailedException(id, dataBefore, dataAfter, e); } } SubInterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore,
@Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testUpdateSuccessful() throws UpdateValidationFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); validator.validateUpdate(ID, getRouting(), getRouting(), writeContext); } |
### Question:
SubInterfaceRoutingValidator implements Validator<Routing> { @Override public void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore, @Nonnull final WriteContext writeContext) throws DeleteValidationFailedException { try { checkInterfaceAddressConf(id, writeContext, false); } catch (Exception e) { throw new DeleteValidationFailedException(id, e); } } SubInterfaceRoutingValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateUpdate(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore,
@Nonnull final Routing dataAfter, @Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Routing> id, @Nonnull final Routing dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDeleteSuccessful() throws DeleteValidationFailedException { when(writeContext.readBefore(any(InstanceIdentifier.class))).thenReturn(Optional.empty()); validator.validateDelete(ID, getRouting(), writeContext); } |
### Question:
DisabledInterfacesManager { public List<Integer> getDisabledInterfaces(@Nonnull final MappingContext ctx) { final Optional<DisabledInterfaces> read = ctx.read(DISABLED_IFCS_ROOT); if (read.isPresent()) { return read.get().getDisabledInterfaceIndex().stream() .map(DisabledInterfaceIndex::getIndex) .collect(Collectors.toList()); } else { return Collections.emptyList(); } } List<Integer> getDisabledInterfaces(@Nonnull final MappingContext ctx); boolean isInterfaceDisabled(final int index, @Nonnull final MappingContext ctx); void disableInterface(final int index, @Nonnull final MappingContext ctx); void removeDisabledInterface(final int index, @Nonnull final MappingContext ctx); }### Answer:
@Test public void testGetAll() throws Exception { final List<Integer> disabledInterfaces = manager.getDisabledInterfaces(mappingContext); assertThat(disabledInterfaces, hasItems(1, 2, 3)); } |
### Question:
DisabledInterfacesManager { public boolean isInterfaceDisabled(final int index, @Nonnull final MappingContext ctx) { return ctx.read(getKeyedId(index)) .isPresent(); } List<Integer> getDisabledInterfaces(@Nonnull final MappingContext ctx); boolean isInterfaceDisabled(final int index, @Nonnull final MappingContext ctx); void disableInterface(final int index, @Nonnull final MappingContext ctx); void removeDisabledInterface(final int index, @Nonnull final MappingContext ctx); }### Answer:
@Test public void testCheckOne() throws Exception { assertTrue(manager.isInterfaceDisabled(1, mappingContext)); assertFalse(manager.isInterfaceDisabled(4, mappingContext)); } |
### Question:
DisabledInterfacesManager { public void disableInterface(final int index, @Nonnull final MappingContext ctx) { ctx.put(getKeyedId(index), getDisabledInterfaceIndex(index)); } List<Integer> getDisabledInterfaces(@Nonnull final MappingContext ctx); boolean isInterfaceDisabled(final int index, @Nonnull final MappingContext ctx); void disableInterface(final int index, @Nonnull final MappingContext ctx); void removeDisabledInterface(final int index, @Nonnull final MappingContext ctx); }### Answer:
@Test public void testDisable() throws Exception { manager.disableInterface(1, mappingContext); verify(mappingContext).put(SPECIFIC_ID_1, toIndex(1)); } |
### Question:
DisabledInterfacesManager { public void removeDisabledInterface(final int index, @Nonnull final MappingContext ctx) { ctx.delete(getKeyedId(index)); } List<Integer> getDisabledInterfaces(@Nonnull final MappingContext ctx); boolean isInterfaceDisabled(final int index, @Nonnull final MappingContext ctx); void disableInterface(final int index, @Nonnull final MappingContext ctx); void removeDisabledInterface(final int index, @Nonnull final MappingContext ctx); }### Answer:
@Test public void testRemoveDisability() throws Exception { manager.removeDisabledInterface(1, mappingContext); verify(mappingContext).delete(SPECIFIC_ID_1); } |
### Question:
InterfaceCacheDumpManagerImpl implements InterfaceCacheDumpManager, InterfaceDataTranslator { @Override @Nonnull public synchronized Stream<SwInterfaceDetails> getInterfaces(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading all interfaces[{}]", identifier); return initMapAndGet(identifier, ctx).entrySet().stream().map(Map.Entry::getValue); } InterfaceCacheDumpManagerImpl(@Nonnull final FutureJVppCore jvpp,
@Nonnull final NamingContext namingContext); @Override @Nonnull synchronized Stream<SwInterfaceDetails> getInterfaces(@Nonnull final InstanceIdentifier<?> identifier,
@Nonnull final ReadContext ctx); @Override @Nullable synchronized SwInterfaceDetails getInterfaceDetail(@Nonnull final InstanceIdentifier<?> identifier,
@Nonnull final ReadContext ctx,
@Nonnull final String interfaceName); }### Answer:
@Test public void getInterfaces() throws Exception { assertFalse(cache.containsKey(BY_NAME_INDEX_KEY)); final List<SwInterfaceDetails> interfaces = manager.getInterfaces(identifier, ctx).collect(Collectors.toList()); assertEquals(3, interfaces.size()); assertTrue(interfaces.contains(detailZero())); assertTrue(interfaces.contains(detailOne())); assertTrue(interfaces.contains(detailTwo())); verify(jvpp, times(1)).swInterfaceDump(fullRequest()); assertTrue(cache.containsKey(BY_NAME_INDEX_KEY)); final List<SwInterfaceDetails> cachedInterfaces = manager.getInterfaces(identifier, ctx).collect(Collectors.toList()); assertEquals(3, cachedInterfaces.size()); assertTrue(cachedInterfaces.contains(detailZero())); assertTrue(cachedInterfaces.contains(detailOne())); assertTrue(cachedInterfaces.contains(detailTwo())); verifyNoMoreInteractions(jvpp); } |
### Question:
InterfaceCacheDumpManagerImpl implements InterfaceCacheDumpManager, InterfaceDataTranslator { @Override @Nullable public synchronized SwInterfaceDetails getInterfaceDetail(@Nonnull final InstanceIdentifier<?> identifier, @Nonnull final ReadContext ctx, @Nonnull final String interfaceName) throws ReadFailedException { final Map<String, SwInterfaceDetails> interfaceIndex = getMap(ctx); if (interfaceIndex != null) { return interfaceIndex.get(interfaceName); } else { return dumpSpecificDetail(identifier, ctx, interfaceName); } } InterfaceCacheDumpManagerImpl(@Nonnull final FutureJVppCore jvpp,
@Nonnull final NamingContext namingContext); @Override @Nonnull synchronized Stream<SwInterfaceDetails> getInterfaces(@Nonnull final InstanceIdentifier<?> identifier,
@Nonnull final ReadContext ctx); @Override @Nullable synchronized SwInterfaceDetails getInterfaceDetail(@Nonnull final InstanceIdentifier<?> identifier,
@Nonnull final ReadContext ctx,
@Nonnull final String interfaceName); }### Answer:
@Test public void getInterfaceDetailFromCache() throws Exception { final HashMap<Object, Object> cachedMap = new HashMap<>(); final SwInterfaceDetails detailZero = detailZero(); cachedMap.put(IFACE_0, detailZero); cache.put(BY_NAME_INDEX_KEY, cachedMap); when(jvpp.swInterfaceDump(specificRequest(IFACE_0))).thenReturn(future(specificReplyZero())); final SwInterfaceDetails interfaceDetail = manager.getInterfaceDetail(identifier, ctx, IFACE_0); assertEquals(detailZero, interfaceDetail); verifyZeroInteractions(jvpp); }
@Test public void getInterfaceDetailNotInFullDump() throws Exception { assertFalse(cache.containsKey(BY_NAME_INDEX_KEY)); final SwInterfaceDetails specificDetail = manager.getInterfaceDetail(identifierThree, ctx, IFACE_3); assertEquals(detailThree(), specificDetail); verify(jvpp, times(1)).swInterfaceDump(specificRequest(3)); } |
### Question:
Ipv4RouteCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Route, RouteKey>, JvppReplyConsumer, RouteMapper { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier, @Nonnull final Route routeBefore, @Nonnull final Route routeAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { throw new WriteFailedException.UpdateFailedException(instanceIdentifier, routeBefore, routeAfter, new UnsupportedOperationException("Operation not supported")); } Ipv4RouteCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext,
@Nonnull final NamingContext routesContext,
@Nonnull final NamingContext routingProtocolContext,
@Nonnull final MultiNamingContext routesHopsContext,
@Nonnull final VppClassifierContextManager classifierContextManager); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier,
@Nonnull final Route route,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier,
@Nonnull final Route routeBefore,
@Nonnull final Route routeAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Route> instanceIdentifier,
@Nonnull final Route route,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testUpdate( @InjectTestData(resourcePath = "/ipv4/specialhop/specialHopRouteBlackhole.json", id = STATIC_ROUTE_PATH) StaticRoutes route) { try { customizer.updateCurrentAttributes(ROUTE_IID, new RouteBuilder().build(), getIpv4RouteWithId(route, new Ipv4Prefix("192.168.2.1/24")), writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof UnsupportedOperationException); verifyNotInvoked(api); return; } fail("Test should have thrown exception"); } |
### Question:
Ipv4NeighbourValidator implements Validator<Neighbor> { @Override public void validateWrite(@Nonnull final InstanceIdentifier<Neighbor> id, @Nonnull final Neighbor dataAfter, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.CreateValidationFailedException { checkNeighborData(id, dataAfter); } Ipv4NeighbourValidator(final NamingContext ifcNamingContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Neighbor> id, @Nonnull final Neighbor dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Neighbor> id, @Nonnull final Neighbor dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWriteSuccessful() throws DataValidationFailedException.CreateValidationFailedException { validator.validateWrite(IID, getNeighbor(IP_ADDR, MAC_ADDR), writeContext); }
@Test(expected = NullPointerException.class) public void testWriteFailedMissingIP() throws DataValidationFailedException.CreateValidationFailedException { validator.validateWrite(IID, getNeighbor("", MAC_ADDR), writeContext); }
@Test(expected = NullPointerException.class) public void testWriteFailedMissingMAC() throws DataValidationFailedException.CreateValidationFailedException { validator.validateWrite(IID, getNeighbor(IP_ADDR, ""), writeContext); } |
### Question:
Ipv4NeighbourValidator implements Validator<Neighbor> { @Override public void validateDelete(@Nonnull final InstanceIdentifier<Neighbor> id, @Nonnull final Neighbor dataBefore, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.DeleteValidationFailedException { checkNeighborData(id, dataBefore); } Ipv4NeighbourValidator(final NamingContext ifcNamingContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Neighbor> id, @Nonnull final Neighbor dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Neighbor> id, @Nonnull final Neighbor dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDeleteSuccessful() throws DataValidationFailedException.DeleteValidationFailedException { validator.validateDelete(IID, getNeighbor(IP_ADDR, MAC_ADDR), writeContext); } |
### Question:
Ipv4AddressValidator implements Validator<Address> { @Override public void validateWrite(@Nonnull final InstanceIdentifier<Address> id, @Nonnull final Address dataAfter, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.CreateValidationFailedException { checkAddress(dataAfter); } Ipv4AddressValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Address> id, @Nonnull final Address dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Address> id, @Nonnull final Address dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWriteSuccessful() throws DataValidationFailedException.CreateValidationFailedException { PrefixLength length = new PrefixLengthBuilder().setPrefixLength(new Integer(24).shortValue()).build(); validator.validateWrite(Ipv4AddressCustomizerTest.getAddressId(IFC_NAME), createAddress(length), writeContext); }
@Test public void testWriteNetmaskSuccessful() throws DataValidationFailedException.CreateValidationFailedException { Netmask netmask = new NetmaskBuilder().setNetmask(new DottedQuad(IP_ADDR)).build(); validator.validateWrite(Ipv4AddressCustomizerTest.getAddressId(IFC_NAME), createAddress(netmask), writeContext); }
@Test(expected = IllegalArgumentException.class) public void testWriteNetmaskFailed() throws DataValidationFailedException.CreateValidationFailedException { validator.validateWrite(Ipv4AddressCustomizerTest.getAddressId(IFC_NAME), createAddress(null), writeContext); } |
### Question:
Ipv4AddressValidator implements Validator<Address> { @Override public void validateDelete(@Nonnull final InstanceIdentifier<Address> id, @Nonnull final Address dataBefore, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.DeleteValidationFailedException { checkAddress(dataBefore); } Ipv4AddressValidator(@Nonnull final NamingContext interfaceContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Address> id, @Nonnull final Address dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Address> id, @Nonnull final Address dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDeleteSuccessful() throws DataValidationFailedException.DeleteValidationFailedException { PrefixLength length = new PrefixLengthBuilder().setPrefixLength(new Integer(24).shortValue()).build(); validator.validateDelete(Ipv4AddressCustomizerTest.getAddressId(IFC_NAME), createAddress(length), writeContext); } |
### Question:
Ipv6NeighbourCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Neighbor, NeighborKey>, ByteDataTranslator, AddressTranslator, IpWriter,
JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Neighbor> id, @Nonnull Neighbor dataBefore, @Nonnull WriteContext writeContext) throws WriteFailedException { LOG.debug("Processing request for Neighbour delete"); String interfaceName = id.firstKeyOf(Interface.class).getName(); MappingContext mappingContext = writeContext.getMappingContext(); checkState(interfaceContext.containsIndex(interfaceName, mappingContext), "Mapping does not contains mapping for provider interface name %s", interfaceName); LOG.debug("Parent interface[{}] index found", interfaceName); addDelNeighbourAndReply(id, false, interfaceContext.getIndex(interfaceName, mappingContext), dataBefore); LOG.debug("Neighbour {} successfully deleted", id); } Ipv6NeighbourCustomizer(final FutureJVppCore futureJVppCore, final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<Neighbor> id, @Nonnull Neighbor dataAfter,
@Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<Neighbor> id, @Nonnull Neighbor dataBefore,
@Nonnull WriteContext writeContext); }### Answer:
@Test public void testDeleteCurrentAttributes() throws WriteFailedException { when(api.ipNeighborAddDel(any())).thenReturn(future(new IpNeighborAddDelReply())); customizer.deleteCurrentAttributes(IID, getData(), writeContext); verify(api).ipNeighborAddDel(getExpectedRequest(false)); }
@Test public void testDeleteCurrentAttributesFailed() { when(api.ipNeighborAddDel(any())).thenReturn(failedFuture()); try { customizer.deleteCurrentAttributes(IID, getData(), writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppBaseCallException); verify(api).ipNeighborAddDel(getExpectedRequest(false)); return; } fail("WriteFailedException expected"); } |
### Question:
NdProxyCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<NdProxy, NdProxyKey>, AddressTranslator, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NdProxy> id, @Nonnull final NdProxy dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String interfaceName = id.firstKeyOf(Interface.class).getName(); final int swIfIndex = interfaceContext.getIndex(interfaceName, writeContext.getMappingContext()); addDelNdProxy(id, swIfIndex, dataAfter.getAddress(), true); LOG.debug("ND proxy was successfully added for interface {}(id={}): {}", interfaceName, swIfIndex, dataAfter); } NdProxyCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NdProxy> id, @Nonnull final NdProxy dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NdProxy> id,
@Nonnull final NdProxy dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWrite() throws WriteFailedException { final Ipv6AddressNoZone address = new Ipv6AddressNoZone("2001::1"); final NdProxy data = new NdProxyBuilder().setAddress(address).build(); customizer.writeCurrentAttributes(getId(address), data, writeContext); final Ip6NdProxyAddDel request = new Ip6NdProxyAddDel(); request.swIfIndex = IF_INDEX; request.ip = new Ip6Address(); request.ip.ip6Address = new byte[] {0x20, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01}; verify(api).ip6NdProxyAddDel(request); } |
### Question:
NdProxyCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<NdProxy, NdProxyKey>, AddressTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NdProxy> id, @Nonnull final NdProxy dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { final String interfaceName = id.firstKeyOf(Interface.class).getName(); final int swIfIndex = interfaceContext.getIndex(interfaceName, writeContext.getMappingContext()); addDelNdProxy(id, swIfIndex, dataBefore.getAddress(), false); LOG.debug("ND proxy was successfully removed from interface {}(id={}): {}", interfaceName, swIfIndex, dataBefore); } NdProxyCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NdProxy> id, @Nonnull final NdProxy dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NdProxy> id,
@Nonnull final NdProxy dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDelete() throws WriteFailedException { final Ipv6AddressNoZone address = new Ipv6AddressNoZone("2001::3"); final NdProxy data = new NdProxyBuilder().setAddress(address).build(); customizer.deleteCurrentAttributes(getId(address), data, writeContext); final Ip6NdProxyAddDel request = new Ip6NdProxyAddDel(); request.isDel = 1; request.swIfIndex = IF_INDEX; request.ip = new Ip6Address(); request.ip.ip6Address = new byte[] {0x20, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x03}; verify(api).ip6NdProxyAddDel(request); } |
### Question:
Ipv6NeighbourValidator implements Validator<Neighbor> { @Override public void validateWrite(@Nonnull final InstanceIdentifier<Neighbor> id, @Nonnull final Neighbor dataAfter, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.CreateValidationFailedException { testNeighbor(id, dataAfter); } Ipv6NeighbourValidator(final NamingContext ifcNamingContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Neighbor> id, @Nonnull final Neighbor dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Neighbor> id, @Nonnull final Neighbor dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWriteSuccessful() throws DataValidationFailedException.CreateValidationFailedException { validator.validateWrite(IID, getNeighbor(IP_ADDR, MAC_ADDR), writeContext); }
@Test(expected = NullPointerException.class) public void testWriteFailedMissingIP() throws DataValidationFailedException.CreateValidationFailedException { validator.validateWrite(IID, getNeighbor("", MAC_ADDR), writeContext); }
@Test(expected = NullPointerException.class) public void testWriteFailedMissingMAC() throws DataValidationFailedException.CreateValidationFailedException { validator.validateWrite(IID, getNeighbor(IP_ADDR, ""), writeContext); } |
### Question:
Ipv6NeighbourValidator implements Validator<Neighbor> { @Override public void validateDelete(@Nonnull final InstanceIdentifier<Neighbor> id, @Nonnull final Neighbor dataBefore, @Nonnull final WriteContext writeContext) throws DataValidationFailedException.DeleteValidationFailedException { testNeighbor(id, dataBefore); } Ipv6NeighbourValidator(final NamingContext ifcNamingContext); @Override void validateWrite(@Nonnull final InstanceIdentifier<Neighbor> id, @Nonnull final Neighbor dataAfter,
@Nonnull final WriteContext writeContext); @Override void validateDelete(@Nonnull final InstanceIdentifier<Neighbor> id, @Nonnull final Neighbor dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDeleteSuccessful() throws DataValidationFailedException.DeleteValidationFailedException { validator.validateDelete(IID, getNeighbor(IP_ADDR, MAC_ADDR), writeContext); } |
### Question:
Ipv4Customizer extends FutureJVppCustomizer implements ReaderCustomizer<Ipv4, Ipv4Builder> { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv4> id, @Nonnull final Ipv4Builder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.debug("Reading Ipv4 leaves (mtu, forwarding) is not supported by VPP API"); } Ipv4Customizer(@Nonnull final FutureJVppCore futureJVppCore); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final Ipv4 readValue); @Nonnull @Override Ipv4Builder getBuilder(@Nonnull final InstanceIdentifier<Ipv4> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Ipv4> id, @Nonnull final Ipv4Builder builder,
@Nonnull final ReadContext ctx); }### Answer:
@Test public void testReadCurrentAttributes() throws Exception { customizer.readCurrentAttributes(null, null, ctx); verifyZeroInteractions(api); } |
### Question:
Ipv4NeighbourCustomizer extends IpNeighbourReader implements ListReaderCustomizer<Neighbor, NeighborKey, NeighborBuilder> { @Override public List<NeighborKey> getAllIds(InstanceIdentifier<Neighbor> id, ReadContext context) throws ReadFailedException { return getNeighborKeys(interfaceNeighboursDump(id, context), keyMapper()); } Ipv4NeighbourCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext); @Override NeighborBuilder getBuilder(InstanceIdentifier<Neighbor> id); @Override void readCurrentAttributes(InstanceIdentifier<Neighbor> id, NeighborBuilder builder, ReadContext ctx); @Override List<NeighborKey> getAllIds(InstanceIdentifier<Neighbor> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<Neighbor> readData); }### Answer:
@Test public void testGetAll() throws ReadFailedException { verifyList(Arrays.asList(new NeighborKey(IPV4_ONE_ADDRESS), new NeighborKey(IPV4_TWO_ADDRESS)), getCustomizer().getAllIds(instanceIdentifier, ctx)); } |
### Question:
Ipv4NeighbourCustomizer extends IpNeighbourReader implements ListReaderCustomizer<Neighbor, NeighborKey, NeighborBuilder> { @Override public void readCurrentAttributes(InstanceIdentifier<Neighbor> id, NeighborBuilder builder, ReadContext ctx) throws ReadFailedException { final Ipv4AddressNoZone ip = id.firstKeyOf(Neighbor.class).getIp(); final Optional<IpNeighborDetailsReplyDump> dumpOpt = interfaceNeighboursDump(id, ctx); if (dumpOpt.isPresent()) { dumpOpt.get().ipNeighborDetails .stream() .filter(ipNeighborDetails -> ip.equals(arrayToIpv4AddressNoZone( ipNeighborDetails.neighbor.ipAddress.un.getIp4().ip4Address))) .findFirst() .ifPresent(ipNeighborDetails -> builder.setIp(arrayToIpv4AddressNoZone( ipNeighborDetails.neighbor.ipAddress.un.getIp4().ip4Address)) .withKey(keyMapper().apply(ipNeighborDetails)) .setLinkLayerAddress(toPhysAddress(ipNeighborDetails.neighbor.macAddress.macaddress)) .setOrigin(ipNeighborDetails.neighbor.flags .contains(IpNeighborFlags.IpNeighborFlagsOptions.IP_API_NEIGHBOR_FLAG_STATIC) ? Static : Dynamic)); } } Ipv4NeighbourCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext); @Override NeighborBuilder getBuilder(InstanceIdentifier<Neighbor> id); @Override void readCurrentAttributes(InstanceIdentifier<Neighbor> id, NeighborBuilder builder, ReadContext ctx); @Override List<NeighborKey> getAllIds(InstanceIdentifier<Neighbor> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<Neighbor> readData); }### Answer:
@Test public void readCurrent() throws ReadFailedException { final NeighborBuilder builder = new NeighborBuilder(); getCustomizer().readCurrentAttributes(instanceIdentifier, builder, ctx); assertEquals(IPV4_ONE_ADDRESS, builder.getIp()); assertEquals(MAC_ONE_ADDRESS, builder.getLinkLayerAddress()); } |
### Question:
Ipv6AddressCustomizer extends IpAddressReader implements InitializingListReaderCustomizer<Address, AddressKey, AddressBuilder> { @Override public List<AddressKey> getAllIds(@Nonnull InstanceIdentifier<Address> id, @Nonnull ReadContext ctx) throws ReadFailedException { LOG.debug("Reading list of keys for interface addresses: {}", id); return getAllIpv6AddressIds(interfaceAddressDumpSupplier(id, ctx), AddressKey::new); } Ipv6AddressCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext); @Override @Nonnull AddressBuilder getBuilder(@Nonnull InstanceIdentifier<Address> id); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<Address> id, @Nonnull AddressBuilder builder,
@Nonnull ReadContext ctx); @Override List<AddressKey> getAllIds(@Nonnull InstanceIdentifier<Address> id, @Nonnull ReadContext ctx); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<Address> readData); @Override Initialized<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev180222.interfaces._interface.ipv6.Address> init(
@Nonnull final InstanceIdentifier<Address> id, @Nonnull final Address readValue,
@Nonnull final ReadContext ctx); }### Answer:
@Test public void testGetAll() throws ReadFailedException { verifyList(Arrays.asList( new AddressKey(IPV6_ONE_ADDRESS_COMPRESSED), new AddressKey(IPV6_TWO_ADDRESS_COMPRESSED)), getCustomizer().getAllIds(instanceIdentifier, ctx)); } |
### Question:
Ipv6NeighbourCustomizer extends IpNeighbourReader implements ListReaderCustomizer<Neighbor, NeighborKey, NeighborBuilder> { @Override public List<NeighborKey> getAllIds(InstanceIdentifier<Neighbor> id, ReadContext context) throws ReadFailedException { return getNeighborKeys(interfaceNeighboursDump(id, context), keyMapper()); } Ipv6NeighbourCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext); @Override NeighborBuilder getBuilder(InstanceIdentifier<Neighbor> id); @Override void readCurrentAttributes(InstanceIdentifier<Neighbor> id, NeighborBuilder builder, ReadContext ctx); @Override List<NeighborKey> getAllIds(InstanceIdentifier<Neighbor> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<Neighbor> readData); }### Answer:
@Test public void testGetAll() throws ReadFailedException { verifyList(Arrays.asList( new NeighborKey(IPV6_ONE_ADDRESS_COMPRESSED), new NeighborKey(IPV6_TWO_ADDRESS_COMPRESSED)), getCustomizer().getAllIds(instanceIdentifier, ctx)); } |
### Question:
NdProxyCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<NdProxy, NdProxyKey, NdProxyBuilder>, JvppReplyConsumer,
Ipv6Translator { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<NdProxy> id, @Nonnull final NdProxyBuilder builder, @Nonnull final ReadContext context) throws ReadFailedException { builder.setAddress(id.firstKeyOf(NdProxy.class).getAddress()); } NdProxyCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext); @Nonnull @Override List<NdProxyKey> getAllIds(@Nonnull final InstanceIdentifier<NdProxy> id,
@Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<NdProxy> list); @Nonnull @Override NdProxyBuilder getBuilder(@Nonnull final InstanceIdentifier<NdProxy> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<NdProxy> id,
@Nonnull final NdProxyBuilder builder,
@Nonnull final ReadContext context); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<NdProxy> id,
@Nonnull final NdProxy ndProxy,
@Nonnull final ReadContext readContext); }### Answer:
@Test public void readCurrent() throws ReadFailedException { final NdProxyBuilder builder = new NdProxyBuilder(); final Ipv6AddressNoZone address = new Ipv6AddressNoZone("2001::1"); getCustomizer().readCurrentAttributes(getId(IF1_NAME, address), builder, ctx); assertEquals(builder.getAddress(), address); } |
### Question:
GpeFeatureCustomizer extends FutureJVppCustomizer implements WriterCustomizer<GpeFeatureData>, JvppReplyConsumer, ByteDataTranslator { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<GpeFeatureData> id, @Nonnull final GpeFeatureData dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { LOG.debug("Removing gpe feature"); getReplyForDelete(enableDisableGpeFeature(false), id); } GpeFeatureCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<GpeFeatureData> id,
@Nonnull final GpeFeatureData dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<GpeFeatureData> id,
@Nonnull final GpeFeatureData dataBefore,
@Nonnull final GpeFeatureData dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<GpeFeatureData> id,
@Nonnull final GpeFeatureData dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDelete() throws WriteFailedException { when(api.gpeEnableDisable(any())).thenReturn(future(new GpeEnableDisableReply())); customizer.deleteCurrentAttributes(InstanceIdentifier.create(GpeFeatureData.class), new GpeFeatureDataBuilder().setEnable(true).build(), writeContext); verify(api, times(1)).gpeEnableDisable(requestCaptor.capture()); final GpeEnableDisable request = requestCaptor.getValue(); assertEquals(0, request.isEn); } |
### Question:
NativeForwardPathsTableCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<NativeForwardPathsTable, NativeForwardPathsTableKey>, ByteDataTranslator,
JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id, @Nonnull final NativeForwardPathsTable dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { createFibTable(id, dataAfter); } NativeForwardPathsTableCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id,
@Nonnull final NativeForwardPathsTable dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id,
@Nonnull final NativeForwardPathsTable dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWriteValid() throws WriteFailedException { when(api.gpeAddDelNativeFwdRpath(any())).thenReturn(future(new GpeAddDelNativeFwdRpathReply())); customizer.writeCurrentAttributes(validId, validTable(), writeContext); verify(api, times(1)).gpeAddDelIface(requestCaptor.capture()); final List<GpeAddDelIface> requests = requestCaptor.getAllValues(); assertEquals(desiredRequest(1, 1), requests.get(0)); } |
### Question:
NativeForwardPathsTableCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<NativeForwardPathsTable, NativeForwardPathsTableKey>, ByteDataTranslator,
JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id, @Nonnull final NativeForwardPathsTable dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { deleteFibTable(id); } NativeForwardPathsTableCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id,
@Nonnull final NativeForwardPathsTable dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id,
@Nonnull final NativeForwardPathsTable dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDeleteValid() throws WriteFailedException { when(api.gpeAddDelNativeFwdRpath(any())).thenReturn(future(new GpeAddDelNativeFwdRpathReply())); customizer.deleteCurrentAttributes(validId, validTable(), writeContext); verify(api, times(1)).gpeAddDelIface(requestCaptor.capture()); final List<GpeAddDelIface> requests = requestCaptor.getAllValues(); assertEquals(desiredRequest(0, 1), requests.get(0)); } |
### Question:
GpeFeatureCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<GpeFeatureData, GpeFeatureDataBuilder>, JvppReplyConsumer,
ByteDataTranslator { @Override public void readCurrentAttributes(@Nonnull final InstanceIdentifier<GpeFeatureData> id, @Nonnull final GpeFeatureDataBuilder builder, @Nonnull final ReadContext ctx) throws ReadFailedException { final ShowLispStatusReply reply = getReplyForRead(getFutureJVpp().showLispStatus(new ShowLispStatus()).toCompletableFuture(), id); if (reply != null) { builder.setEnable(byteToBoolean(reply.gpeStatus)); } } GpeFeatureCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<GpeFeatureData> id,
@Nonnull final GpeFeatureData readValue,
@Nonnull final ReadContext ctx); @Nonnull @Override GpeFeatureDataBuilder getBuilder(@Nonnull final InstanceIdentifier<GpeFeatureData> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<GpeFeatureData> id,
@Nonnull final GpeFeatureDataBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final GpeFeatureData readValue); }### Answer:
@Test public void testReadCurrent() throws ReadFailedException { final ShowLispStatusReply result = new ShowLispStatusReply(); result.gpeStatus = 1; when(api.showLispStatus(any())).thenReturn(future(result)); final GpeFeatureDataBuilder builder = new GpeFeatureDataBuilder(); getCustomizer().readCurrentAttributes(InstanceIdentifier.create(GpeFeatureData.class), builder, ctx); assertTrue(builder.isEnable()); } |
### Question:
GpeFeatureCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<GpeFeatureData, GpeFeatureDataBuilder>, JvppReplyConsumer,
ByteDataTranslator { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<GpeFeatureData> id, @Nonnull final GpeFeatureData readValue, @Nonnull final ReadContext ctx) { return Initialized.create(InstanceIdentifier.create(Gpe.class).child(GpeFeatureData.class), new GpeFeatureDataBuilder().setEnable(readValue.isEnable()).build()); } GpeFeatureCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<GpeFeatureData> id,
@Nonnull final GpeFeatureData readValue,
@Nonnull final ReadContext ctx); @Nonnull @Override GpeFeatureDataBuilder getBuilder(@Nonnull final InstanceIdentifier<GpeFeatureData> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<GpeFeatureData> id,
@Nonnull final GpeFeatureDataBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final GpeFeatureData readValue); }### Answer:
@Test public void testInit() { final InstanceIdentifier<GpeFeatureData> CONFIG_ID = InstanceIdentifier.create(Gpe.class).child(GpeFeatureData.class); final InstanceIdentifier<GpeFeatureData> STATE_ID = InstanceIdentifier.create(GpeState.class).child(GpeFeatureData.class); final GpeFeatureData data = new GpeFeatureDataBuilder().build(); invokeInitTest(STATE_ID, data, CONFIG_ID, data); } |
### Question:
GpeForwardEntryCustomizer extends FutureJVppCustomizer implements InitializingListReaderCustomizer<GpeEntry, GpeEntryKey, GpeEntryBuilder>, JvppReplyConsumer,
EidTranslator { @Nonnull @Override public List<GpeEntryKey> getAllIds(@Nonnull final InstanceIdentifier<GpeEntry> id, @Nonnull final ReadContext context) throws ReadFailedException { if (!gpeStateCheckService.isGpeEnabled(context)) { return Collections.emptyList(); } return activeVnis(id, context.getModificationCache()) .flatMap(vni -> getKeysForVni(id, vni, context).stream()) .collect(Collectors.toList()); } GpeForwardEntryCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final GpeStateCheckService gpeStateCheckService,
@Nonnull final NamingContext gpeEntryMappingContext); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<GpeEntry> id,
@Nonnull final GpeEntry readValue,
@Nonnull final ReadContext ctx); @Nonnull @Override List<GpeEntryKey> getAllIds(@Nonnull final InstanceIdentifier<GpeEntry> id,
@Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<GpeEntry> readData); @Nonnull @Override GpeEntryBuilder getBuilder(@Nonnull final InstanceIdentifier<GpeEntry> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<GpeEntry> id,
@Nonnull final GpeEntryBuilder builder,
@Nonnull final ReadContext ctx); }### Answer:
@Test public void testGetAll() throws ReadFailedException { final List<GpeEntryKey> allIds = getCustomizer().getAllIds(V4_IDENTIFIER, ctx); assertTrue(allIds.containsAll(Arrays.asList(new GpeEntryKey(V4_ENTRY_ID), new GpeEntryKey(V6_ENTRY_ID), new GpeEntryKey(MAC_ENTRY_ID)))); } |
### Question:
NativeForwardPathsTableCustomizer extends FutureJVppCustomizer implements
InitializingListReaderCustomizer<NativeForwardPathsTable, NativeForwardPathsTableKey, NativeForwardPathsTableBuilder>,
JvppReplyConsumer { @Nonnull @Override public List<NativeForwardPathsTableKey> getAllIds(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id, @Nonnull final ReadContext context) throws ReadFailedException { return Stream.concat(v4FibsStream(id, context), v6FibsStream(id, context)) .mapToLong(UnsignedInts::toLong) .distinct() .mapToObj(NativeForwardPathsTableKey::new) .collect(Collectors.toList()); } NativeForwardPathsTableCustomizer(@Nonnull final FutureJVppCore futureJVppCore); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id,
@Nonnull final NativeForwardPathsTable readValue,
@Nonnull final ReadContext ctx); @Nonnull @Override List<NativeForwardPathsTableKey> getAllIds(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id,
@Nonnull final ReadContext context); @Override void merge(@Nonnull final Builder<? extends DataObject> builder,
@Nonnull final List<NativeForwardPathsTable> readData); @Nonnull @Override NativeForwardPathsTableBuilder getBuilder(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<NativeForwardPathsTable> id,
@Nonnull final NativeForwardPathsTableBuilder builder,
@Nonnull final ReadContext ctx); }### Answer:
@Test public void testGetAll() throws ReadFailedException { final List<NativeForwardPathsTableKey> allIds = getCustomizer().getAllIds(validId, ctx); assertEquals(3, allIds.size()); assertTrue(allIds.contains(new NativeForwardPathsTableKey((long) TABLE_0_IDX))); assertTrue(allIds.contains(new NativeForwardPathsTableKey((long) TABLE_1_IDX))); assertTrue(allIds.contains(new NativeForwardPathsTableKey((long) TABLE_2_IDX))); } |
### Question:
VrfSubtableCustomizer extends FutureJVppCustomizer implements WriterCustomizer<VrfSubtable>, SubtableWriter { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id, @Nonnull final VrfSubtable dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { checkNotNull(dataAfter.getTableId(), "Table id must be present"); LOG.debug("Writing Id[{}]/Data[{}]", id, dataAfter); try { addDelSubtableMapping(getFutureJVpp(), true, extractVni(id), dataAfter.getTableId().intValue(), false, LOG); } catch (TimeoutException | VppBaseCallException e) { throw new WriteFailedException.CreateFailedException(id, dataAfter, e); } LOG.debug("{} successfully written", id); } VrfSubtableCustomizer(@Nonnull final FutureJVppCore futureJvpp); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id,
@Nonnull final VrfSubtable dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id,
@Nonnull final VrfSubtable dataBefore, @Nonnull final WriteContext writeContext); }### Answer:
@Test public void testWriteSuccessfull() throws WriteFailedException { whenAddDelEidTableAddDelMapSuccess(); customizer.writeCurrentAttributes(validId, validData, writeContext); verifyAddDelEidTableAddDelMapInvokedCorrectly(1, 12, 10, 0); }
@Test public void testWriteFailed() { whenAddDelEidTableAddDelMapFail(); try { customizer.writeCurrentAttributes(validId, validData, writeContext); } catch (Exception e) { assertTrue(e instanceof WriteFailedException); final WriteFailedException realException = ((WriteFailedException) e); assertEquals(validId, realException.getFailedId()); assertTrue(e.getCause() instanceof VppCallbackException); return; } fail("Test should throw exception"); } |
### Question:
VrfSubtableCustomizer extends FutureJVppCustomizer implements WriterCustomizer<VrfSubtable>, SubtableWriter { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id, @Nonnull final VrfSubtable dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { checkNotNull(dataBefore.getTableId(), "Table id must be present"); LOG.debug("Removing Id[{}]/Data[{}]", id, dataBefore); try { addDelSubtableMapping(getFutureJVpp(), false, extractVni(id), dataBefore.getTableId().intValue(), false, LOG); } catch (TimeoutException | VppBaseCallException e) { throw new WriteFailedException.CreateFailedException(id, dataBefore, e); } LOG.debug("{} successfully removed", id); } VrfSubtableCustomizer(@Nonnull final FutureJVppCore futureJvpp); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id,
@Nonnull final VrfSubtable dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id,
@Nonnull final VrfSubtable dataBefore, @Nonnull final WriteContext writeContext); }### Answer:
@Test public void testDeleteSuccessfull() throws WriteFailedException { whenAddDelEidTableAddDelMapSuccess(); customizer.deleteCurrentAttributes(validId, validData, writeContext); verifyAddDelEidTableAddDelMapInvokedCorrectly(0, 12, 10, 0); }
@Test public void testDeleteFailed() { whenAddDelEidTableAddDelMapFail(); try { customizer.deleteCurrentAttributes(validId, validData, writeContext); } catch (Exception e) { assertTrue(e instanceof WriteFailedException); final WriteFailedException realException = ((WriteFailedException) e); assertEquals(validId, realException.getFailedId()); assertTrue(e.getCause() instanceof VppCallbackException); return; } fail("Test should throw exception"); } |
### Question:
AdjacencyCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Adjacency, AdjacencyKey>, ByteDataTranslator, EidTranslator,
JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Adjacency> id, @Nonnull final Adjacency dataBefore, @Nonnull final Adjacency dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { checkIgnoredSubnetUpdate(dataBefore.getLocalEid().getAddress(), dataAfter.getLocalEid().getAddress(), LOG); checkIgnoredSubnetUpdate(dataBefore.getRemoteEid().getAddress(), dataAfter.getRemoteEid().getAddress(), LOG); } AdjacencyCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final EidMappingContext localEidsMappingContext,
@Nonnull final EidMappingContext remoteEidsMappingContext,
@Nonnull final AdjacenciesMappingContext adjacenciesMappingContext); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Adjacency> id,
@Nonnull final Adjacency dataAfter, @Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Adjacency> id,
@Nonnull final Adjacency dataBefore, @Nonnull final Adjacency dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Adjacency> id,
@Nonnull final Adjacency dataBefore, @Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void updateCurrentAttributesFail() throws Exception { customizer.updateCurrentAttributes(emptyId, failDataBefore, failDataAfter, writeContext); }
@Test public void updateCurrentAttributesIgnore() throws Exception { customizer.updateCurrentAttributes(emptyId, ignoreDataBefore, ignoreDataAfter, writeContext); verifyZeroInteractions(api); } |
### Question:
LispCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Lisp>, ByteDataTranslator, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Lisp> id, @Nonnull final Lisp dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { Preconditions.checkNotNull(dataAfter, "Lisp is null"); try { enableDisableLisp(dataAfter.isEnable()); } catch (VppBaseCallException | TimeoutException e) { throw new WriteFailedException.CreateFailedException(id, dataAfter, e); } } LispCustomizer(final FutureJVppCore vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Lisp> id, @Nonnull final Lisp dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Lisp> id, @Nonnull final Lisp dataBefore,
@Nonnull final Lisp dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Lisp> id, @Nonnull final Lisp dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = NullPointerException.class) public void testWriteCurrentAttributesNullData() throws WriteFailedException { customizer.writeCurrentAttributes(null, null, null); }
@Test public void testWriteCurrentAttributes() throws WriteFailedException { Lisp intf = new LispBuilder().setEnable(true).build(); whenlispEnableDisableThenSuccess(); customizer.writeCurrentAttributes(null, intf, null); ArgumentCaptor<OneEnableDisable> mappingCaptor = ArgumentCaptor.forClass(OneEnableDisable.class); verify(api, times(1)).oneEnableDisable(mappingCaptor.capture()); OneEnableDisable request = mappingCaptor.getValue(); assertNotNull(request); assertEquals(1, request.isEn); } |
### Question:
LispCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Lisp>, ByteDataTranslator, JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Lisp> id, @Nonnull final Lisp dataBefore, @Nonnull final Lisp dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { Preconditions.checkNotNull(dataAfter, "Lisp is null"); try { enableDisableLisp(dataAfter.isEnable()); } catch (VppBaseCallException | TimeoutException e) { throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, e); } } LispCustomizer(final FutureJVppCore vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Lisp> id, @Nonnull final Lisp dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Lisp> id, @Nonnull final Lisp dataBefore,
@Nonnull final Lisp dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Lisp> id, @Nonnull final Lisp dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = NullPointerException.class) public void testUpdateCurrentAttributesNullData() throws WriteFailedException { customizer.updateCurrentAttributes(null, null, null, null); }
@Test public void testUpdateCurrentAttributes() throws WriteFailedException { Lisp lisp = new LispBuilder().setEnable(true).build(); whenlispEnableDisableThenSuccess(); customizer.updateCurrentAttributes(null, null, lisp, null); ArgumentCaptor<OneEnableDisable> lispCaptor = ArgumentCaptor.forClass(OneEnableDisable.class); verify(api, times(1)).oneEnableDisable(lispCaptor.capture()); OneEnableDisable request = lispCaptor.getValue(); assertNotNull(request); assertEquals(1, request.isEn); } |
### Question:
LispCustomizer extends FutureJVppCustomizer implements WriterCustomizer<Lisp>, ByteDataTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Lisp> id, @Nonnull final Lisp dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { Preconditions.checkNotNull(dataBefore, "Lisp is null"); try { enableDisableLisp(false); } catch (VppBaseCallException | TimeoutException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } LispCustomizer(final FutureJVppCore vppApi); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Lisp> id, @Nonnull final Lisp dataAfter,
@Nonnull final WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Lisp> id, @Nonnull final Lisp dataBefore,
@Nonnull final Lisp dataAfter, @Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Lisp> id, @Nonnull final Lisp dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test(expected = NullPointerException.class) public void testDeleteCurrentAttributesNullData() throws WriteFailedException { customizer.deleteCurrentAttributes(null, null, null); }
@Test public void testDeleteCurrentAttributes() throws WriteFailedException { Lisp lisp = new LispBuilder().setEnable(true).build(); whenlispEnableDisableThenSuccess(); customizer.deleteCurrentAttributes(null, lisp, null); ArgumentCaptor<OneEnableDisable> lispCaptor = ArgumentCaptor.forClass(OneEnableDisable.class); verify(api, times(1)).oneEnableDisable(lispCaptor.capture()); OneEnableDisable request = lispCaptor.getValue(); assertNotNull(request); assertEquals(0, request.isEn); } |
### Question:
RlocProbeCustomizer extends CheckedLispCustomizer implements WriterCustomizer<RlocProbe>, ByteDataTranslator, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier, @Nonnull RlocProbe rlocProbe, @Nonnull WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledAfter(writeContext); enableDisableRlocProbe(rlocProbe.isEnabled(), instanceIdentifier); } RlocProbeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbe,
@Nonnull WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbeBefore,
@Nonnull RlocProbe rlocProbeAfter,
@Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbe,
@Nonnull WriteContext writeContext); }### Answer:
@Test public void testWriteCurrentAttributes() throws Exception { customizer.writeCurrentAttributes(ID, enabledProbe, writeContext); verifyRequest(true); }
@Test public void testWriteLispDisabled() throws WriteFailedException { mockLispDisabledAfter(); try { customizer.writeCurrentAttributes(EMPTY_ID, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
RlocProbeCustomizer extends CheckedLispCustomizer implements WriterCustomizer<RlocProbe>, ByteDataTranslator, JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier, @Nonnull RlocProbe rlocProbeBefore, @Nonnull RlocProbe rlocProbeAfter, @Nonnull WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledAfter(writeContext); enableDisableRlocProbe(rlocProbeAfter.isEnabled(), instanceIdentifier); } RlocProbeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbe,
@Nonnull WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbeBefore,
@Nonnull RlocProbe rlocProbeAfter,
@Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbe,
@Nonnull WriteContext writeContext); }### Answer:
@Test public void testUpdateCurrentAttributesToDisabled() throws Exception { customizer.updateCurrentAttributes(ID, enabledProbe, disabledProbe, writeContext); verifyRequest(false); }
@Test public void testUpdateCurrentAttributesToEnabled() throws Exception { customizer.updateCurrentAttributes(ID, disabledProbe, enabledProbe, writeContext); verifyRequest(true); }
@Test public void testUpdateLispDisabled() throws WriteFailedException { mockLispDisabledAfter(); try { customizer.updateCurrentAttributes(EMPTY_ID, EMPTY_DATA,EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
RlocProbeCustomizer extends CheckedLispCustomizer implements WriterCustomizer<RlocProbe>, ByteDataTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier, @Nonnull RlocProbe rlocProbe, @Nonnull WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledBefore(writeContext); enableDisableRlocProbe(false, instanceIdentifier); } RlocProbeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbe,
@Nonnull WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbeBefore,
@Nonnull RlocProbe rlocProbeAfter,
@Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbe,
@Nonnull WriteContext writeContext); }### Answer:
@Test public void testDeleteCurrentAttributes() throws Exception { customizer.deleteCurrentAttributes(ID, disabledProbe, writeContext); verifyRequest(false); }
@Test public void testDeleteLispDisabled() throws WriteFailedException { mockLispDisabledBefore(); try { customizer.deleteCurrentAttributes(EMPTY_ID, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
MapServerCustomizer extends CheckedLispCustomizer implements ListWriterCustomizer<MapServer, MapServerKey>, AddressTranslator,
JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, @Nonnull MapServer mapServer, @Nonnull WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledAfter(writeContext); addDelMapServer(true, instanceIdentifier, mapServer); } MapServerCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull MapServer mapServer,
@Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, @Nonnull MapServer mapServer, @Nonnull WriteContext writeContext); }### Answer:
@Test public void writeCurrentAttributes() throws Exception { customizer.writeCurrentAttributes(ID, data, writeContext); verifyRequest(true); }
@Test public void testWriteLispDisabled() throws WriteFailedException { mockLispDisabledAfter(); try { customizer.writeCurrentAttributes(EMPTY_ID, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
MapServerCustomizer extends CheckedLispCustomizer implements ListWriterCustomizer<MapServer, MapServerKey>, AddressTranslator,
JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, @Nonnull MapServer mapServer, @Nonnull WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledBefore(writeContext); addDelMapServer(false, instanceIdentifier, mapServer); } MapServerCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull MapServer mapServer,
@Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, @Nonnull MapServer mapServer, @Nonnull WriteContext writeContext); }### Answer:
@Test public void deleteCurrentAttributes() throws Exception { customizer.deleteCurrentAttributes(ID, data, writeContext); verifyRequest(false); }
@Test public void testDeleteLispDisabled() throws WriteFailedException { mockLispDisabledBefore(); try { customizer.deleteCurrentAttributes(EMPTY_ID, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
PetrCfgCustomizer extends CheckedLispCustomizer implements WriterCustomizer<PetrCfg>, AddressTranslator, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, @Nonnull PetrCfg petrCfg, @Nonnull WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledAfter(writeContext); enablePetrCfg(instanceIdentifier, petrCfg); } PetrCfgCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
@Nonnull PetrCfg petrCfg,
@Nonnull WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
@Nonnull PetrCfg petrCfgBefore,
@Nonnull PetrCfg petrCfgAfter,
@Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, @Nonnull PetrCfg petrCfg, @Nonnull WriteContext writeContext); }### Answer:
@Test public void testWriteCurrentAttributes() throws Exception { customizer.writeCurrentAttributes(ID, enabledCfg, writeContext); verifyEnabledInvoked(); }
@Test public void testWriteLispDisabled() throws WriteFailedException { mockLispDisabledAfter(); try { customizer.writeCurrentAttributes(EMPTY_ID, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
PetrCfgCustomizer extends CheckedLispCustomizer implements WriterCustomizer<PetrCfg>, AddressTranslator, JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, @Nonnull PetrCfg petrCfgBefore, @Nonnull PetrCfg petrCfgAfter, @Nonnull WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledAfter(writeContext); if (petrCfgAfter.getPetrAddress() != null) { enablePetrCfg(instanceIdentifier, petrCfgAfter); } else { disablePetrCfg(instanceIdentifier); } } PetrCfgCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
@Nonnull PetrCfg petrCfg,
@Nonnull WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
@Nonnull PetrCfg petrCfgBefore,
@Nonnull PetrCfg petrCfgAfter,
@Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, @Nonnull PetrCfg petrCfg, @Nonnull WriteContext writeContext); }### Answer:
@Test public void testUpdateCurrentAttributesToEnabled() throws Exception { customizer.updateCurrentAttributes(ID, disabledCfg, enabledCfg, writeContext); verifyEnabledInvoked(); }
@Test public void testUpdateCurrentAttributesToDisabled() throws Exception { customizer.updateCurrentAttributes(ID, enabledCfg, disabledCfg, writeContext); verifyDisabledInvoked(); }
@Test public void testUpdateLispDisabled() throws WriteFailedException { mockLispDisabledAfter(); try { customizer.updateCurrentAttributes(EMPTY_ID, EMPTY_DATA,EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
PetrCfgCustomizer extends CheckedLispCustomizer implements WriterCustomizer<PetrCfg>, AddressTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, @Nonnull PetrCfg petrCfg, @Nonnull WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledBefore(writeContext); disablePetrCfg(instanceIdentifier); } PetrCfgCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
@Nonnull PetrCfg petrCfg,
@Nonnull WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
@Nonnull PetrCfg petrCfgBefore,
@Nonnull PetrCfg petrCfgAfter,
@Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, @Nonnull PetrCfg petrCfg, @Nonnull WriteContext writeContext); }### Answer:
@Test public void testDeleteCurrentAttributes() throws Exception { customizer.deleteCurrentAttributes(ID, disabledCfg, writeContext); verifyDisabledInvoked(); }
@Test public void testDeleteLispDisabled() throws WriteFailedException { mockLispDisabledBefore(); try { customizer.deleteCurrentAttributes(EMPTY_ID, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
RemoteMappingCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<RemoteMapping, RemoteMappingKey>, EidTranslator,
AddressTranslator, JvppReplyConsumer, MappingProducer { @Override public void updateCurrentAttributes(InstanceIdentifier<RemoteMapping> id, RemoteMapping dataBefore, RemoteMapping dataAfter, WriteContext writeContext) throws WriteFailedException { checkIgnoredSubnetUpdate(dataBefore.getEid().getAddress(), dataAfter.getEid().getAddress(), LOG); } RemoteMappingCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final EidMappingContext remoteMappingContext); @Override void writeCurrentAttributes(InstanceIdentifier<RemoteMapping> id, RemoteMapping dataAfter,
WriteContext writeContext); @Override void updateCurrentAttributes(InstanceIdentifier<RemoteMapping> id, RemoteMapping dataBefore,
RemoteMapping dataAfter, WriteContext writeContext); @Override void deleteCurrentAttributes(InstanceIdentifier<RemoteMapping> id, RemoteMapping dataBefore,
WriteContext writeContext); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testUpdateCurrentAttributesFail() throws WriteFailedException { customizer.updateCurrentAttributes(null, failUpdateBefore, failUpdateAfter, writeContext); }
@Test public void testUpdateCurrentAttributesIgnore() throws WriteFailedException { customizer.updateCurrentAttributes(null, ignoreUpdateBefore, ignoreUpdateAfter, writeContext); verifyZeroInteractions(api); } |
### Question:
FibTableCustomizer implements InitializingListReaderCustomizer<Table, TableKey, TableBuilder>, ByteDataTranslator { @Nonnull @Override public Initialized<Table> init(@Nonnull final InstanceIdentifier<Table> id, @Nonnull final Table readValue, @Nonnull final ReadContext ctx) { return Initialized.create(id, readValue); } FibTableCustomizer(final DumpCacheManager<IpFibDetailsReplyDump, Void> ipv4DumpManager,
final DumpCacheManager<Ip6FibDetailsReplyDump, Void> ipv6DumpManager); @Nonnull @Override List<TableKey> getAllIds(@Nonnull final InstanceIdentifier<Table> instanceIdentifier,
@Nonnull final ReadContext readContext); @Override void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Table> list); @Nonnull @Override TableBuilder getBuilder(@Nonnull final InstanceIdentifier<Table> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<Table> instanceIdentifier,
@Nonnull final TableBuilder builder, @Nonnull final ReadContext readContext); @Nonnull @Override Initialized<Table> init(@Nonnull final InstanceIdentifier<Table> id,
@Nonnull final Table readValue,
@Nonnull final ReadContext ctx); }### Answer:
@Test public void testInit() { final Table data = new TableBuilder().build(); invokeInitTest(TABLE_V4_ID, data, TABLE_V4_ID, data); } |
### Question:
MapRegisterCustomizer extends CheckedLispCustomizer implements WriterCustomizer<MapRegister>, ByteDataTranslator, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier, @Nonnull MapRegister mapRegister, @Nonnull WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledAfter(writeContext); enableDisableMapRegister(mapRegister, instanceIdentifier); } MapRegisterCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull MapRegister mapRegister,
@Nonnull WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull MapRegister mapRegisterBefore,
@Nonnull MapRegister mapRegisterAfter, @Nonnull
WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull MapRegister mapRegister,
@Nonnull WriteContext writeContext); }### Answer:
@Test public void writeCurrentAttributes() throws Exception { customizer.writeCurrentAttributes(ID, enabledRegister, writeContext); verifyRequest(true, 7, 4); }
@Test public void testWriteLispDisabled() throws WriteFailedException { mockLispDisabledAfter(); try { customizer.writeCurrentAttributes(EMPTY_ID, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
MapRegisterCustomizer extends CheckedLispCustomizer implements WriterCustomizer<MapRegister>, ByteDataTranslator, JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier, @Nonnull MapRegister mapRegisterBefore, @Nonnull MapRegister mapRegisterAfter, @Nonnull WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledAfter(writeContext); enableDisableMapRegister(mapRegisterAfter, instanceIdentifier); } MapRegisterCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull MapRegister mapRegister,
@Nonnull WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull MapRegister mapRegisterBefore,
@Nonnull MapRegister mapRegisterAfter, @Nonnull
WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull MapRegister mapRegister,
@Nonnull WriteContext writeContext); }### Answer:
@Test public void updateCurrentAttributesToDisabled() throws Exception { customizer.updateCurrentAttributes(ID, enabledRegister, disabledRegister, writeContext); verifyRequest(false, 7, 4); }
@Test public void updateCurrentAttributesToEnabled() throws Exception { customizer.updateCurrentAttributes(ID, disabledRegister, enabledRegister, writeContext); verifyRequest(true, 7, 4); }
@Test public void testUpdateLispDisabled() throws WriteFailedException { mockLispDisabledAfter(); try { customizer.updateCurrentAttributes(EMPTY_ID, EMPTY_DATA, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
MapRegisterCustomizer extends CheckedLispCustomizer implements WriterCustomizer<MapRegister>, ByteDataTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier, @Nonnull MapRegister mapRegister, @Nonnull WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledBefore(writeContext); enableDisableMapRegister(mapRegister, instanceIdentifier); } MapRegisterCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull MapRegister mapRegister,
@Nonnull WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull MapRegister mapRegisterBefore,
@Nonnull MapRegister mapRegisterAfter, @Nonnull
WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull MapRegister mapRegister,
@Nonnull WriteContext writeContext); }### Answer:
@Test public void deleteCurrentAttributes() throws Exception { customizer.deleteCurrentAttributes(ID, disabledRegister, writeContext); verifyRequest(false, 0, 0); }
@Test public void testDeleteLispDisabled() throws WriteFailedException { mockLispDisabledBefore(); try { customizer.deleteCurrentAttributes(EMPTY_ID, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
VniTableCustomizer extends CheckedLispCustomizer implements ListWriterCustomizer<VniTable, VniTableKey> { @Override public void writeCurrentAttributes(InstanceIdentifier<VniTable> id, VniTable dataAfter, WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledAfter(writeContext); checkAtLeastOnChildExists(id, writeContext, false); } VniTableCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(InstanceIdentifier<VniTable> id, VniTable dataAfter, WriteContext writeContext); @Override void deleteCurrentAttributes(InstanceIdentifier<VniTable> id, VniTable dataBefore, WriteContext writeContext); }### Answer:
@Test public void testWriteSuccessfull() { whenReadAfterReturnValid(); try { customizer.writeCurrentAttributes(validId, validData, writeContext); } catch (Exception e) { fail("Test should pass without exception"); } }
@Test(expected = IllegalStateException.class) public void testWriteFailed() throws WriteFailedException { whenReadAfterReturnInvalid(); customizer.writeCurrentAttributes(validId, validData, writeContext); }
@Test public void testWriteLispDisabled() throws WriteFailedException { mockLispDisabledAfter(); try { customizer.writeCurrentAttributes(EMPTY_ID, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
VniTableCustomizer extends CheckedLispCustomizer implements ListWriterCustomizer<VniTable, VniTableKey> { @Override public void deleteCurrentAttributes(InstanceIdentifier<VniTable> id, VniTable dataBefore, WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledBefore(writeContext); checkAtLeastOnChildExists(id, writeContext, true); } VniTableCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(InstanceIdentifier<VniTable> id, VniTable dataAfter, WriteContext writeContext); @Override void deleteCurrentAttributes(InstanceIdentifier<VniTable> id, VniTable dataBefore, WriteContext writeContext); }### Answer:
@Test public void testDeleteSuccessfull() { whenReadBeforeReturnValid(); try { customizer.deleteCurrentAttributes(validId, validData, writeContext); } catch (Exception e) { fail("Test should pass without exception"); } }
@Test(expected = IllegalStateException.class) public void testDeleteFailed() throws WriteFailedException { whenReadBeforeReturnInvalid(); customizer.deleteCurrentAttributes(validId, validData, writeContext); }
@Test public void testDeleteLispDisabled() throws WriteFailedException { mockLispDisabledBefore(); try { customizer.deleteCurrentAttributes(EMPTY_ID, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
ItrRemoteLocatorSetCustomizer extends CheckedLispCustomizer implements
WriterCustomizer<ItrRemoteLocatorSet>, ByteDataTranslator, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id, @Nonnull final ItrRemoteLocatorSet dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { try { addDelItrRemoteLocatorSet(true, dataAfter, writeContext); } catch (TimeoutException | VppBaseCallException e) { throw new WriteFailedException.CreateFailedException(id, dataAfter, e); } } ItrRemoteLocatorSetCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id,
@Nonnull final ItrRemoteLocatorSet dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id,
@Nonnull final ItrRemoteLocatorSet dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void writeCurrentAttributesSuccess() throws Exception { onWriteSuccess(); customizer.writeCurrentAttributes(validId, validData, writeContext); verifyWriteInvoked(true, VALID_NAME); }
@Test public void writeCurrentAttributesFailed() { onWriteThrow(); try { customizer.writeCurrentAttributes(validId, validData, writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppCallbackException); verifyWriteInvoked(true, VALID_NAME); return; } fail("Test should have thrown exception"); }
@Test public void deleteCurrentAttributesFailed() throws Exception { onWriteThrow(); try { customizer.writeCurrentAttributes(validId, validData, writeContext); } catch (WriteFailedException e) { assertTrue(e.getCause() instanceof VppCallbackException); verifyWriteInvoked(true, VALID_NAME); return; } fail("Test should have thrown exception"); } |
### Question:
ItrRemoteLocatorSetCustomizer extends CheckedLispCustomizer implements
WriterCustomizer<ItrRemoteLocatorSet>, ByteDataTranslator, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id, @Nonnull final ItrRemoteLocatorSet dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { try { addDelItrRemoteLocatorSet(false, dataBefore, writeContext); } catch (TimeoutException | VppBaseCallException e) { throw new WriteFailedException.DeleteFailedException(id, e); } } ItrRemoteLocatorSetCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id,
@Nonnull final ItrRemoteLocatorSet dataAfter,
@Nonnull final WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id,
@Nonnull final ItrRemoteLocatorSet dataBefore,
@Nonnull final WriteContext writeContext); }### Answer:
@Test public void deleteCurrentAttributesSuccess() throws Exception { onWriteSuccess(); customizer.deleteCurrentAttributes(validId, validData, writeContext); verifyWriteInvoked(false, VALID_NAME); } |
### Question:
LocalMappingCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<LocalMapping, LocalMappingKey>, ByteDataTranslator, EidTranslator,
JvppReplyConsumer, MappingProducer { @Override public void updateCurrentAttributes(InstanceIdentifier<LocalMapping> id, LocalMapping dataBefore, LocalMapping dataAfter, WriteContext writeContext) throws WriteFailedException { checkIgnoredSubnetUpdate(dataBefore.getEid().getAddress(), dataAfter.getEid().getAddress(), LOG); } LocalMappingCustomizer(@Nonnull FutureJVppCore futureJvpp, @Nonnull EidMappingContext localMappingsContext); @Override void writeCurrentAttributes(InstanceIdentifier<LocalMapping> id, LocalMapping dataAfter,
WriteContext writeContext); @Override void updateCurrentAttributes(InstanceIdentifier<LocalMapping> id, LocalMapping dataBefore,
LocalMapping dataAfter, WriteContext writeContext); @Override void deleteCurrentAttributes(InstanceIdentifier<LocalMapping> id, LocalMapping dataBefore,
WriteContext writeContext); }### Answer:
@Test(expected = UnsupportedOperationException.class) public void testUpdateCurrentAttributesFail() throws WriteFailedException { customizer.updateCurrentAttributes(null, failUpdateBefore, failUpdateAfter, writeContext); }
@Test public void testUpdateCurrentAttributesIgnore() throws WriteFailedException { customizer.updateCurrentAttributes(null, ignoreUpdateBefore, ignoreUpdateAfter, writeContext); verifyZeroInteractions(api); } |
### Question:
MapRequestModeCustomizer extends CheckedLispCustomizer implements WriterCustomizer<MapRequestMode>, JvppReplyConsumer { @Override public void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier, @Nonnull MapRequestMode mapRequestMode, @Nonnull WriteContext writeContext) throws WriteFailedException { LOG.debug("Setting map request mode to [{}]", mapRequestMode); lispStateCheckService.checkLispEnabledAfter(writeContext); getReplyForWrite(mapRequestModeRequestFuture(mapRequestMode), instanceIdentifier); } MapRequestModeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestMode,
@Nonnull WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestModeBefore,
@Nonnull MapRequestMode mapRequestModeAfter, @Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestMode,
@Nonnull WriteContext writeContext); }### Answer:
@Test public void writeCurrentAttributes() throws Exception { customizer.writeCurrentAttributes(ID, sourceDestinationMode, writeContext); verifyModeRequest(SourceDestination); }
@Test public void testWriteLispDisabled() throws WriteFailedException { mockLispDisabledAfter(); try { customizer.writeCurrentAttributes(EMPTY_ID, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
MapRequestModeCustomizer extends CheckedLispCustomizer implements WriterCustomizer<MapRequestMode>, JvppReplyConsumer { @Override public void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier, @Nonnull MapRequestMode mapRequestModeBefore, @Nonnull MapRequestMode mapRequestModeAfter, @Nonnull WriteContext writeContext) throws WriteFailedException { lispStateCheckService.checkLispEnabledAfter(writeContext); LOG.debug("Setting map request mode to [{}]", mapRequestModeAfter); getReplyForUpdate(mapRequestModeRequestFuture(mapRequestModeAfter), instanceIdentifier, mapRequestModeBefore, mapRequestModeAfter); } MapRequestModeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestMode,
@Nonnull WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestModeBefore,
@Nonnull MapRequestMode mapRequestModeAfter, @Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestMode,
@Nonnull WriteContext writeContext); }### Answer:
@Test public void updateCurrentAttributes() throws Exception { customizer.updateCurrentAttributes(ID, sourceDestinationMode, destinationOnlyMode, writeContext); verifyModeRequest(DestinationOnly); }
@Test public void testUpdateLispDisabled() throws WriteFailedException { mockLispDisabledAfter(); try { customizer.updateCurrentAttributes(EMPTY_ID, EMPTY_DATA, EMPTY_DATA, writeContext); } catch (IllegalArgumentException e) { verifyZeroInteractions(api); return; } fail("Test should have thrown IllegalArgumentException"); } |
### Question:
MapRequestModeCustomizer extends CheckedLispCustomizer implements WriterCustomizer<MapRequestMode>, JvppReplyConsumer { @Override public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier, @Nonnull MapRequestMode mapRequestMode, @Nonnull WriteContext writeContext) throws WriteFailedException { LOG.debug("Setting map request mode to default[{}]", DEFAULT_MODE); lispStateCheckService.checkLispEnabledBefore(writeContext); getReplyForWrite(mapRequestModeRequestFuture(DEFAULT_MODE), instanceIdentifier); } MapRequestModeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Override void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestMode,
@Nonnull WriteContext writeContext); @Override void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestModeBefore,
@Nonnull MapRequestMode mapRequestModeAfter, @Nonnull WriteContext writeContext); @Override void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestMode,
@Nonnull WriteContext writeContext); }### Answer:
@Test public void deleteCurrentAttributes() throws Exception { customizer.deleteCurrentAttributes(ID, sourceDestinationMode, writeContext); verifyModeRequest(DestinationOnly); } |
### Question:
LispStateCheckServiceImpl implements LispStateCheckService, JvppReplyConsumer, ByteDataTranslator { @Override public void checkLispEnabledBefore(@Nonnull final WriteContext ctx) { checkState(ctx.readBefore(InstanceIdentifier.create(Lisp.class)) .orElse(STATIC_LISP_INSTANCE).isEnable(), "Lisp feature not enabled"); } @Inject LispStateCheckServiceImpl(@Nonnull final FutureJVppCore vppApi); @Override void checkLispEnabledBefore(@Nonnull final WriteContext ctx); @Override void checkLispEnabledAfter(@Nonnull final WriteContext ctx); @Override boolean lispEnabled(@Nonnull final ReadContext ctx); }### Answer:
@Test(expected = IllegalStateException.class) public void testCheckLispEnabledBeforeNoConfig() throws Exception { when(writeContext.readBefore(InstanceIdentifier.create(Lisp.class))).thenReturn(Optional.empty()); impl.checkLispEnabledBefore(writeContext); }
@Test(expected = IllegalStateException.class) public void testCheckLispEnabledBeforeDisabledConfig() throws Exception { when(writeContext.readBefore(InstanceIdentifier.create(Lisp.class))) .thenReturn(Optional.of(new LispBuilder().setEnable(false).build())); impl.checkLispEnabledBefore(writeContext); }
@Test public void testCheckLispEnabledBeforeEnabledConfig() throws Exception { when(writeContext.readBefore(InstanceIdentifier.create(Lisp.class))) .thenReturn(Optional.of(new LispBuilder().setEnable(true).build())); impl.checkLispEnabledBefore(writeContext); } |
### Question:
LispStateCheckServiceImpl implements LispStateCheckService, JvppReplyConsumer, ByteDataTranslator { @Override public void checkLispEnabledAfter(@Nonnull final WriteContext ctx) { checkState(ctx.readAfter(InstanceIdentifier.create(Lisp.class)) .orElse(STATIC_LISP_INSTANCE).isEnable(), "Lisp feature not enabled"); } @Inject LispStateCheckServiceImpl(@Nonnull final FutureJVppCore vppApi); @Override void checkLispEnabledBefore(@Nonnull final WriteContext ctx); @Override void checkLispEnabledAfter(@Nonnull final WriteContext ctx); @Override boolean lispEnabled(@Nonnull final ReadContext ctx); }### Answer:
@Test(expected = IllegalStateException.class) public void testCheckLispEnabledAfterNoConfig() throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Lisp.class))).thenReturn(Optional.empty()); impl.checkLispEnabledAfter(writeContext); }
@Test(expected = IllegalStateException.class) public void testCheckLispEnabledAfterDisabledConfig() throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Lisp.class))) .thenReturn(Optional.of(new LispBuilder().setEnable(false).build())); impl.checkLispEnabledAfter(writeContext); }
@Test public void testCheckLispEnabledAfterEnabledConfig() throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Lisp.class))) .thenReturn(Optional.of(new LispBuilder().setEnable(true).build())); impl.checkLispEnabledAfter(writeContext); } |
### Question:
LispStateCheckServiceImpl implements LispStateCheckService, JvppReplyConsumer, ByteDataTranslator { @Override public boolean lispEnabled(@Nonnull final ReadContext ctx) { try { return byteToBoolean(dumpManager.getDump(IDENTIFIER, ctx.getModificationCache()) .orElse(DEFAULT_REPLY).featureStatus); } catch (ReadFailedException e) { throw new IllegalStateException("Unable to read Lisp Feature status", e); } } @Inject LispStateCheckServiceImpl(@Nonnull final FutureJVppCore vppApi); @Override void checkLispEnabledBefore(@Nonnull final WriteContext ctx); @Override void checkLispEnabledAfter(@Nonnull final WriteContext ctx); @Override boolean lispEnabled(@Nonnull final ReadContext ctx); }### Answer:
@Test public void testLispEnabledDisabledDump() throws Exception { when(vppApi.showOneStatus(any())).thenReturn(future(new ShowOneStatusReply())); assertFalse(impl.lispEnabled(readContext)); }
@Test public void testLispEnabledEnabledDump() throws Exception { final ShowOneStatusReply reply = new ShowOneStatusReply(); reply.featureStatus = 1; when(vppApi.showOneStatus(any())).thenReturn(future(reply)); assertTrue(impl.lispEnabled(readContext)); } |
### Question:
PitrCfgCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<PitrCfg, PitrCfgBuilder>, ByteDataTranslator, JvppReplyConsumer,
LispInitPathsMapper { @Override public void readCurrentAttributes(InstanceIdentifier<PitrCfg> id, PitrCfgBuilder builder, ReadContext ctx) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(ctx)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", id); return; } LOG.debug("Reading status for Lisp Pitr node {}", id); ShowOnePitrReply reply; try { reply = getPitrStatus(); } catch (TimeoutException | VppBaseCallException e) { throw new ReadFailedException(id, e); } builder.setLocatorSet(toString(reply.locatorSetName)); LOG.debug("Reading status for Lisp Pitr node {} successfull", id); } PitrCfgCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Override PitrCfgBuilder getBuilder(InstanceIdentifier<PitrCfg> id); @Override void readCurrentAttributes(InstanceIdentifier<PitrCfg> id, PitrCfgBuilder builder, ReadContext ctx); @Override void merge(Builder<? extends DataObject> parentBuilder, PitrCfg readValue); ShowOnePitrReply getPitrStatus(); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<PitrCfg> instanceIdentifier, @Nonnull PitrCfg pitrCfg, @Nonnull ReadContext readContext); }### Answer:
@Test public void readCurrentAttributes() throws Exception { PitrCfgBuilder builder = new PitrCfgBuilder(); getCustomizer().readCurrentAttributes(emptyId, builder, ctx); final PitrCfg cfg = builder.build(); assertNotNull(cfg); assertEquals("loc-set", cfg.getLocatorSet()); } |
### Question:
LocatorSetCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<LocatorSet, LocatorSetKey, LocatorSetBuilder>, ByteDataTranslator,
LocatorSetReader, LispInitPathsMapper { @Override public List<LocatorSetKey> getAllIds(InstanceIdentifier<LocatorSet> id, ReadContext context) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(context)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", id); return Collections.emptyList(); } LOG.debug("Dumping Locator Set {}", id); final Optional<OneLocatorSetDetailsReplyDump> dumpOptional = dumpManager.getDump(id, context.getModificationCache()); if (!dumpOptional.isPresent() || dumpOptional.get().oneLocatorSetDetails.isEmpty()) { return Collections.emptyList(); } return dumpOptional.get().oneLocatorSetDetails.stream() .map(set -> new LocatorSetKey(toString(set.lsName))) .collect(Collectors.toList()); } LocatorSetCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override LocatorSetBuilder getBuilder(@Nonnull InstanceIdentifier<LocatorSet> instanceIdentifier); @Override void readCurrentAttributes(InstanceIdentifier<LocatorSet> id, LocatorSetBuilder builder, ReadContext ctx); @Override List<LocatorSetKey> getAllIds(InstanceIdentifier<LocatorSet> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<LocatorSet> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<LocatorSet> instanceIdentifier, @Nonnull LocatorSet locatorSet, @Nonnull ReadContext readContext); }### Answer:
@Test public void getAllIds() throws Exception { final List<LocatorSetKey> keys = getCustomizer().getAllIds(emptyId, ctx); assertEquals(1, keys.size()); assertEquals("loc-set", keys.get(0).getName()); } |
### Question:
LocatorSetCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<LocatorSet, LocatorSetKey, LocatorSetBuilder>, ByteDataTranslator,
LocatorSetReader, LispInitPathsMapper { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<LocatorSet> instanceIdentifier, @Nonnull LocatorSet locatorSet, @Nonnull ReadContext readContext) { return Initialized.create(lispLocatorSetPath(instanceIdentifier), locatorSet); } LocatorSetCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override LocatorSetBuilder getBuilder(@Nonnull InstanceIdentifier<LocatorSet> instanceIdentifier); @Override void readCurrentAttributes(InstanceIdentifier<LocatorSet> id, LocatorSetBuilder builder, ReadContext ctx); @Override List<LocatorSetKey> getAllIds(InstanceIdentifier<LocatorSet> id, ReadContext context); @Override void merge(Builder<? extends DataObject> builder, List<LocatorSet> readData); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<LocatorSet> instanceIdentifier, @Nonnull LocatorSet locatorSet, @Nonnull ReadContext readContext); }### Answer:
@Test public void testInit(@InjectTestData(resourcePath = "/locator-set.json", id = LOC_1_PATH) LocatorSet locatorSet) { final LocatorSetKey loc1Key = new LocatorSetKey("loc1"); final KeyedInstanceIdentifier<LocatorSet, LocatorSetKey> operationalPath = InstanceIdentifier.create(LispState.class) .child(LispFeatureData.class) .child(LocatorSets.class) .child(LocatorSet.class, loc1Key); final KeyedInstanceIdentifier<LocatorSet, LocatorSetKey> configPath = InstanceIdentifier.create(Lisp.class) .child(LispFeatureData.class) .child(LocatorSets.class) .child(LocatorSet.class, loc1Key); invokeInitTest(operationalPath, locatorSet, configPath, locatorSet); } |
### Question:
VrfSubtableCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<VrfSubtable, VrfSubtableBuilder>, SubtableReader, LispInitPathsMapper { @Nonnull @Override public VrfSubtableBuilder getBuilder(@Nonnull final InstanceIdentifier<VrfSubtable> id) { return new VrfSubtableBuilder(); } VrfSubtableCustomizer(@Nonnull final FutureJVppCore futureJvpp); @Nonnull @Override VrfSubtableBuilder getBuilder(@Nonnull final InstanceIdentifier<VrfSubtable> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id,
@Nonnull final VrfSubtableBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final VrfSubtable readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<VrfSubtable> instanceIdentifier, @Nonnull VrfSubtable vrfSubtable, @Nonnull ReadContext readContext); }### Answer:
@Override @Test public void testGetBuilder() { final VrfSubtableBuilder builder = customizer.getBuilder(validId); assertNotNull(builder); assertNull(builder.getLocalMappings()); assertNull(builder.getRemoteMappings()); assertNull(builder.getTableId()); } |
### Question:
VrfSubtableCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<VrfSubtable, VrfSubtableBuilder>, SubtableReader, LispInitPathsMapper { @Override public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final VrfSubtable readValue) { ((VniTableBuilder) parentBuilder).setVrfSubtable(readValue); } VrfSubtableCustomizer(@Nonnull final FutureJVppCore futureJvpp); @Nonnull @Override VrfSubtableBuilder getBuilder(@Nonnull final InstanceIdentifier<VrfSubtable> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<VrfSubtable> id,
@Nonnull final VrfSubtableBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final VrfSubtable readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<VrfSubtable> instanceIdentifier, @Nonnull VrfSubtable vrfSubtable, @Nonnull ReadContext readContext); }### Answer:
@Override @Test public void testMerge() { VniTableBuilder parentBuilder = new VniTableBuilder(); VrfSubtable subtable = new VrfSubtableBuilder().build(); customizer.merge(parentBuilder, subtable); assertEquals(subtable, parentBuilder.getVrfSubtable()); } |
### Question:
LispStateCustomizer extends FutureJVppCustomizer implements InitializingReaderCustomizer<LispState, LispStateBuilder>, JvppReplyConsumer, ByteDataTranslator,
LocatorSetReader { @Override public void readCurrentAttributes(InstanceIdentifier<LispState> id, LispStateBuilder builder, ReadContext ctx) throws ReadFailedException { ShowOneStatusReply reply; try { reply = getReply(getFutureJVpp().showOneStatus(new ShowOneStatus()).toCompletableFuture()); } catch (TimeoutException | VppBaseCallException e) { throw new ReadFailedException(id, e); } builder.setEnable(byteToBoolean(reply.featureStatus)); } LispStateCustomizer(@Nonnull final FutureJVppCore futureJvpp,
@Nonnull final NamingContext locatorSetContext); @Override LispStateBuilder getBuilder(InstanceIdentifier<LispState> id); @Override void readCurrentAttributes(InstanceIdentifier<LispState> id, LispStateBuilder builder, ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final LispState readValue); @Override Initialized<Lisp> init(
@Nonnull final InstanceIdentifier<LispState> id, @Nonnull final LispState readValue,
@Nonnull final ReadContext ctx); }### Answer:
@Test public void testReadCurrentAttributes() throws ReadFailedException { LispStateBuilder builder = new LispStateBuilder(); getCustomizer().readCurrentAttributes(identifier, builder, ctx); assertEquals(true, builder.build().isEnable()); } |
### Question:
RlocProbeCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<RlocProbe, RlocProbeBuilder>, JvppReplyConsumer, ByteDataTranslator,
LispInitPathsMapper { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier, @Nonnull RlocProbe rlocProbe, @Nonnull ReadContext readContext) { return Initialized.create(lispFeaturesBasePath().child(RlocProbe.class), rlocProbe); } RlocProbeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override RlocProbeBuilder getBuilder(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbeBuilder rlocProbeBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull RlocProbe rlocProbe); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbe,
@Nonnull ReadContext readContext); }### Answer:
@Test public void testInit() { final RlocProbe data = new RlocProbeBuilder().setEnabled(true).build(); invokeInitTest(STATE_IID, data, CONFIG_IID, data); } |
### Question:
RlocProbeCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<RlocProbe, RlocProbeBuilder>, JvppReplyConsumer, ByteDataTranslator,
LispInitPathsMapper { @Override public void readCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier, @Nonnull RlocProbeBuilder rlocProbeBuilder, @Nonnull ReadContext readContext) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(readContext)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", instanceIdentifier); return; } final ShowOneRlocProbeStateReply read = getReplyForRead(getFutureJVpp() .showOneRlocProbeState(new ShowOneRlocProbeState()).toCompletableFuture(), instanceIdentifier); if (read != null) { rlocProbeBuilder.setEnabled(byteToBoolean(read.isEnabled)); } } RlocProbeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override RlocProbeBuilder getBuilder(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbeBuilder rlocProbeBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull RlocProbe rlocProbe); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
@Nonnull RlocProbe rlocProbe,
@Nonnull ReadContext readContext); }### Answer:
@Test public void testReadCurrentAttributes() throws Exception { final RlocProbeBuilder builder = new RlocProbeBuilder(); getCustomizer().readCurrentAttributes(CONFIG_IID, builder, ctx); assertTrue(builder.isEnabled()); } |
### Question:
MapServerCustomizer extends CheckedLispCustomizer implements InitializingListReaderCustomizer<MapServer, MapServerKey, MapServerBuilder>, JvppReplyConsumer,
AddressTranslator { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, @Nonnull MapServer mapServer, @Nonnull ReadContext readContext) { final InstanceIdentifier<MapServer> configId = InstanceIdentifier.create(Lisp.class) .child(LispFeatureData.class) .child(MapServers.class) .child(MapServer.class, instanceIdentifier.firstKeyOf(MapServer.class)); return Initialized.create(configId, mapServer); } MapServerCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull MapServer mapServer,
@Nonnull ReadContext readContext); @Nonnull @Override List<MapServerKey> getAllIds(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<MapServer> list); @Nonnull @Override MapServerBuilder getBuilder(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
@Nonnull MapServerBuilder mapServerBuilder, @Nonnull ReadContext readContext); }### Answer:
@Test public void testInit() { final MapServer data = new MapServerBuilder().setIpAddress( new IpAddress(new Ipv4Address("192.168.2.1"))).build(); invokeInitTest(STATE_IID, data, CONFIG_IID, data); } |
### Question:
PetrCfgCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<PetrCfg, PetrCfgBuilder>, JvppReplyConsumer,
AddressTranslator, LispInitPathsMapper { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, @Nonnull PetrCfg petrCfg, @Nonnull ReadContext readContext) { return Initialized.create(lispFeaturesBasePath().child(PetrCfg.class), petrCfg); } PetrCfgCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
@Nonnull PetrCfg petrCfg,
@Nonnull ReadContext readContext); @Nonnull @Override PetrCfgBuilder getBuilder(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
@Nonnull PetrCfgBuilder petrCfgBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull PetrCfg petrCfg); }### Answer:
@Test public void testInit() { final PetrCfg data = new PetrCfgBuilder().setPetrAddress( new IpAddress(new Ipv4Address("192.168.2.1"))).build(); invokeInitTest(STATE_IID, data, CONFIG_IID, data); } |
### Question:
MapRegisterCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<MapRegister, MapRegisterBuilder>, ByteDataTranslator,
JvppReplyConsumer, LispInitPathsMapper { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<MapRegister> instanceIdentifier, @Nonnull final MapRegister mapRegister, @Nonnull final ReadContext readContext) { return Initialized.create(lispFeaturesBasePath().child(MapRegister.class), mapRegister); } MapRegisterCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override MapRegisterBuilder getBuilder(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull MapRegisterBuilder mapRegisterBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull MapRegister mapRegister); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<MapRegister> instanceIdentifier,
@Nonnull final MapRegister mapRegister,
@Nonnull final ReadContext readContext); }### Answer:
@Test public void testInit() { final MapRegister data = new MapRegisterBuilder().setEnabled(true).build(); invokeInitTest(STATE_IID, data, CONFIG_IID, data); } |
### Question:
ItrRemoteLocatorSetCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<ItrRemoteLocatorSet, ItrRemoteLocatorSetBuilder>, ByteDataTranslator,
JvppReplyConsumer, LispInitPathsMapper { @Nonnull @Override public ItrRemoteLocatorSetBuilder getBuilder(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id) { return new ItrRemoteLocatorSetBuilder(); } ItrRemoteLocatorSetCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override ItrRemoteLocatorSetBuilder getBuilder(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id,
@Nonnull final ItrRemoteLocatorSetBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final ItrRemoteLocatorSet readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<ItrRemoteLocatorSet> instanceIdentifier, @Nonnull ItrRemoteLocatorSet itrRemoteLocatorSet, @Nonnull ReadContext readContext); }### Answer:
@Test public void getBuilder() throws Exception { final ItrRemoteLocatorSetBuilder itrRemoteLocatorSetBuilder = getCustomizer().getBuilder(validId); assertNotNull(itrRemoteLocatorSetBuilder); assertNull(itrRemoteLocatorSetBuilder.getRemoteLocatorSetName()); } |
### Question:
ItrRemoteLocatorSetCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<ItrRemoteLocatorSet, ItrRemoteLocatorSetBuilder>, ByteDataTranslator,
JvppReplyConsumer, LispInitPathsMapper { @Override public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final ItrRemoteLocatorSet readValue) { ((LispFeatureDataBuilder) parentBuilder).setItrRemoteLocatorSet(readValue); } ItrRemoteLocatorSetCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override ItrRemoteLocatorSetBuilder getBuilder(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<ItrRemoteLocatorSet> id,
@Nonnull final ItrRemoteLocatorSetBuilder builder, @Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final ItrRemoteLocatorSet readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<ItrRemoteLocatorSet> instanceIdentifier, @Nonnull ItrRemoteLocatorSet itrRemoteLocatorSet, @Nonnull ReadContext readContext); }### Answer:
@Test public void merge() throws Exception { LispFeatureDataBuilder builder = new LispFeatureDataBuilder(); ItrRemoteLocatorSet set = new ItrRemoteLocatorSetBuilder().setRemoteLocatorSetName("loc-set").build(); getCustomizer().merge(builder, set); assertNotNull(builder); assertEquals(set, builder.getItrRemoteLocatorSet()); } |
### Question:
BridgeDomainSubtableCustomizer extends FutureJVppCustomizer implements
InitializingReaderCustomizer<BridgeDomainSubtable, BridgeDomainSubtableBuilder>, SubtableReader, LispInitPathsMapper { @Nonnull @Override public BridgeDomainSubtableBuilder getBuilder(@Nonnull final InstanceIdentifier<BridgeDomainSubtable> id) { return new BridgeDomainSubtableBuilder(); } BridgeDomainSubtableCustomizer(@Nonnull final FutureJVppCore futureJvppCore,
@Nonnull final NamingContext bridgeDomainContext); @Nonnull @Override BridgeDomainSubtableBuilder getBuilder(@Nonnull final InstanceIdentifier<BridgeDomainSubtable> id); @Override void readCurrentAttributes(@Nonnull final InstanceIdentifier<BridgeDomainSubtable> id,
@Nonnull final BridgeDomainSubtableBuilder builder,
@Nonnull final ReadContext ctx); @Override void merge(@Nonnull final Builder<? extends DataObject> parentBuilder,
@Nonnull final BridgeDomainSubtable readValue); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<BridgeDomainSubtable> instanceIdentifier, @Nonnull BridgeDomainSubtable bridgeDomainSubtable, @Nonnull ReadContext readContext); }### Answer:
@Override @Test public void testGetBuilder() { final BridgeDomainSubtableBuilder builder = customizer.getBuilder(validId); assertNotNull(builder); assertNull(builder.getLocalMappings()); assertNull(builder.getRemoteMappings()); assertNull(builder.getBridgeDomainRef()); } |
### Question:
MapRequestModeCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<MapRequestMode, MapRequestModeBuilder>,
JvppReplyConsumer, LispInitPathsMapper { @Override public void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier, @Nonnull MapRequestModeBuilder mapRequestModeBuilder, @Nonnull ReadContext readContext) throws ReadFailedException { if (!lispStateCheckService.lispEnabled(readContext)) { LOG.debug("Failed to read {}. Lisp feature must be enabled first", instanceIdentifier); return; } final ShowOneMapRequestModeReply reply = getReplyForRead( getFutureJVpp().showOneMapRequestMode(new ShowOneMapRequestMode()).toCompletableFuture(), instanceIdentifier); if (reply != null) { mapRequestModeBuilder.setMode( org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.lisp.rev171013.MapRequestMode .forValue(reply.mode)); } } MapRequestModeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override MapRequestModeBuilder getBuilder(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestModeBuilder mapRequestModeBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder,
@Nonnull MapRequestMode mapRequestMode); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestMode,
@Nonnull ReadContext readContext); }### Answer:
@Test public void testReadCurrentAttributes() throws Exception { final MapRequestModeBuilder builder = new MapRequestModeBuilder(); customizer.readCurrentAttributes(CONFIG_IID, builder, ctx); assertEquals(DestinationOnly, builder.getMode()); } |
### Question:
MapRequestModeCustomizer extends CheckedLispCustomizer implements InitializingReaderCustomizer<MapRequestMode, MapRequestModeBuilder>,
JvppReplyConsumer, LispInitPathsMapper { @Nonnull @Override public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier, @Nonnull MapRequestMode mapRequestMode, @Nonnull ReadContext readContext) { return Initialized.create(lispFeaturesBasePath().child(MapRequestMode.class), mapRequestMode); } MapRequestModeCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final LispStateCheckService lispStateCheckService); @Nonnull @Override MapRequestModeBuilder getBuilder(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier); @Override void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestModeBuilder mapRequestModeBuilder,
@Nonnull ReadContext readContext); @Override void merge(@Nonnull Builder<? extends DataObject> builder,
@Nonnull MapRequestMode mapRequestMode); @Nonnull @Override Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
@Nonnull MapRequestMode mapRequestMode,
@Nonnull ReadContext readContext); }### Answer:
@Test public void testInit() { final MapRequestMode data = new MapRequestModeBuilder().setMode(DestinationOnly).build(); invokeInitTest(STATE_IID, data, CONFIG_IID, data); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.