import io.netty.buffer.Unpooled;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
+import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class BGPMessageParserMockTest {
private final byte[][] inputBytes = new byte[11][];
- private final List<Update> messages = Lists.newArrayList();
+ private final List<Update> messages = new ArrayList<>();
@Before
public void init() throws Exception {
final UpdateBuilder builder = new UpdateBuilder();
- final List<Segments> asPath = Lists.newArrayList();
+ final List<Segments> asPath = new ArrayList<>();
asPath.add(new SegmentsBuilder().setAsSequence(Lists.newArrayList(new AsNumber(asn))).build());
final CNextHop nextHop = new Ipv6NextHopCaseBuilder().setIpv6NextHop(
new Ipv6NextHopBuilder().setGlobal(new Ipv6Address("2001:db8::1"))
final Set<BgpTableType> type = Sets.newHashSet();
type.add(new BgpTableTypeImpl(Ipv4AddressFamily.class, MplsLabeledVpnSubsequentAddressFamily.class));
- final List<BgpParameters> params = Lists.newArrayList();
+ final List<BgpParameters> params = new ArrayList<>();
final CParameters par = new CParametersBuilder().addAugmentation(CParameters1.class, new CParameters1Builder()
.setMultiprotocolCapability(new MultiprotocolCapabilityBuilder().setAfi(Ipv4AddressFamily.class)
import static org.junit.Assert.assertTrue;
-import com.google.common.collect.Lists;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.Uninterruptibles;
+import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
private static final Logger LOG = LoggerFactory.getLogger(SimpleSessionListener.class);
@GuardedBy("this")
- private final List<Notification> listMsg = Lists.newArrayList();
+ private final List<Notification> listMsg = new ArrayList<>();
private BGPSession bgpSession;
private final CountDownLatch sessionLatch = new CountDownLatch(1);
package org.opendaylight.protocol.bgp.testtool;
-import com.google.common.collect.Lists;
+import java.util.ArrayList;
import java.util.List;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
}
static List<ExtendedCommunities> createExtComm(final List<String> extCom) {
- final List<ExtendedCommunities> extendedCommunities = Lists.newArrayList();
+ final List<ExtendedCommunities> extendedCommunities = new ArrayList<>();
for (String ec : extCom) {
ExtendedCommunity community = null;
switch (ec) {
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
-import com.google.common.collect.Lists;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPipeline;
import java.net.InetSocketAddress;
+import java.util.ArrayList;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- this.messages = Lists.newArrayList();
+ this.messages = new ArrayList<>();
this.session = new BmpMockSession(1, 1, 1);
this.channel = Mockito.mock(Channel.class);
Mockito.doReturn(REMOTE_ADDRESS).when(this.channel).remoteAddress();
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedInt;
import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
+import java.util.ArrayList;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.CommonObjectParser;
import org.opendaylight.protocol.pcep.spi.ObjectSerializer;
}
bytes.skipBytes(FLAGS_F_OFFSET);
final BitArray flags = BitArray.valueOf(bytes, FLAGS_SIZE);
- final List<RequestId> requestIDs = Lists.newArrayList();
+ final List<RequestId> requestIDs = new ArrayList<>();
while (bytes.isReadable()) {
requestIDs.add(new RequestId(bytes.readUnsignedInt()));
package org.opendaylight.protocol.pcep.parser.subobject;
import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import java.util.ArrayList;
final SubobjectBuilder builder = new SubobjectBuilder();
builder.setLoose(loose);
final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.exclude.route.object.xro.Subobject> list = parseSubobject(buffer);
- final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.explicit.route.subobjects.subobject.type.exrs._case.exrs.Exrs> exrss = Lists.newArrayList();
+ final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.explicit.route.subobjects.subobject.type.exrs._case.exrs.Exrs> exrss = new ArrayList<>();
for (final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.exclude.route.object.xro.Subobject s : list) {
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.explicit.route.subobjects.subobject.type.exrs._case.exrs.ExrsBuilder b = new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.explicit.route.subobjects.subobject.type.exrs._case.exrs.ExrsBuilder();
b.setAttribute(s.getAttribute());
import static org.opendaylight.protocol.util.ByteBufWriteUtil.writeUnsignedShort;
import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
+import java.util.ArrayList;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.PCEPDeserializerException;
import org.opendaylight.protocol.pcep.spi.TlvParser;
if (buffer.readableBytes() % OF_CODE_ELEMENT_LENGTH != 0) {
throw new PCEPDeserializerException("Wrong length of array of bytes. Passed: " + buffer.readableBytes() + ".");
}
- final List<OfId> ofCodes = Lists.newArrayList();
+ final List<OfId> ofCodes = new ArrayList<>();
while (buffer.isReadable()) {
ofCodes.add(new OfId(buffer.readUnsignedShort()));
}
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
+import java.util.ArrayList;
import java.util.List;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
import org.opendaylight.protocol.pcep.spi.MessageUtil;
protected Message validate(final List<Object> objects, final List<Message> errors) {
checkArgument(objects != null, "Passed list can't be null.");
final PcinitiateMessageBuilder builder = new PcinitiateMessageBuilder();
- final List<Requests> reqs = Lists.newArrayList();
+ final List<Requests> reqs = new ArrayList<>();
while (!objects.isEmpty()) {
reqs.add(this.getValidRequest(objects));
}
builder.setLsp((Lsp) objects.get(0));
objects.remove(0);
- final List<Metrics> metrics = Lists.newArrayList();
+ final List<Metrics> metrics = new ArrayList<>();
Object obj;
State state = State.INIT;
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
+import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
throw new PCEPDeserializerException("Pcrpt message cannot be empty.");
}
- final List<Reports> reports = Lists.newArrayList();
+ final List<Reports> reports = new ArrayList<>();
while (!objects.isEmpty()) {
final Reports report = getValidReports(objects, errors);
}
private static void parsePath(final List<Object> objects, final PathBuilder builder) {
- final List<Metrics> pathMetrics = Lists.newArrayList();
+ final List<Metrics> pathMetrics = new ArrayList<>();
Object obj;
State state = State.INIT;
while (!objects.isEmpty() && !state.equals(State.END)) {
import static com.google.common.base.Preconditions.checkArgument;
-import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
+import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import org.opendaylight.protocol.pcep.spi.AbstractMessageParser;
throw new PCEPDeserializerException("Pcup message cannot be empty.");
}
- final List<Updates> updateRequests = Lists.newArrayList();
+ final List<Updates> updateRequests = new ArrayList<>();
while (!objects.isEmpty()) {
final Updates upd = getValidUpdates(objects, errors);
}
private static void parsePath(final List<Object> objects, final PathBuilder pathBuilder) {
- final List<Metrics> pathMetrics = Lists.newArrayList();
+ final List<Metrics> pathMetrics = new ArrayList<>();
Object obj;
State state = State.INIT;
while (!objects.isEmpty() && !state.equals(State.END)) {
final IroBuilder iroBuilder = new IroBuilder();
iroBuilder.setIgnore(false);
iroBuilder.setProcessingRule(false);
- final List<Subobject> iroSubs = Lists.newArrayList();
+ final List<Subobject> iroSubs = new ArrayList<>();
iroSubs.add(new SubobjectBuilder().setSubobjectType(this.eroASSubobject).setLoose(false).build());
iroBuilder.setSubobject(iroSubs);
this.iro = iroBuilder.build();
eroBuilder.setIgnore(false);
eroBuilder.setProcessingRule(false);
final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.explicit.route
- .object.ero.Subobject> eroSubs = Lists.newArrayList();
+ .object.ero.Subobject> eroSubs = new ArrayList<>();
eroSubs.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.explicit
.route.object.ero.SubobjectBuilder().setSubobjectType(this.eroASSubobject).setLoose(false).build());
eroBuilder.setSubobject(eroSubs);
rroBuilder.setIgnore(false);
rroBuilder.setProcessingRule(false);
final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.reported.route
- .object.rro.Subobject> rroSubs = Lists.newArrayList();
+ .object.rro.Subobject> rroSubs = new ArrayList<>();
rroSubs.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.reported
.route.object.rro.SubobjectBuilder().setSubobjectType(this.rroUnnumberedSub).setProtectionAvailable(false)
.setProtectionInUse(false).build());
final PcupdMessageBuilder builder = new PcupdMessageBuilder();
- final List<Updates> updates = Lists.newArrayList();
+ final List<Updates> updates = new ArrayList<>();
final PathBuilder pBuilder = new PathBuilder();
pBuilder.setEro(this.ero);
pBuilder.setLspa(this.lspa);
parser.serializeMessage(new PcupdBuilder().setPcupdMessage(builder.build()).build(), buf);
assertArrayEquals(result.array(), buf.array());
- final List<Updates> updates1 = Lists.newArrayList();
+ final List<Updates> updates1 = new ArrayList<>();
final PathBuilder pBuilder1 = new PathBuilder();
pBuilder1.setEro(this.ero);
pBuilder1.setLspa(this.lspa);
final PcrptMessageBuilder builder = new PcrptMessageBuilder();
- final List<Reports> reports = Lists.newArrayList();
+ final List<Reports> reports = new ArrayList<>();
reports.add(new ReportsBuilder().setLsp(this.lsp).build());
builder.setReports(reports);
final Message parseResult = parser.parseMessage(result.slice(4, result.readableBytes() - 4),
result = Unpooled.wrappedBuffer(PCRT2);
- final List<Reports> reports1 = Lists.newArrayList();
+ final List<Reports> reports1 = new ArrayList<>();
reports1.add(new ReportsBuilder().setLsp(this.lsp).setPath(new org.opendaylight.yang.gen.v1.urn.opendaylight
.params.xml.ns.yang.pcep.ietf.stateful.rev181109.pcrpt.message.pcrpt.message.reports.PathBuilder()
.setEro(this.ero).setLspa(this.lspa).build()).build());
result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCRpt.3.bin"));
- final List<Reports> reports2 = Lists.newArrayList();
+ final List<Reports> reports2 = new ArrayList<>();
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.pcrpt
.message.pcrpt.message.reports.PathBuilder pBuilder = new org.opendaylight.yang.gen.v1.urn.opendaylight
.params.xml.ns.yang.pcep.ietf.stateful.rev181109.pcrpt.message.pcrpt.message.reports.PathBuilder();
result = Unpooled.wrappedBuffer(ByteArray.fileToBytes("src/test/resources/PCRpt.5.bin"));
- final List<Reports> reports3 = Lists.newArrayList();
+ final List<Reports> reports3 = new ArrayList<>();
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.ietf.stateful.rev181109.pcrpt
.message.pcrpt.message.reports.PathBuilder pBuilder1 = new org.opendaylight.yang.gen.v1.urn.opendaylight
.params.xml.ns.yang.pcep.ietf.stateful.rev181109.pcrpt.message.pcrpt.message.reports.PathBuilder();
result = Unpooled.wrappedBuffer(PCRT3);
- final List<Reports> reports4 = Lists.newArrayList();
+ final List<Reports> reports4 = new ArrayList<>();
reports4.add(new ReportsBuilder().setLsp(this.lsp).setPath(new org.opendaylight.yang.gen.v1.urn.opendaylight
.params.xml.ns.yang.pcep.ietf.stateful.rev181109.pcrpt.message.pcrpt.message.reports.PathBuilder()
.setEro(this.ero).setLspa(this.lspa).setBandwidth(this.bandwidth)
final PcinitiateMessageBuilder builder = new PcinitiateMessageBuilder();
final RequestsBuilder rBuilder = new RequestsBuilder();
- final List<Requests> reqs = Lists.newArrayList();
+ final List<Requests> reqs = new ArrayList<>();
rBuilder.setSrp(this.srp);
rBuilder.setLsp(this.lspSrp);
rBuilder.setEro(this.ero);
.rp.object.rp.TlvsBuilder().build());
rpBuilder.setProcessingRule(false);
final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcerr
- .message.pcerr.message.error.type.request._case.request.Rps> rps = Lists.newArrayList();
+ .message.pcerr.message.error.type.request._case.request.Rps> rps = new ArrayList<>();
rps.add(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.pcep.types.rev181109.pcerr
.message.pcerr.message.error.type.request._case.request.RpsBuilder().setRp(rpBuilder.build()).build());
builder.setPcerrMessage(errMsgBuilder.build());
final ByteBuf buf = Unpooled.wrappedBuffer(statefulMsg);
- final List<Message> errors = Lists.newArrayList();
+ final List<Message> errors = new ArrayList<>();
parser.parseMessage(buf.slice(4, buf.readableBytes() - 4), errors);
assertFalse(errors.isEmpty());
assertEquals(builder.build(), errors.get(0));
builder.setPcerrMessage(errMsgBuilder.build());
final ByteBuf buf = Unpooled.wrappedBuffer(badUpdateMsg);
- final List<Message> errors = Lists.newArrayList();
+ final List<Message> errors = new ArrayList<>();
parser.parseMessage(buf.slice(4, buf.readableBytes() - 4), errors);
assertFalse(errors.isEmpty());
assertEquals(builder.build(), errors.get(0));
*/
package org.opendaylight.protocol.pcep.spi;
+import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
+import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.iana.rev130816.EnterpriseNumber;
}
protected final void parseTlvs(final T builder, final ByteBuf bytes) throws PCEPDeserializerException {
- Preconditions.checkArgument(bytes != null, "Array of bytes is mandatory. Can't be null.");
+ checkArgument(bytes != null, "Array of bytes is mandatory. Can't be null.");
if (!bytes.isReadable()) {
return;
}
- final List<VendorInformationTlv> viTlvs = Lists.newArrayList();
+ final List<VendorInformationTlv> viTlvs = new ArrayList<>();
while (bytes.isReadable()) {
final int type = bytes.readUnsignedShort();
final int length = bytes.readUnsignedShort();
*/
package org.opendaylight.protocol.pcep.testtool;
-import com.google.common.collect.Lists;
+import java.util.ArrayList;
import java.util.List;
import org.opendaylight.protocol.pcep.PCEPSession;
import org.opendaylight.protocol.pcep.PCEPSessionListener;
public class TestingSessionListener implements PCEPSessionListener {
private static final Logger LOG = LoggerFactory.getLogger(TestingSessionListener.class);
- private final List<Message> messages = Lists.newArrayList();
+ private final List<Message> messages = new ArrayList<>();
private boolean up = false;
@Override
import static org.mockito.Mockito.mock;
import static org.opendaylight.protocol.util.CheckTestUtil.checkEquals;
-import com.google.common.collect.Lists;
+import java.util.ArrayList;
import java.util.List;
import org.junit.Assert;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.yangtools.yang.binding.Notification;
final class MockedNotificationServiceWrapper {
- private final List<Notification> publishedNotifications;
-
- MockedNotificationServiceWrapper() {
- this.publishedNotifications = Lists.newArrayList();
- }
+ private final List<Notification> publishedNotifications = new ArrayList<>();
NotificationPublishService getMockedNotificationService() throws InterruptedException {
final NotificationPublishService mockedNotificationService = mock(NotificationPublishService.class);
import io.netty.util.HashedWheelTimer;
import io.netty.util.Timer;
import java.math.BigInteger;
+import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import org.junit.After;
final SubmitInstructionInput mockedSubmitInstruction = mock(SubmitInstructionInput.class);
doReturn(PcepUpdateTunnelInput.class).when(mockedSubmitInstruction).getImplementedInterface();
- final List<InstructionId> dependencies = Lists.newArrayList();
+ final List<InstructionId> dependencies = new ArrayList<>();
for (final String dependencyId : dependencyIds) {
dependencies.add(new InstructionId(dependencyId));
}
package org.opendaylight.protocol.rsvp.parser.impl.subobject.ero;
import com.google.common.base.Preconditions;
-import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import java.util.ArrayList;
final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.exclude.route
.object.exclude.route.object.SubobjectContainer> list = localParseSubobject(buffer);
final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.explicit.route
- .subobjects.subobject.type.exrs._case.exrs.Exrs> exrss = Lists.newArrayList();
+ .subobjects.subobject.type.exrs._case.exrs.Exrs> exrss = new ArrayList<>();
for (final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.exclude.route
.object.exclude.route.object.SubobjectContainer s : list) {
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.explicit.route
import static org.junit.Assert.assertEquals;
-import com.google.common.collect.Lists;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
+import java.util.ArrayList;
import java.util.List;
import org.junit.After;
import org.junit.Assert;
final SubobjectContainerBuilder subs = new SubobjectContainerBuilder();
subs.setLoose(true);
final List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.explicit.route
- .subobjects.subobject.type.exrs._case.exrs.Exrs> list = Lists.newArrayList();
+ .subobjects.subobject.type.exrs._case.exrs.Exrs> list = new ArrayList<>();
final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.explicit.route
.subobjects.subobject.type.exrs._case.exrs.ExrsBuilder builder =
new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp