diff options
Diffstat (limited to 'framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol')
12 files changed, 10927 insertions, 0 deletions
diff --git a/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepCloseMsgTest.java b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepCloseMsgTest.java new file mode 100644 index 00000000..33c00ddf --- /dev/null +++ b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepCloseMsgTest.java @@ -0,0 +1,56 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.pcepio.protocol; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepCloseMsgTest { + + /** + * Common header, reason to close. + */ + @Test + public void closeMessageTest1() throws PcepParseException { + + byte[] closeMsg = new byte[] {0x20, 0x07, 0x00, 0x0C, 0x0f, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02 }; + + byte[] testCloseMsg = {0 }; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(closeMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepCloseMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testCloseMsg = buf.array(); + + int readLen = buf.writerIndex(); + testCloseMsg = new byte[readLen]; + buf.readBytes(testCloseMsg, 0, readLen); + assertThat(testCloseMsg, is(closeMsg)); + } +} diff --git a/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepErrorMsgTest.java b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepErrorMsgTest.java new file mode 100644 index 00000000..234cea67 --- /dev/null +++ b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepErrorMsgTest.java @@ -0,0 +1,735 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.pcepio.protocol; + + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +/** + * Test cases for PCEP ERROR Message. + */ +public class PcepErrorMsgTest { + + /** + * This test case checks for + * PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, + * PCECC-CAPABILITY-TLV, TED Capability TLV) + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest1() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x34, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x01, 0x10, 0x00, 0x28, // OPEN object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x03, 0x00, (byte) 0x84, 0x00, 0x04, // TED Capability TLV + 0x00, 0x00, 0x00, 0x00}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, + * PCECC-CAPABILITY-TLV, TED Capability TLV) + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest2() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x3C, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x28, // OPEN object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x03, 0x00, (byte) 0x84, 0x00, 0x04, // TED Capability TLV + 0x00, 0x00, 0x00, 0x00}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, + * PCECC-CAPABILITY-TLV) + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest3() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x34, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x20, // OPEN object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x03}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV) + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest4() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x2c, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x18, // OPEN object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object (STATEFUL-PCE-CAPABILITY) + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest5() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x24, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x10, // OPEN object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, OPEN Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest6() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x1C, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03, 0x01, 0x10, 0x00, 0x08, // OPEN object header + 0x20, 0x05, 0x1E, 0x01 // OPEN object + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, OPEN Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest7() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x14, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x01, 0x10, 0x00, 0x08, // OPEN object header + 0x20, 0x05, 0x1E, 0x01 // OPEN object + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, RP Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest8() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x20, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest9() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x14, // common header + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest10() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x14, // common header + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * TE Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest11() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x18, // common header + 0x65, 0x13, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * RP Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest12() throws PcepParseException { + + //RP Object, PCEP-ERROR Object + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x18, // common header + 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * RP Object, RP Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest13() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x24, // common header + 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * TE Object, TE Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest14() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x24, // common header + 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x11, // TE-ID + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, TE Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest15() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x20, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x03}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest16() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x2C, // common header + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, TE Object, TE Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest17() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x2C, // common header + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01, 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x11, // TE-ID + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x03}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest18() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x3C, // common header + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x06}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, PCEP-ERROR Object, TE Object, TE Object, PCEP-ERROR Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest19() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x3C, // common header + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x01, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x03, 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x11, // TE-ID + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x06}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } + + /** + * This test case checks for + * PCEP-ERROR Object, RP Object, RP Object, PCEP-ERROR Object, PCEP-ERROR Object, + * TE Object, PCEP-ERROR Object + * in PcepErrorMsg message. + */ + @Test + public void errorMessageTest20() throws PcepParseException { + + byte[] errorMsg = new byte[]{0x20, 0x06, 0x00, 0x48, // common header + 0x0D, 0x10, 0x00, 0x08, // PCEP-ERROR Object Header + 0x00, 0x00, 0x01, 0x01, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x10, 0x00, 0x0C, // RP Object Header + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x04, 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x06, 0x65, 0x10, 0x00, 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x0D, 0x10, 0x00, 0x08, // PCERR Object Header + 0x00, 0x00, 0x01, 0x06}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(errorMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testErrorMsg = {0}; + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + assertThat(message, instanceOf(PcepErrorMsg.class)); + + message.writeTo(buf); + int iReadLen = buf.writerIndex(); + testErrorMsg = new byte[iReadLen]; + buf.readBytes(testErrorMsg, 0, iReadLen); + + assertThat(testErrorMsg, is(errorMsg)); + } +} diff --git a/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepInitiateMsgExtTest.java b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepInitiateMsgExtTest.java new file mode 100644 index 00000000..9341f326 --- /dev/null +++ b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepInitiateMsgExtTest.java @@ -0,0 +1,1683 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.pcepio.protocol; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepInitiateMsgExtTest { + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv, StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH, METRIC-LIST objects in PcInitiate message. + */ + @Test + public void initiateMessageTest1() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC-LIST. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xA4, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, //Metric object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv, StatefulLspErrorCodeTlv, + * StatefulRsvpErrorSpecTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest2() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xA8, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x48, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x00, 0x15, 0x00, 0x0c, //StatefulRsvpErrorSpecTlv + 0x00, 0x0c, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x05, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspDbVerTlv, StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH objects in PcInitiate message. + */ + @Test + public void initiateMessageTest3() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, ERO, LSPA, BANDWIDTH. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x8c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + // 0x00, 0x15, 0x00, 0x0c, //StatefulRsvpErrorSpecTlv + //0x00, 0x0c, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x05, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv, StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), + * END-POINTS, ERO, LSPA objects in PcInitiate message. + */ + @Test + public void initiateMessageTest4() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, ERO, LSPA. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x84, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + // 0x00, 0x15, 0x00, 0x0c, //StatefulRsvpErrorSpecTlv + // 0x00, 0x0c, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x05, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv, StatefulLspErrorCodeTlv), END-POINTS, ERO, LSPA + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest5() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv), END-POINTS, ERO, LSPA. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x84, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv, StatefulLspErrorCodeTlv), END-POINTS, ERO, LSPA, + * BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest6() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv), END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x8c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv, StatefulLspErrorCodeTlv), END-POINTS, ERO, + * LSPA, BANDWIDTH, METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest7() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv, + * StatefulLspErrorCodeTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x98, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest8() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x90, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x30, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv), END-POINTS, ERO, LSPA, BANDWIDTH OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest9() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x84, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x30, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv), END-POINTS, ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest10() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv), END-POINTS, ERO, LSPA OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest11() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv), + * END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x7C, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x30, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv), END-POINTS, ERO, LSPA, BANDWIDTH OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest12() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x78, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspDbVerTlv), END-POINTS, ERO, LSPA, BANDWIDTH , METRIC OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest13() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, StatefulLspDbVerTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH , METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x84, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH , METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest14() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH , METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x7c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest15() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest16() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest17() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, + * BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest18() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, + * BANDWIDTH, METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest19() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x74, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, + * BANDWIDTH, METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest20() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, + * BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest21() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, + * LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest22() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest23() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINTS, ERO, LSPA BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest25() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), END-POINTS, ERO, LSPA BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH, METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest26() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x6C, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), END-POINTS, ERO, LSPA, + * BANDWIDTH, METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest27() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), END-POINTS, ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), END-POINTS, ERO, + * LSPA, BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest28() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), END-POINTS, ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), + * END-POINTS, ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest29() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x4C, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), + * END-POINTS, ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest30() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x5C, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv), END-POINTS, ERO, LSPA OBJECT + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest31() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv), END-POINTS, ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH, METRIC OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest32() throws PcepParseException { + + /* SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH, METRIC OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest33() throws PcepParseException { + + /* SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA, BANDWIDTH OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest34() throws PcepParseException { + + /* SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest35() throws PcepParseException { + + /* SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA OBJECT objects in PcInitiate message. + */ + @Test + public void initiateMessageTest36() throws PcepParseException { + + /* SRP, LSP ( StatefulLspDbVerTlv), END-POINTS, + * ERO, LSPA OBJECT. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x0C, 0x01, //ERO object + 0x01, 0x01, 0x00, 0x00, 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } +} + diff --git a/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepInitiateMsgTest.java b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepInitiateMsgTest.java new file mode 100644 index 00000000..0f8bb7ba --- /dev/null +++ b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepInitiateMsgTest.java @@ -0,0 +1,1331 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.pcepio.protocol; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepInitiateMsgTest { + + /** + * This test case checks for srp, lsp, end-point, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest1() throws PcepParseException { + + /* srp, lsp, end-point, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, 0x54, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x00, 0x08, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp and lsp objects in PcInitiate message. + */ + @Test + public void initiateMessageTest2() throws PcepParseException { + /* srp, lsp. + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x34, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x20, 0x10, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + 0x01, 0x01, 0x01, 0x01, 0x00, 0x43, (byte) 0x83, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33}; //SymbolicPathTlv + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, ERO objects + * in PcInitiate message. + */ + @Test + public void initiateMessageTest3() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv, StatefulRsvpErrorSpecTlv), END-POINTS, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), END-POINT, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest4() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), END-POINT, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * END-POINT, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest5() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * END-POINT, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * END-POINT, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest6() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * END-POINT, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINT, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest7() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * END-POINT, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * END-POINT, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest8() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * END-POINT, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x4c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * END-POINT, ERO objects in PcInitiate message. + */ + @Test + public void initiateMessageTest9() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * END-POINT, ERO. + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x3c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, StatefulRsvpErrorSpecTlv) + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest10() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, StatefulRsvpErrorSpecTlv). + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x44, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, (byte) 0xb6, 0x02, 0x4e, 0x1f, + (byte) 0xb6, 0x02, 0x4e, 0x20, 0x00, 0x11, 0x00, 0x04, 0x54, 0x31, 0x32, 0x33, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08 //StatefulLspErrorCodeTlv + }; + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv) objects in PcInitiate message. + */ + @Test + public void initiateMessageTest11() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + StatefulLspErrorCodeTlv).*/ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x44, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08}; //StatefulLspErrorCodeTlv + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv) + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest12() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv). + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x3c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00 //SymbolicPathNameTlv + }; + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv) + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest13() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv). + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x3c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00}; //SymbolicPathNameTlv + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv) + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest14() throws PcepParseException { + + /* SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv). + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x34, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20}; + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv) + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest15() throws PcepParseException { + + /* SRP, LSP (StatefulIPv4LspIdentidiersTlv). + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x2c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20}; + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for srp,lsp (StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest16() throws PcepParseException { + + //srp,lsp (StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp (StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest17() throws PcepParseException { + + //srp,lsp (StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp (StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth,metric-list + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest18() throws PcepParseException { + //srp,lsp (StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth,metric-list + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(all tlvs),end-point,ero,lspa,bandwidth,metric-list + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest19() throws PcepParseException { + //srp,lsp(all tlvs),end-point,ero,lspa,bandwidth,metric-list + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x74, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x04, //ERO object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, srp, + * lsp(SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv) objects in PcInitiate message. + */ + @Test + public void initiateMessageTest20() throws PcepParseException { + /* srp,lsp (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, srp, + * lsp(SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv). + */ + byte[] initiateDeletionMsg = new byte[]{0x20, 0x0C, 0x00, 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20}; + + byte[] testInitiateDeletionMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateDeletionMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateDeletionMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateDeletionMsg = new byte[iReadLen]; + buf.readBytes(testInitiateDeletionMsg, 0, iReadLen); + + assertThat(testInitiateDeletionMsg, is(initiateDeletionMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest21() throws PcepParseException { + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero, + * srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0x94, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest22() throws PcepParseException { + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero, + * srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xA8, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest23() throws PcepParseException { + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero, + * srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth + */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xB0, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest24() throws PcepParseException { + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero, + * srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth*/ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xBC, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,bandwidth, + * srp,lsp(StatefulIPv4LspIdentidiersTlv), end-point,ero,lspa,bandwidth,metric-list + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest25() throws PcepParseException { + + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,bandwidth, + * srp,lsp(StatefulIPv4LspIdentidiersTlv), + * end-point,ero,lspa,bandwidth,metric-list */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xC4, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,bandwidth,metric-list, + * srp,lsp(StatefulIPv4LspIdentidiersTlv), end-point,ero,lspa,bandwidth,metric-list + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest26() throws PcepParseException { + + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,bandwidth,metric-list, + * srp,lsp(StatefulIPv4LspIdentidiersTlv), + * end-point,ero,lspa,bandwidth,metric-list */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xD0, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } + + /** + * This test case checks for srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth,metric-list, + * srp,lsp(StatefulIPv4LspIdentidiersTlv), end-point,ero,lspa,bandwidth,metric-list + * objects in PcInitiate message. + */ + @Test + public void initiateMessageTest27() throws PcepParseException { + + /*srp,lsp(StatefulIPv4LspIdentidiersTlv),end-point,ero,lspa,bandwidth,metric-list, + * srp,lsp(StatefulIPv4LspIdentidiersTlv), + * end-point,ero,lspa,bandwidth,metric-list */ + byte[] initiateCreationMsg = new byte[]{0x20, 0x0C, 0x00, (byte) 0xE4, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x04, 0x12, 0x00, 0x0C, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, //Endpoints Object + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x01, 0x08, 0x0C, 0x01, 0x01, 0x02, 0x00, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testInitiateCreationMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(initiateCreationMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepInitiateMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testInitiateCreationMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testInitiateCreationMsg = new byte[iReadLen]; + buf.readBytes(testInitiateCreationMsg, 0, iReadLen); + + assertThat(testInitiateCreationMsg, is(initiateCreationMsg)); + } +} diff --git a/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepKeepaliveMsgTest.java b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepKeepaliveMsgTest.java new file mode 100644 index 00000000..56cf06b4 --- /dev/null +++ b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepKeepaliveMsgTest.java @@ -0,0 +1,59 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.pcepio.protocol; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Assert; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepKeepaliveMsgTest { + + /** + * Common header for keep alive message. + */ + @Test + public void keepaliveMessageTest1() throws PcepParseException { + + byte[] keepaliveMsg = new byte[] {0x20, 0x02, 0x00, 0x04 }; + + byte[] testKeepaliveMsg = {0 }; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(keepaliveMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepKeepaliveMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + + message.writeTo(buf); + + testKeepaliveMsg = buf.array(); + + int iReadLen = buf.writerIndex(); + testKeepaliveMsg = new byte[iReadLen]; + buf.readBytes(testKeepaliveMsg, 0, iReadLen); + + Assert.assertThat(testKeepaliveMsg, is(keepaliveMsg)); + } +} diff --git a/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepLabelUpdateMsgTest.java b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepLabelUpdateMsgTest.java new file mode 100644 index 00000000..e1947bd7 --- /dev/null +++ b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepLabelUpdateMsgTest.java @@ -0,0 +1,402 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.pcepio.protocol; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.Matchers.is; + +public class PcepLabelUpdateMsgTest { + + /** + * This test case checks for + * <pce-label-download> SRP, LSP, LABEL Object. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest1() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x24, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-download> SRP, LSP, LABEL Object, LABEL Object. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest2() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x30, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x77}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-map> SRP, LABEL, FEC Object. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest3() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x24, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x24, 0x10, 0x00, 0x08, // FEC Object Header + 0x0A, 0x0A, 0x0B, 0x0B}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-download> SRP, LSP, LABEL, LABEL, <pce-label-download> SRP, LSP, LABEL + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest4() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x50, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x77, + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x11, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x02, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x44}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-map> SRP, LABEL, FEC, <pce-label-map> SRP, LABEL, FEC. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest5() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x44, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x66, + 0x24, 0x10, 0x00, 0x08, // FEC Object Header + 0x0A, 0x0A, 0x0B, 0x0B, + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x11, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x24, 0x10, 0x00, 0x08, // FEC Object Header + 0x0A, 0x0A, 0x0C, 0x0C}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-download> SRP, LSP, LABEL, LABEL, <pce-label-download> SRP, LABEL, FEC. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest6() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x50, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x77, + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x12, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x24, 0x10, 0x00, 0x08, // FEC Object Header + 0x0A, 0x0A, 0x0D, 0x0D}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-download> SRP, LABEL, FEC, <pce-label-download> SRP, LSP, LABEL, LABEL. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest7() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x50, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x12, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x24, 0x10, 0x00, 0x08, // FEC Object Header + 0x0A, 0x0A, 0x0D, 0x0D, + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x77}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } + + /** + * This test case checks for + * <pce-label-download> SRP, LABEL, FEC, <pce-label-download> SRP, LSP, LABEL, LABEL. + * <pce-label-download> SRP, LSP, LABEL, LABEL. + * in PcepLabelUpdate message. + */ + @Test + public void labelUpdateMessageTest8() throws PcepParseException { + + byte[] labelUpdate = new byte[]{0x20, 0x0D, 0x00, 0x7C, // common header + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x12, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x24, 0x10, 0x00, 0x08, // FEC Object Header + 0x0A, 0x0A, 0x0D, 0x0D, + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x77, + 0x21, 0x10, 0x00, 0x0C, // SRP Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x10, + 0x20, 0x10, 0x00, 0x08, // LSP Object Header + 0x00, 0x01, 0x00, 0x00, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x66, + 0x23, 0x10, 0x00, 0x0C, // LABEL Object Header + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x77}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(labelUpdate); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testLabelUpdateMsg = {0}; + + assertThat(message, instanceOf(PcepLabelUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testLabelUpdateMsg = new byte[readLen]; + buf.readBytes(testLabelUpdateMsg, 0, readLen); + + assertThat(testLabelUpdateMsg, is(labelUpdate)); + } +} diff --git a/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepOpenMsgTest.java b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepOpenMsgTest.java new file mode 100644 index 00000000..6e0a0596 --- /dev/null +++ b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepOpenMsgTest.java @@ -0,0 +1,558 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.pcepio.protocol; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; +/** + * Test cases for PCEP OPEN Message. + */ +public class PcepOpenMsgTest { + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, + * PCECC-CAPABILITY-TLV in Pcep Open message. + */ + @Test + public void openMessageTest1() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x24, 0x01, 0x10, 0x00, 0x20, 0x20, 0x1e, 0x78, (byte) 0xbd, + 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f, //STATEFUL-PCE-CAPABILITY + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, //GMPLS-CAPABILITY-TLV + 0x00, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, //PCECC-CAPABILITY-TLV + }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY-TLV in Pcep Open message. + */ + @Test + public void openMessageTest2() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x14, // common header + 0x01, 0x10, 0x00, 0x10, // common object header + 0x20, 0x1E, 0x78, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f}; // STATEFUL-PCE-CAPABILITY + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with GmplsCapability tlv in Pcep Open message. + */ + @Test + public void openMessageTest3() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x14, // common header + 0x01, 0x10, 0x00, 0x10, // common object header + 0x20, 0x1E, 0x78, 0x01, // OPEN object + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00}; //GMPLS-CAPABILITY-TLV + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with StatefulLspDbVer Tlv in Pcep Open message. + */ + @Test + public void openMessageTest4() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x18, + 0x01, 0x10, 0x00, 0x14, 0x20, 0x1e, 0x78, 0x20, + 0x00, 0x17, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02 }; //StatefulLspDbVerTlv + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with no tlv's in Pcep Open message. + */ + @Test + public void openMessageTest5() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x0C, + 0x01, 0x10, 0x00, 0x08, 0x20, 0x1e, 0x78, (byte) 0xbd }; // no Tlvs in open messsage + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, PCECC-CAPABILITY-TLV + * with I bit set in Pcep Open message. + */ + @Test + public void openMessageTest6() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x24, 0x01, 0x11, 0x00, 0x20, //p bit not set & i bit set + 0x20, 0x1e, 0x78, (byte) 0xbd, + 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f, // STATEFUL-PCE-CAPABILITY + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, //GMPLS-CAPABILITY-TLV + 0x00, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, //PCECC-CAPABILITY-TLV + }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, PCECC-CAPABILITY-TLV + * with P bit set in Pcep Open message. + */ + @Test + public void openMessageTest7() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x24, 0x01, 0x12, 0x00, 0x20, //p bit set & i bit not set + 0x20, 0x1e, 0x78, (byte) 0xbd, + 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f, //STATEFUL-PCE-CAPABILITY + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, //GMPLS-CAPABILITY-TLV + 0x00, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, //PCECC-CAPABILITY-TLV + }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, PCECC-CAPABILITY-TLV + * with P & I bits set in Pcep Open message. + */ + @Test + public void openMessageTest8() throws PcepParseException { + + /* OPEN OBJECT (STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, PCECC-CAPABILITY-TLV) + with p bit set & i bit set. + */ + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x24, 0x01, 0x13, 0x00, 0x20, //p bit set & i bit set + 0x20, 0x1e, 0x78, (byte) 0xbd, + 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f, //STATEFUL-PCE-CAPABILITY + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, //GMPLS-CAPABILITY-TLV + 0x00, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, //PCECC-CAPABILITY-TLV + }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, PCECC-CAPABILITY-TLV + * with P & I bits set and invalid session id in Pcep Open message. + */ + @Test + public void openMessageTest9() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x24, 0x01, 0x13, 0x00, 0x20, //p bit set & i bit set + 0x20, 0x1e, 0x78, 0x00, //invalid sessionID + 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0f, //STATEFUL-PCE-CAPABILITY + 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, //GMPLS-CAPABILITY-TLV + 0x00, 0x20, 0x00, 0x04, 0x00, 0x00, 0x00, 0x07, //PCECC-CAPABILITY-TLV + }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV + * in Pcep Open message. + */ + @Test + public void openMessageTest10() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x1C, // common header + 0x01, 0x10, 0x00, 0x18, // common object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, + 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00}; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, + * PCECC-CAPABILITY-TLV, TED Capability TLV in Pcep Open message. + */ + @Test + public void openMessageTest11() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x2C, // common header + 0x01, 0x10, 0x00, 0x28, // common object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x03, 0x00, (byte) 0x84, 0x00, 0x04, // TED Capability TLV + 0x00, 0x00, 0x00, 0x00 }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV, + * PCECC-CAPABILITY-TLV in Pcep Open message. + */ + @Test + public void openMessageTest12() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x24, // common header + 0x01, 0x10, 0x00, 0x20, // common object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x04, // PCECC-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x03}; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY, GMPLS-CAPABILITY-TLV + * in Pcep Open message. + */ + @Test + public void openMessageTest13() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x1c, // common header + 0x01, 0x10, 0x00, 0x18, // common object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05, 0x00, 0x0E, 0x00, 0x04, // GMPLS-CAPABILITY-TLV + 0x00, 0x00, 0x00, 0x00}; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with STATEFUL-PCE-CAPABILITY in Pcep Open message. + */ + @Test + public void openMessageTest14() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x14, // common header + 0x01, 0x10, 0x00, 0x10, // common object header + 0x20, 0x05, 0x1E, 0x01, // OPEN object + 0x00, 0x10, 0x00, 0x04, // STATEFUL-PCE-CAPABILITY + 0x00, 0x00, 0x00, 0x05}; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + + assertThat(testOpenMsg, is(openMsg)); + + } + + /** + * This test case checks open object with no tlv Pcep Open message. + */ + @Test + public void openMessageTest15() throws PcepParseException { + + byte[] openMsg = new byte[] {0x20, 0x01, 0x00, 0x0c, // common header + 0x01, 0x10, 0x00, 0x08, // common object header + 0x20, 0x05, 0x1E, 0x01 // OPEN object + }; + + byte[] testOpenMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(openMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepOpenMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testOpenMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testOpenMsg = new byte[readLen]; + buf.readBytes(testOpenMsg, 0, readLen); + assertThat(testOpenMsg, is(openMsg)); + + } +} diff --git a/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepReportMsgExtTest.java b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepReportMsgExtTest.java new file mode 100644 index 00000000..f9921efd --- /dev/null +++ b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepReportMsgExtTest.java @@ -0,0 +1,218 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.pcepio.protocol; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepReportMsgExtTest { + + /** + * This test case checks forSRP Object,LSP Object(symbolic path tlv),ERO Object + * SRP Object,LSP Object(symbolic path tlv,ERO Object,LSPA Object,BandWidth Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest39() throws PcepParseException { + + byte[] reportMsg = new byte[] {0x20, 0x0a, 0x00, (byte) 0x98, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object + * SRP Object,LSP Object(symbolic path tlv),ERO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest40() throws PcepParseException { + + byte[] reportMsg = new byte[] {0x20, 0x0a, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object + * SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object + * in PcRpt message. + */ + @Test + public void reportMessageTest41() throws PcepParseException { + + byte[] reportMsg = new byte[] {0x20, 0x0a, 0x00, (byte) 0x8c, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object,BandWidth Object, + * Metric-list SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object,BandWidth Object,Metric-list, + * RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest42() throws PcepParseException { + + byte[] reportMsg = new byte[] {0x20, 0x0a, 0x00, (byte) 0xE8, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //symbolic path tlv + 0x07, 0x10, 0x00, 0x14, //ERO object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } +} diff --git a/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepReportMsgTest.java b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepReportMsgTest.java new file mode 100644 index 00000000..c9e2bc8b --- /dev/null +++ b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepReportMsgTest.java @@ -0,0 +1,1597 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.pcepio.protocol; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepReportMsgTest { + + /** + * This test case checks for SRP object, LSP object(Symbolic path name tlv), ERO object + * in PcRpt message. + */ + @Test + public void reportMessageTest1() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, 0x24, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x04}; //ERO Object + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object, LSP Object(StatefulIPv4LspIdentidiersTlv,SymbolicPathNameTlv + * StatefulLspErrorCodeTlv) ERO Object, LSPA Object, Metric-list, IRO object + * in PcRpt message. + */ + @Test + public void reportMessageTest2() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x7c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object // LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, // IPv4SubObjects + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, //Metric Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + }; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(StatefulIPv4LspIdentidiersTlv,SymbolicPathNameTlv,StatefulLspErrorCodeTlv) + * ERO Object, LSPA Object, Metric-list, IRO object + * in PcRpt message. + */ + @Test + public void reportMessageTest3() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x70, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, //Ipv4SubObjects + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, //Metric Objects + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + }; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(StatefulIPv4LspIdentidiersTlv,SymbolicPathNameTlv,StatefulLspErrorCodeTlv) + * ERO Object, LSPA Object, Metric-list + * in PcRpt message. + */ + @Test + public void reportMessageTest4() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object, LSP Object(StatefulIPv4LspIdentidiersTlv,SymbolicPathNameTlv + * StatefulLspErrorCodeTlv) ERO Object, IRO object + * in PcRpt message. + */ + @Test + public void reportMessageTest5() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object, LSP Object(StatefulIPv4LspIdentidiersTlv,SymbolicPathNameTlv + * StatefulLspErrorCodeTlv) ERO Object, LSPA Object, Metric-list. + * in PcRpt message. + */ + @Test + public void reportMessageTest6() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x6c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x04, //ERO Object + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, //Metric object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + }; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object, ERO Object, LSPA Object, Metric-list, IRO object + * in PcRpt message. + */ + @Test + public void reportMessageTest7() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, // Metric objects + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP object, LSP object( StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv) ERO object, LSPA object, Metric object + * in PcRpt message. + */ + @Test + public void reportMessageTest8() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric Object + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv, + * StatefulLspErrorCodeTlv ),ERO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest9() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x44, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(StatefulIPv4LspIdentidiersTlv)ERO Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest10() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x74, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(SymbolicPathNameTlv)ERO Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest11() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object, ERO Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest12() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(StatefulLspErrorCodeTlv)ERO Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest13() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(StatefulRsvpErrorSpecTlv),ERO Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest14() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),LSPA Object,ERO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest15() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x7C, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),BandWidth Object,ERO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest16() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object,ERO Object,LSPA Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest17() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x74, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object,ERO Object,BandWidth Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest18() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object,ERO Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest19() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x6C, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object,ERO Object,LSPA Object,BandWidth Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest20() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x88, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv, + * StatefulLspErrorCodeTlv ) ERO Object,LSPA Object,BandWidth Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest21() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0xac, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv ) + * ERO Object,LSPA Object,BandWidth Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest22() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0xA0, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv ) + * ERO Object,BandWidth Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest23() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x8c, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv ) + * ERO Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest24() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x84, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv ) + * ERO Object,LSPA Object,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest25() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x8c, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv ) + * ERO Object,LSPA Object + * in PcRpt message. + */ + @Test + public void reportMessageTest26() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x58, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv) + * ERO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest27() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x44, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for LSP Object(Symbolic path tlv, StatefulIPv4LspIdentidiersTlv,StatefulLspErrorCodeTlv ) + * LSPA Object,BandWidth Object,Metric-list,ERO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest28() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x6c, + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest29() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x74, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,Metric-list,RRO Object + * SRP Object,LSP Object(symbolic path tlv),ERO Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest30() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0xE4, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object + * BandWidth Object,Metric-list,RRO Object,SRP Object,LSP Object(symbolic path tlv) + * ERO Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest31() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x01, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object + * BandWidth Object,Metric-list,RRO Object,SRP Object,LSP Object(symbolic path tlv) + * ERO Object,LSPA Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest32() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x01, (byte) 0x14, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path tlv),ERO Object,LSPA Object + * BandWidth Object,Metric-list,RRO Object,SRP Object,LSP Object(symbolic path tlv) + * ERO Object,LSPA Object,BandWidth Object,Metric-list,RRO Object + * in PcRpt message. + */ + @Test + public void reportMessageTest33() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x01, (byte) 0x1c, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x08, 0x10, 0x00, 0x34, 0x01, 0x08, 0x11, 0x01, //RRO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x06, 0x06, + 0x06, 0x06, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x05, 0x05, 0x05, 0x05, 0x04, 0x00}; + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object(symbolic path Tlv),ERO Object,LSPA Object + * BandWidth Object,Metric-list,SRP Object,LSP Object(symbolic path tlv) + * ERO Object,LSPA Object,BandWidth Object,Metric-list + * in PcRpt message. + */ + @Test + public void reportMessageTest34() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0xB4, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric Object + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x04, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric Object + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } + + /** + * This test case checks for SRP Object,LSP Object)Symbolic path tlv),ERO Object,SRP Object + * LSP Object(symbolic path tlv) ERO Object,LSPA Object, BandWidth Object,Metric-list + * in PcRpt message. + */ + @Test + public void reportMessageTest35() throws PcepParseException { + + byte[] reportMsg = new byte[]{0x20, 0x0a, 0x00, (byte) 0x8C, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x21, 0x10, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, //SRP Object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP Object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, //ERO Object + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x04, 0x00, + 0x01, 0x08, (byte) 0xb6, 0x02, 0x4e, 0x20, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, //LSPA Object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth Object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric Object + + byte[] testReportMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(reportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(reportMsg)); + } +} diff --git a/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepTEReportMsgTest.java b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepTEReportMsgTest.java new file mode 100644 index 00000000..e401c159 --- /dev/null +++ b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepTEReportMsgTest.java @@ -0,0 +1,1596 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.pcepio.protocol; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepTEReportMsgTest { + + /** + * This test case checks for + * TE Object (Routing Universe TLV, Local TE Node Descriptors TLV(AutonomousSystemTlv)). + * in PcTERpt message. + */ + @Test + public void teReportMessageTest1() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x28, // common header + 0x0E, 0x10, 0x00, 0x24, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x08, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystem Tlv + 0x00, 0x00, 0x00, 0x11}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * T E Object (Routing Universe TLV, Local TE Node Descriptors TLV(AutonomousSystemTlv)) with different TE-ID. + * in PcTERpt message. + */ + @Test + public void teReportMessageTest2() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x28, // common header + 0x0E, 0x10, 0x00, 0x24, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x08, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for TE Object (Routing Universe TLV) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest3() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x1c, // common header + 0x0E, 0x10, 0x00, 0x18, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv. + * OSPFareaIDsubTlv, RouterIDSubTlv)). + * in PcTERpt message. + */ + @Test + public void teReportMessageTest4() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x44, // common header + 0x0E, 0x10, 0x00, 0x40, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest5() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x3C, // common header + 0x0E, 0x10, 0x00, 0x38, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x1C, // Local TE Node Descriptors TLV + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(OSPFareaIDsubTlv, + * RouterIDSubTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest6() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x34, // common header + 0x0E, 0x10, 0x00, 0x30, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x14, // Local TE Node Descriptors TLV + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(RouterIDSubTlv)). + * in PcTERpt message. + */ + @Test + public void teReportMessageTest7() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x2C, // common header + 0x0E, 0x10, 0x00, 0x28, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x0C, // Local TE Node Descriptors TLV + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11}; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for TE Object (Routing Universe TLV,Local TE Node Descriptors TLV) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest8() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x20, // common header + 0x0E, 0x10, 0x00, 0x1C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x00 // Local TE Node Descriptors TLV + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv. + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv. + * OSPFareaIDsubTlv, RouterIDSubTlv)). + * in PcTERpt message. + */ + @Test + public void teReportMessageTest9() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x6C, // common header + 0x0E, 0x10, 0x00, 0x68, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest10() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x64, // common header + 0x0E, 0x10, 0x00, 0x60, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x1C, //RemoteTENodeDescriptorsTLV + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(OSPFareaIDsubTlv, RouterIDSubTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest11() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x5C, // common header + 0x0E, 0x10, 0x00, 0x58, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x14, //RemoteTENodeDescriptorsTLV + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(RouterIDSubTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest12() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x54, // common header + 0x0E, 0x10, 0x00, 0x50, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x0c, //RemoteTENodeDescriptorsTLV + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest13() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, 0x48, // common header + 0x0E, 0x10, 0x00, 0x44, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x00, //RemoteTENodeDescriptorsTLV + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest14() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0x8C, // common header + 0x0E, 0x10, 0x00, (byte) 0x88, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV( + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest15() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0x80, // common header + 0x0E, 0x10, 0x00, (byte) 0x7C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x10, //TELinkDescriptorsTLV + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(IPv4NeighborAddressTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest16() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0x78, // common header + 0x0E, 0x10, 0x00, (byte) 0x74, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x08, //TELinkDescriptorsTLV + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest17() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0x70, // common header + 0x0E, 0x10, 0x00, (byte) 0x6C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x00, //TELinkDescriptorsTLV + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest18() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0xC0, // common header + 0x0E, 0x10, 0x00, (byte) 0xbC, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x30, //TENodeAttributesTlv + 0x00, 0x0E, 0x00, 0x01, //NodeFlagBitsTlv + (byte) 0x90, 0x00, 0x00, 0x00, + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(NodeFlagBitsTlv + * OpaqueNodeAttributeTlv, NodeNameTlv, ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest19() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0xC0, // common header + 0x0E, 0x10, 0x00, (byte) 0xBC, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x30, //TENodeAttributesTlv + 0x00, 0x0E, 0x00, 0x01, //NodeFlagBitsTlv + (byte) 0x90, 0x00, 0x00, 0x00, + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(OpaqueNodeAttributeTlv + * NodeNameTlv, ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest20() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0xB8, // common header + 0x0E, 0x10, 0x00, (byte) 0xB4, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x28, //TENodeAttributesTlv + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv. + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(OpaqueNodeAttributeTlv + * ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest21() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x00, (byte) 0xAC, // common header + 0x0E, 0x10, 0x00, (byte) 0xA8, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x1C, //TENodeAttributesTlv + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv. + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv. + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv. + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(NodeFlagBitsTlv. + * OpaqueNodeAttributeTlv, NodeNameTlv, ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv). + * TELinkAttributesTlv(IPv4TERouterIdOfRemoteNodeTlv, IPv6TERouterIdofRemoteNodeTlv, AdministrativeGroupTlv. + * MaximumLinkBandwidthTlv, MaximumReservableLinkBandwidthTlv, UnreservedBandwidthTlv, TEDefaultMetricTlv. + * LinkProtectionTypeTlv, MPLSProtocolMaskTlv, IGPMetricTlv:, SharedRiskLinkGroupTlv. + * OpaqueLinkAttributeTlv, LinkNameTlv)). + * in PcTERpt message. + */ + @Test + public void teReportMessageTest22() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x01, (byte) 0x120, // common header + 0x0E, 0x10, 0x01, (byte) 0x1C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x28, //TENodeAttributesTlv + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02, + 0x07, 0x69, 0x00, 0x64, //TELinkAttributesTlv + 0x05, 0x3C, 0x00, 0x04, //IPv4TERouterIdOfRemoteNodeTlv + 0x00, 0x07, 0x08, 0x00, + 0x00, 0x03, 0x00, 0x04, //AdministrativeGroupTlv + 0x00, 0x09, 0x08, 0x00, + 0x00, 0x09, 0x00, 0x04, //MaximumLinkBandwidthTlv + 0x00, 0x09, 0x00, 0x00, + 0x00, 0x0a, 0x00, 0x04, //MaximumReservableLinkBandwidthTlv + 0x00, 0x10, 0x00, 0x00, + 0x00, 0x0b, 0x00, 0x04, //UnreservedBandwidthTlv + 0x00, 0x00, (byte) 0x90, 0x00, + 0x34, 0x58, 0x00, 0x04, //TEDefaultMetricTlv + 0x00, (byte) 0x99, 0x09, 0x00, + 0x00, 0x14, 0x00, 0x02, //LinkProtectionTypeTlv + 0x09, 0x00, 0x00, 0x00, + 0x04, 0x46, 0x00, 0x01, //MPLSProtocolMaskTlv + (byte) 0x80, 0x00, 0x00, 0x00, + 0x04, 0x47, 0x00, 0x03, //IGPMetricTlv + 0x09, (byte) 0x89, 0x07, 0x00, + 0x04, 0x48, 0x00, 0x08, //SharedRiskLinkGroupTlv + 0x04, 0x47, 0x00, 0x03, + 0x04, 0x47, 0x00, 0x03, //OpaqueLinkAttributeTlv + 0x04, 0x49, 0x00, 0x04, + 0x04, 0x47, 0x00, 0x03, + 0x04, 0x4A, 0x00, 0x04, //LinkNameTlv + 0x04, 0x47, 0x00, 0x03 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(NodeFlagBitsTlv + * OpaqueNodeAttributeTlv, NodeNameTlv, ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv) + * TELinkAttributesTlv(IPv4TERouterIdOfRemoteNodeTlv, IPv6TERouterIdofRemoteNodeTlv, AdministrativeGroupTlv + * MaximumLinkBandwidthTlv, MaximumReservableLinkBandwidthTlv, UnreservedBandwidthTlv, TEDefaultMetricTlv + * LinkProtectionTypeTlv, MPLSProtocolMaskTlv, IGPMetricTlv:, SharedRiskLinkGroupTlv + * OpaqueLinkAttributeTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest23() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x01, (byte) 0x118, // common header + 0x0E, 0x10, 0x01, (byte) 0x14, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x28, //TENodeAttributesTlv + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02, + 0x07, 0x69, 0x00, 0x5C, //TELinkAttributesTlv + 0x05, 0x3C, 0x00, 0x04, //IPv4TERouterIdOfRemoteNodeTlv + 0x00, 0x07, 0x08, 0x00, + 0x00, 0x03, 0x00, 0x04, //AdministrativeGroupTlv + 0x00, 0x09, 0x08, 0x00, + 0x00, 0x09, 0x00, 0x04, //MaximumLinkBandwidthTlv + 0x00, 0x09, 0x00, 0x00, + 0x00, 0x0a, 0x00, 0x04, //MaximumReservableLinkBandwidthTlv + 0x00, 0x10, 0x00, 0x00, + 0x00, 0x0b, 0x00, 0x04, //UnreservedBandwidthTlv + 0x00, 0x00, (byte) 0x90, 0x00, + 0x34, 0x58, 0x00, 0x04, //TEDefaultMetricTlv + 0x00, (byte) 0x99, 0x09, 0x00, + 0x00, 0x14, 0x00, 0x02, //LinkProtectionTypeTlv + 0x09, 0x00, 0x00, 0x00, + 0x04, 0x46, 0x00, 0x01, //MPLSProtocolMaskTlv + (byte) 0x80, 0x00, 0x00, 0x00, + 0x04, 0x47, 0x00, 0x03, //IGPMetricTlv + 0x09, (byte) 0x89, 0x07, 0x00, + 0x04, 0x48, 0x00, 0x08, //SharedRiskLinkGroupTlv + 0x04, 0x47, 0x00, 0x03, + 0x04, 0x47, 0x00, 0x03, //OpaqueLinkAttributeTlv + 0x04, 0x49, 0x00, 0x04, + 0x04, 0x47, 0x00, 0x03 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(NodeFlagBitsTlv + * OpaqueNodeAttributeTlv, NodeNameTlv, ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv) + * TELinkAttributesTlv(IPv4TERouterIdOfRemoteNodeTlv, IPv6TERouterIdofRemoteNodeTlv, AdministrativeGroupTlv + * MaximumLinkBandwidthTlv, MaximumReservableLinkBandwidthTlv, UnreservedBandwidthTlv, TEDefaultMetricTlv + * LinkProtectionTypeTlv, MPLSProtocolMaskTlv, IGPMetricTlv:, SharedRiskLinkGroupTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest24() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x01, (byte) 0x110, // common header + 0x0E, 0x10, 0x01, (byte) 0x0C, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x28, //TENodeAttributesTlv + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02, + 0x07, 0x69, 0x00, 0x54, //TELinkAttributesTlv + 0x05, 0x3C, 0x00, 0x04, //IPv4TERouterIdOfRemoteNodeTlv + 0x00, 0x07, 0x08, 0x00, + 0x00, 0x03, 0x00, 0x04, //AdministrativeGroupTlv + 0x00, 0x09, 0x08, 0x00, + 0x00, 0x09, 0x00, 0x04, //MaximumLinkBandwidthTlv + 0x00, 0x09, 0x00, 0x00, + 0x00, 0x0a, 0x00, 0x04, //MaximumReservableLinkBandwidthTlv + 0x00, 0x10, 0x00, 0x00, + 0x00, 0x0b, 0x00, 0x04, //UnreservedBandwidthTlv + 0x00, 0x00, (byte) 0x90, 0x00, + 0x34, 0x58, 0x00, 0x04, //TEDefaultMetricTlv + 0x00, (byte) 0x99, 0x09, 0x00, + 0x00, 0x14, 0x00, 0x02, //LinkProtectionTypeTlv + 0x09, 0x00, 0x00, 0x00, + 0x04, 0x46, 0x00, 0x01, //MPLSProtocolMaskTlv + (byte) 0x80, 0x00, 0x00, 0x00, + 0x04, 0x47, 0x00, 0x03, //IGPMetricTlv + 0x09, (byte) 0x89, 0x07, 0x00, + 0x04, 0x48, 0x00, 0x08, //SharedRiskLinkGroupTlv + 0x04, 0x47, 0x00, 0x03, + 0x04, 0x47, 0x00, 0x03 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } + + /** + * This test case checks for + * TE Object (Routing Universe TLV,Local TE Node Descriptors TLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), RemoteTENodeDescriptorsTLV(AutonomousSystemTlv, BGPLSidentifierTlv + * OSPFareaIDsubTlv, RouterIDSubTlv), TELinkDescriptorsTLV(LinkLocalRemoteIdentifiersTlv + * IPv4InterfaceAddressTlv, IPv4NeighborAddressTlv), TENodeAttributesTlv(NodeFlagBitsTlv + * OpaqueNodeAttributeTlv, NodeNameTlv, ISISAreaIdentifierTlv, IPv4TERouterIdOfLocalNodeTlv) + * TELinkAttributesTlv(IPv4TERouterIdOfRemoteNodeTlv, IPv6TERouterIdofRemoteNodeTlv, AdministrativeGroupTlv + * MaximumLinkBandwidthTlv, MaximumReservableLinkBandwidthTlv, UnreservedBandwidthTlv, TEDefaultMetricTlv + * LinkProtectionTypeTlv, MPLSProtocolMaskTlv, IGPMetricTlv)) + * in PcTERpt message. + */ + @Test + public void teReportMessageTest25() throws PcepParseException { + + byte[] teReportMsg = new byte[]{0x20, 0x0E, 0x01, (byte) 0x104, // common header + 0x0E, 0x10, 0x01, 0x00, // TE Object Header + 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x10, // TE-ID + 0x00, 0x0E, 0x00, 0x08, // Routing Universe TLV + 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, + 0x06, 0x65, 0x00, 0x24, // Local TE Node Descriptors TLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xEB, 0x00, 0x24, //RemoteTENodeDescriptorsTLV + 0x00, 0x64, 0x00, 0x04, //AutonomousSystemTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x11, 0x00, 0x04, //BGPLSidentifierTlv + 0x00, 0x00, 0x00, 0x11, + 0x02, 0x58, 0x00, 0x04, //OSPFareaIDsubTlv + 0x00, 0x00, 0x00, 0x11, + 0x03, (byte) 0xE8, 0x00, 0x08, //RouterIDSubTlv + 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x00, 0x11, + 0x04, 0x2E, 0x00, 0x1C, //TELinkDescriptorsTLV + 0x00, 0x04, 0x00, 0x08, //LinkLocalRemoteIdentifiersTlv + 0x01, 0x11, 0x00, 0x09, + 0x01, 0x21, 0x00, 0x09, + 0x00, 0x06, 0x00, 0x04, //IPv4InterfaceAddressTlv + 0x01, 0x01, 0x01, 0x01, + 0x00, 0x08, 0x00, 0x04, //IPv4NeighborAddressTlv + 0x01, 0x011, 0x01, 0x10, + 0x04, (byte) 0xF3, 0x00, 0x28, //TENodeAttributesTlv + 0x03, (byte) 0xE9, 0x00, 0x04, //OpaqueNodeAttributeTlv + 0x01, 0x011, 0x01, 0x10, + 0x03, (byte) 0xEF, 0x00, 0x08, //NodeNameTlv + 0x08, 0x00, 0x01, 0x09, + 0x08, 0x00, 0x01, 0x09, + 0x00, 0x6B, 0x00, 0x08, //ISISAreaIdentifierTlv + 0x20, 0x01, 0x22, 0x01, + 0x20, 0x01, 0x22, 0x01, + 0x00, (byte) 0x86, 0x00, 0x04, //IPv4TERouterIdOfLocalNodeTlv + 0x00, 0x01, 0x01, 0x02, + 0x07, 0x69, 0x00, 0x48, //TELinkAttributesTlv + 0x05, 0x3C, 0x00, 0x04, //IPv4TERouterIdOfRemoteNodeTlv + 0x00, 0x07, 0x08, 0x00, + 0x00, 0x03, 0x00, 0x04, //AdministrativeGroupTlv + 0x00, 0x09, 0x08, 0x00, + 0x00, 0x09, 0x00, 0x04, //MaximumLinkBandwidthTlv + 0x00, 0x09, 0x00, 0x00, + 0x00, 0x0a, 0x00, 0x04, //MaximumReservableLinkBandwidthTlv + 0x00, 0x10, 0x00, 0x00, + 0x00, 0x0b, 0x00, 0x04, //UnreservedBandwidthTlv + 0x00, 0x00, (byte) 0x90, 0x00, + 0x34, 0x58, 0x00, 0x04, //TEDefaultMetricTlv + 0x00, (byte) 0x99, 0x09, 0x00, + 0x00, 0x14, 0x00, 0x02, //LinkProtectionTypeTlv + 0x09, 0x00, 0x00, 0x00, + 0x04, 0x46, 0x00, 0x01, //MPLSProtocolMaskTlv + (byte) 0x80, 0x00, 0x00, 0x00, + 0x04, 0x47, 0x00, 0x03, //IGPMetricTlv + 0x09, (byte) 0x89, 0x07, 0x00 + }; + + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(teReportMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + byte[] testReportMsg = {0}; + + assertThat(message, instanceOf(PcepTEReportMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + + int readLen = buf.writerIndex(); + testReportMsg = new byte[readLen]; + buf.readBytes(testReportMsg, 0, readLen); + + assertThat(testReportMsg, is(teReportMsg)); + } +} diff --git a/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepUpdateMsgExtTest.java b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepUpdateMsgExtTest.java new file mode 100644 index 00000000..40234a69 --- /dev/null +++ b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepUpdateMsgExtTest.java @@ -0,0 +1,1269 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.pcepio.protocol; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +/** + * Test cases for PCEP update message. + */ +public class PcepUpdateMsgExtTest { + + /** + * This test case is for SRP object(symbolic path tlv), LSP object(StatefulLspDbVerTlv), ERO object, + * Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest1() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x8c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x38, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulIPv4LspIdentidiersTlv), ERO object, + * LSPA, Bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest2() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSP object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object, ERO object, LSPA, bandwidth object + * Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest3() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspErrorCodeTlv), ERO object,bandwidth object + * Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest4() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspDbVerTlv), ERO object,bandwidth object + * Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest5() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(SymbolicPathNameTlv), ERO object, LSPA, bandwidth object + * Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest6() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(SymbolicPathNameTlv), ERO object, + * bandwidth object Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest7() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulIPv4LspIdentidiersTlv), ERO object,LSPA + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest8() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulRsvpErrorSpecTlv), ERO object,LSPA + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest9() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x18, 0x00, 0x00, 0x10, 0x03, + 0x00, 0x15, 0x00, 0x0c, //StatefulRsvpErrorSpecTlv + 0x00, 0x0c, 0x06, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x05, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulRsvpErrorSpecTlv), ERO object,LSPA + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest10() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPa object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspDbVerTlv), ERO object,LSPA + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest11() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00}; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(SymbolicPathNameTlv), ERO object,LSPA + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest12() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(SymbolicPathNameTlv), ERO object,LSPA + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest13() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulIPv4LspIdentidiersTlv), ERO object,LSPA + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest14() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object, ERO object,LSPA + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest15() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x4c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //lspa object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspErrorCodeTlv), ERO object,LSPA + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest16() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspDbVerTlv), ERO object,LSPA + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest17() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(SymbolicPathNameTlv), ERO object,LSPA + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest18() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(SymbolicPathNameTlv), ERO object, + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest19() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulIPv4LspIdentidiersTlv), ERO object, + * Bandwidth , metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest20() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object, ERO object, + * Bandwidth , metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest21() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x40, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspErrorCodeTlv), ERO object, + * Bandwidth , metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest22() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x48, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspDbVerTlv), ERO object, + * Bandwidth , metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest23() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x4c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(SymbolicPathNameTlv), ERO object, + * Bandwidth , metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest24() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x48, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(SymbolicPathNameTlv), ERO object, + * Bandwidth , metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest25() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulIPv4LspIdentidiersTlv), ERO object, + * LSPA object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest26() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object, ERO object, + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest27() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x34, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object, LSP object(StatefulLspErrorCodeTlv), ERO object, + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest28() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x40, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(StatefulLspErrorCodeTlv), ERO object, + * lspa object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest29() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(StatefulLspErrorCodeTlv), ERO object, + * bandwidth object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest30() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x48, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(SymbolicPathNameTlv), LSP object(StatefulLspErrorCodeTlv), ERO object, + * metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest31() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x4c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case is for SRP object(symbolic path tlv), LSP object(StatefulLspDbVerTlv), ERO object, + * Metric object in PcepUpdate message. + */ + @Test + public void pcepUpdateMsgTest32() throws PcepParseException { + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x14, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x17, 0x00, 0x08, //StatefulLspDbVerTlv + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO Object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } +} + diff --git a/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepUpdateMsgTest.java b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepUpdateMsgTest.java new file mode 100644 index 00000000..1db30641 --- /dev/null +++ b/framework/src/onos/pcep/pcepio/src/test/java/org/onosproject/pcepio/protocol/PcepUpdateMsgTest.java @@ -0,0 +1,1423 @@ +/* + * Copyright 2014-2015 Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.pcepio.protocol; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.jboss.netty.buffer.ChannelBuffers; +import org.junit.Test; +import org.onosproject.pcepio.exceptions.PcepParseException; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.instanceOf; +import static org.hamcrest.core.Is.is; + +public class PcepUpdateMsgTest { + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), ERO in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest1() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x30, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, (byte) 0xb6, 0x02, 0x4e, 0x1f, //StatefulIPv4LspIdentidiersTlv + 0x00, 0x01, (byte) 0x80, 0x01, (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x04 }; //ERO object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP(SymbolicPathNameTlv), LSP (StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspErrorCodeTlv), ERO, LSPA, Metric-list in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest2() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x94, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object // lsp object + 0x00, 0x12, 0x00, 0x10, (byte) 0xb6, 0x02, 0x4e, 0x1f, //StatefulIPv4LspIdentidiersTlv + 0x00, 0x01, (byte) 0x80, 0x01, (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x24, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, + 0x01, 0x02, 0x04, 0x00, 0x01, 0x08, 0x12, 0x01, 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv), + * ERO objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest3() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x38, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x04 }; //ERO object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv), ERO objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest4() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x40, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x04 }; //ERO object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv), ERO objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest5() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x40, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x04 }; //ERO object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest6() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x48, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x04 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest7() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x48, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x04}; //ERO object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO (IPv4SubObject) objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest8() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x50, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x0c, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO (IPv4SubObject, IPv4SubObject) objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest9() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO (IPv4SubObject, IPv4SubObject), LSPA objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest10() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x6c, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO (IPv4SubObject, IPv4SubObject),LSPA, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest11() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x78, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO (IPv4SubObject, IPv4SubObject),LSPA, metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest12() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv), ERO (IPv4SubObject, IPv4SubObject),LSPA, metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest13() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * ERO (IPv4SubObject, IPv4SubObject),LSPA, metric Object objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest14() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv), + * ERO (IPv4SubObject, IPv4SubObject),LSPA, metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest15() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject),LSPA, metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest16() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x60, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject),LSPA objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest17() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1c, 0x00, 0x00, 0x10, 0x05, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00 }; + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject),Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest18() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x4c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject),Metric-list objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest19() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x58, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20, //Metric object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv),ERO (IPv4SubObject, IPv4SubObject),LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest20() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x80, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject), Bandwidth objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest21() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x48, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest22() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5C, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00 }; //Bandwidth object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest23() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv) + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest24() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv) + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest25() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x70, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x24, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv) ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, + * Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest26() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x78, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv, SymbolicPathNameTlv, + * StatefulLspErrorCodeTlv) ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, + * Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest27() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x78, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, StatefulIPv4LspIdentidiersTlv, + * SymbolicPathNameTlv, StatefulLspErrorCodeTlv), ERO (IPv4SubObject, IPv4SubObject), + * LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest28() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x80, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x2c, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulIPv4LspIdentidiersTlv), + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest29() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x68, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x1C, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x12, 0x00, 0x10, //StatefulIPv4LspIdentidiersTlv + (byte) 0xb6, 0x02, 0x4e, 0x1f, 0x00, 0x01, (byte) 0x80, 0x01, + (byte) 0xb6, 0x02, 0x4e, 0x1f, (byte) 0xb6, 0x02, 0x4e, 0x20, + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP, + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest30() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x08, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20}; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (StatefulLspErrorCodeTlv), + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest31() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x14, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08, //StatefulLspErrorCodeTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP, + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest32() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x54, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x8, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv), + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest33() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x5c, + 0x21, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } + + /** + * This test case checks for SRP, LSP (SymbolicPathNameTlv, SymbolicPathNameTlv), + * ERO (IPv4SubObject, IPv4SubObject), LSPA, Bandwidth, Metric objects in PcUpd message. + */ + @Test + public void pcepUpdateMsgTest34() throws PcepParseException { + + byte[] updateMsg = new byte[] {0x20, 0x0b, 0x00, (byte) 0x64, + 0x21, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, //SRP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x20, 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x03, //LSP object + 0x00, 0x11, 0x00, 0x02, 0x54, 0x31, 0x00, 0x00, //SymbolicPathNameTlv + 0x07, 0x10, 0x00, 0x14, 0x01, 0x08, 0x11, 0x01, //ERO object + 0x01, 0x01, 0x04, 0x00, 0x01, 0x08, 0x11, 0x01, + 0x01, 0x01, 0x04, 0x00, + 0x09, 0x10, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, //LSPA object + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x00, 0x00, + 0x05, 0x20, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, //Bandwidth object + 0x06, 0x10, 0x00, 0x0c, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x20 }; //Metric object + + byte[] testupdateMsg = {0}; + ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(); + buffer.writeBytes(updateMsg); + + PcepMessageReader<PcepMessage> reader = PcepFactories.getGenericReader(); + PcepMessage message = null; + + message = reader.readFrom(buffer); + + assertThat(message, instanceOf(PcepUpdateMsg.class)); + ChannelBuffer buf = ChannelBuffers.dynamicBuffer(); + message.writeTo(buf); + testupdateMsg = buf.array(); + + int readLen = buf.writerIndex() - 0; + testupdateMsg = new byte[readLen]; + buf.readBytes(testupdateMsg, 0, readLen); + + assertThat(testupdateMsg, is(updateMsg)); + } +} |