X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-rest-connector%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Frestconf%2Fimpl%2Ftest%2FRestGetOperationTest.java;h=41a1c3827d21973180e01b7fd3cb11e2e73f993c;hp=f0a232fba670539c5a872e5894a89bd7c214c778;hb=92f1fd15e99ce5b9e52612c0b52f70cd661b99cc;hpb=0601a12e4717510c404ca9a4432727c42745c1ab

diff --git a/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/RestGetOperationTest.java b/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/RestGetOperationTest.java
index f0a232fba6..41a1c3827d 100644
--- a/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/RestGetOperationTest.java
+++ b/opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/RestGetOperationTest.java
@@ -7,8 +7,8 @@
  */
 package org.opendaylight.controller.sal.restconf.impl.test;
 
-import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.Matchers.any;
@@ -77,7 +77,7 @@ public class RestGetOperationTest extends JerseyTest {
         Object key;
         Object data; // List for a CompositeNode, value Object for a SimpleNode
 
-        NodeData( Object key, Object data ) {
+        NodeData( final Object key, final Object data ) {
             this.key = key;
             this.data = data;
         }
@@ -186,7 +186,7 @@ public class RestGetOperationTest extends JerseyTest {
      */
     @Test
     public void getDataWithSlashesBehindMountPoint() throws UnsupportedEncodingException, URISyntaxException,
-            ParseException {
+    ParseException {
         InstanceIdentifier awaitedInstanceIdentifier = prepareInstanceIdentifierForList();
         when(
                 brokerFacade.readConfigurationDataBehindMountPoint(any(MountInstance.class),
@@ -214,7 +214,7 @@ public class RestGetOperationTest extends JerseyTest {
         parameters.add(new InstanceIdentifier.NodeIdentifier(qNameCont));
         parameters.add(new InstanceIdentifier.NodeIdentifierWithPredicates(qNameList, qNameKeyList,
                 "GigabitEthernet0/0/0/0"));
-        return new InstanceIdentifier(parameters);
+        return InstanceIdentifier.create(parameters);
     }
 
     @Test
@@ -356,7 +356,7 @@ public class RestGetOperationTest extends JerseyTest {
 
     }
 
-    private Matcher validateOperationsResponseJson(String searchIn, String rpcName, String moduleName) {
+    private Matcher validateOperationsResponseJson(final String searchIn, final String rpcName, final String moduleName) {
         StringBuilder regex = new StringBuilder();
         regex.append("^");
 
@@ -390,7 +390,7 @@ public class RestGetOperationTest extends JerseyTest {
 
     }
 
-    private Matcher validateOperationsResponseXml(String searchIn, String rpcName, String namespace) {
+    private Matcher validateOperationsResponseXml(final String searchIn, final String rpcName, final String namespace) {
         StringBuilder regex = new StringBuilder();
 
         regex.append("^");
@@ -448,11 +448,11 @@ public class RestGetOperationTest extends JerseyTest {
         assertTrue(
                 "module1-behind-mount-point in json wasn't found",
                 prepareXmlRegex("module1-behind-mount-point", "2014-02-03", "module:1:behind:mount:point", responseBody)
-                        .find());
+                .find());
         assertTrue(
                 "module2-behind-mount-point in json wasn't found",
                 prepareXmlRegex("module2-behind-mount-point", "2014-02-04", "module:2:behind:mount:point", responseBody)
-                        .find());
+                .find());
 
     }
 
@@ -488,13 +488,13 @@ public class RestGetOperationTest extends JerseyTest {
         assertTrue(
                 "module1-behind-mount-point in json wasn't found",
                 prepareXmlRegex("module1-behind-mount-point", "2014-02-03", "module:1:behind:mount:point", responseBody)
-                        .find());
+                .find());
         split = responseBody.split("<module");
         assertEquals("<module element is returned more then once", 2, split.length);
 
     }
 
-    private void validateModulesResponseXml(Response response) {
+    private void validateModulesResponseXml(final Response response) {
         assertEquals(200, response.getStatus());
         String responseBody = response.readEntity(String.class);
 
@@ -506,7 +506,7 @@ public class RestGetOperationTest extends JerseyTest {
                 .find());
     }
 
-    private void validateModulesResponseJson(Response response) {
+    private void validateModulesResponseJson(final Response response) {
         assertEquals(200, response.getStatus());
         String responseBody = response.readEntity(String.class);
 
@@ -518,7 +518,7 @@ public class RestGetOperationTest extends JerseyTest {
                 .find());
     }
 
-    private Matcher prepareJsonRegex(String module, String revision, String namespace, String searchIn) {
+    private Matcher prepareJsonRegex(final String module, final String revision, final String namespace, final String searchIn) {
         StringBuilder regex = new StringBuilder();
         regex.append("^");
 
@@ -544,7 +544,7 @@ public class RestGetOperationTest extends JerseyTest {
 
     }
 
-    private Matcher prepareXmlRegex(String module, String revision, String namespace, String searchIn) {
+    private Matcher prepareXmlRegex(final String module, final String revision, final String namespace, final String searchIn) {
         StringBuilder regex = new StringBuilder();
         regex.append("^");
 
@@ -572,13 +572,13 @@ public class RestGetOperationTest extends JerseyTest {
         return ptrn.matcher(searchIn);
     }
 
-    private void prepareMockForModulesTest(ControllerContext mockedControllerContext) throws FileNotFoundException {
+    private void prepareMockForModulesTest(final ControllerContext mockedControllerContext) throws FileNotFoundException {
         SchemaContext schemaContext = TestUtils.loadSchemaContext("/modules");
         mockedControllerContext.setGlobalSchema(schemaContext);
         // when(mockedControllerContext.getGlobalSchema()).thenReturn(schemaContext);
     }
 
-    private int get(String uri, String mediaType) {
+    private int get(final String uri, final String mediaType) {
         return target(uri).request(mediaType).get().getStatus();
     }
 
@@ -621,179 +621,179 @@ public class RestGetOperationTest extends JerseyTest {
         ControllerContext.getInstance().setGlobalSchema( schemaContextModules );
 
         CompositeNode depth1Cont = toCompositeNode(
-            toCompositeNodeData( toNestedQName( "depth1-cont" ),
-                toCompositeNodeData( toNestedQName( "depth2-cont1" ),
-                    toCompositeNodeData( toNestedQName( "depth3-cont1" ),
-                        toCompositeNodeData( toNestedQName( "depth4-cont1" ),
-                            toSimpleNodeData( toNestedQName( "depth5-leaf1" ), "depth5-leaf1-value" )
-                        ),
-                        toSimpleNodeData( toNestedQName( "depth4-leaf1" ), "depth4-leaf1-value" )
-                    ),
-                    toSimpleNodeData( toNestedQName( "depth3-leaf1" ), "depth3-leaf1-value" )
-                ),
-                toCompositeNodeData( toNestedQName( "depth2-cont2" ),
-                    toCompositeNodeData( toNestedQName( "depth3-cont2" ),
-                        toCompositeNodeData( toNestedQName( "depth4-cont2" ),
-                            toSimpleNodeData( toNestedQName( "depth5-leaf2" ), "depth5-leaf2-value" )
-                        ),
-                        toSimpleNodeData( toNestedQName( "depth4-leaf2" ), "depth4-leaf2-value" )
-                    ),
-                    toSimpleNodeData( toNestedQName( "depth3-leaf2" ), "depth3-leaf2-value" )
-                ),
-                toSimpleNodeData( toNestedQName( "depth2-leaf1" ), "depth2-leaf1-value" )
-            ) );
+                toCompositeNodeData( toNestedQName( "depth1-cont" ),
+                        toCompositeNodeData( toNestedQName( "depth2-cont1" ),
+                                toCompositeNodeData( toNestedQName( "depth3-cont1" ),
+                                        toCompositeNodeData( toNestedQName( "depth4-cont1" ),
+                                                toSimpleNodeData( toNestedQName( "depth5-leaf1" ), "depth5-leaf1-value" )
+                                                ),
+                                                toSimpleNodeData( toNestedQName( "depth4-leaf1" ), "depth4-leaf1-value" )
+                                        ),
+                                        toSimpleNodeData( toNestedQName( "depth3-leaf1" ), "depth3-leaf1-value" )
+                                ),
+                                toCompositeNodeData( toNestedQName( "depth2-cont2" ),
+                                        toCompositeNodeData( toNestedQName( "depth3-cont2" ),
+                                                toCompositeNodeData( toNestedQName( "depth4-cont2" ),
+                                                        toSimpleNodeData( toNestedQName( "depth5-leaf2" ), "depth5-leaf2-value" )
+                                                        ),
+                                                        toSimpleNodeData( toNestedQName( "depth4-leaf2" ), "depth4-leaf2-value" )
+                                                ),
+                                                toSimpleNodeData( toNestedQName( "depth3-leaf2" ), "depth3-leaf2-value" )
+                                        ),
+                                        toSimpleNodeData( toNestedQName( "depth2-leaf1" ), "depth2-leaf1-value" )
+                        ) );
 
         when( brokerFacade.readConfigurationData( any( InstanceIdentifier.class ) ) )
-            .thenReturn( depth1Cont );
+        .thenReturn( depth1Cont );
 
         // Test config with depth 1
 
         Response response = target( "/config/nested-module:depth1-cont" ).queryParam( "depth", "1" )
-                                .request( "application/xml" ).get();
+                .request( "application/xml" ).get();
 
         verifyXMLResponse( response, expectEmptyContainer( "depth1-cont" ) );
 
         // Test config with depth 2
 
         response = target( "/config/nested-module:depth1-cont" ).queryParam( "depth", "2" )
-                       .request( "application/xml" ).get();
+                .request( "application/xml" ).get();
 
-//        String xml="<depth1-cont><depth2-cont1/><depth2-cont2/><depth2-leaf1>depth2-leaf1-value</depth2-leaf1></depth1-cont>";
-//        Response mr=mock(Response.class);
-//        when(mr.getEntity()).thenReturn( new java.io.StringBufferInputStream(xml) );
+        //        String xml="<depth1-cont><depth2-cont1/><depth2-cont2/><depth2-leaf1>depth2-leaf1-value</depth2-leaf1></depth1-cont>";
+        //        Response mr=mock(Response.class);
+        //        when(mr.getEntity()).thenReturn( new java.io.StringBufferInputStream(xml) );
 
         verifyXMLResponse( response,
-            expectContainer( "depth1-cont",
-                expectEmptyContainer( "depth2-cont1" ),
-                expectEmptyContainer( "depth2-cont2" ),
-                expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
-            ) );
+                expectContainer( "depth1-cont",
+                        expectEmptyContainer( "depth2-cont1" ),
+                        expectEmptyContainer( "depth2-cont2" ),
+                        expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
+                        ) );
 
         // Test config with depth 3
 
         response = target( "/config/nested-module:depth1-cont" ).queryParam( "depth", "3" )
-                       .request( "application/xml" ).get();
+                .request( "application/xml" ).get();
 
         verifyXMLResponse( response,
-            expectContainer( "depth1-cont",
-                expectContainer( "depth2-cont1",
-                    expectEmptyContainer( "depth3-cont1" ),
-                    expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
-                ),
-                expectContainer( "depth2-cont2",
-                    expectEmptyContainer( "depth3-cont2" ),
-                    expectLeaf( "depth3-leaf2", "depth3-leaf2-value" )
-                ),
-                expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
-           ) );
+                expectContainer( "depth1-cont",
+                        expectContainer( "depth2-cont1",
+                                expectEmptyContainer( "depth3-cont1" ),
+                                expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
+                                ),
+                                expectContainer( "depth2-cont2",
+                                        expectEmptyContainer( "depth3-cont2" ),
+                                        expectLeaf( "depth3-leaf2", "depth3-leaf2-value" )
+                                        ),
+                                        expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
+                        ) );
 
         // Test config with depth 4
 
         response = target( "/config/nested-module:depth1-cont" ).queryParam( "depth", "4" )
-                      .request( "application/xml" ).get();
+                .request( "application/xml" ).get();
 
         verifyXMLResponse( response,
-            expectContainer( "depth1-cont",
-                expectContainer( "depth2-cont1",
-                    expectContainer( "depth3-cont1",
-                        expectEmptyContainer( "depth4-cont1" ),
-                        expectLeaf( "depth4-leaf1", "depth4-leaf1-value" )
-                    ),
-                    expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
-                ),
-                expectContainer( "depth2-cont2",
-                    expectContainer( "depth3-cont2",
-                        expectEmptyContainer( "depth4-cont2" ),
-                        expectLeaf( "depth4-leaf2", "depth4-leaf2-value" )
-                    ),
-                    expectLeaf( "depth3-leaf2", "depth3-leaf2-value" )
-                ),
-                expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
-            ) );
+                expectContainer( "depth1-cont",
+                        expectContainer( "depth2-cont1",
+                                expectContainer( "depth3-cont1",
+                                        expectEmptyContainer( "depth4-cont1" ),
+                                        expectLeaf( "depth4-leaf1", "depth4-leaf1-value" )
+                                        ),
+                                        expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
+                                ),
+                                expectContainer( "depth2-cont2",
+                                        expectContainer( "depth3-cont2",
+                                                expectEmptyContainer( "depth4-cont2" ),
+                                                expectLeaf( "depth4-leaf2", "depth4-leaf2-value" )
+                                                ),
+                                                expectLeaf( "depth3-leaf2", "depth3-leaf2-value" )
+                                        ),
+                                        expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
+                        ) );
 
         // Test config with depth 5
 
         response = target( "/config/nested-module:depth1-cont" ).queryParam( "depth", "5" )
-                       .request( "application/xml" ).get();
+                .request( "application/xml" ).get();
 
         verifyXMLResponse( response,
-            expectContainer( "depth1-cont",
-                expectContainer( "depth2-cont1",
-                    expectContainer( "depth3-cont1",
-                        expectContainer( "depth4-cont1",
-                            expectLeaf( "depth5-leaf1", "depth5-leaf1-value" )
-                        ),
-                        expectLeaf( "depth4-leaf1", "depth4-leaf1-value" )
-                    ),
-                    expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
-                ),
-                expectContainer( "depth2-cont2",
-                    expectContainer( "depth3-cont2",
-                        expectContainer( "depth4-cont2",
-                            expectLeaf( "depth5-leaf2", "depth5-leaf2-value" )
-                        ),
-                        expectLeaf( "depth4-leaf2", "depth4-leaf2-value" )
-                    ),
-                    expectLeaf( "depth3-leaf2", "depth3-leaf2-value" )
-                ),
-                expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
-            ) );
+                expectContainer( "depth1-cont",
+                        expectContainer( "depth2-cont1",
+                                expectContainer( "depth3-cont1",
+                                        expectContainer( "depth4-cont1",
+                                                expectLeaf( "depth5-leaf1", "depth5-leaf1-value" )
+                                                ),
+                                                expectLeaf( "depth4-leaf1", "depth4-leaf1-value" )
+                                        ),
+                                        expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
+                                ),
+                                expectContainer( "depth2-cont2",
+                                        expectContainer( "depth3-cont2",
+                                                expectContainer( "depth4-cont2",
+                                                        expectLeaf( "depth5-leaf2", "depth5-leaf2-value" )
+                                                        ),
+                                                        expectLeaf( "depth4-leaf2", "depth4-leaf2-value" )
+                                                ),
+                                                expectLeaf( "depth3-leaf2", "depth3-leaf2-value" )
+                                        ),
+                                        expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
+                        ) );
 
         // Test config with depth unbounded
 
         response = target( "/config/nested-module:depth1-cont" ).queryParam( "depth", "unbounded" )
-                       .request( "application/xml" ).get();
+                .request( "application/xml" ).get();
 
         verifyXMLResponse( response,
-            expectContainer( "depth1-cont",
-                expectContainer( "depth2-cont1",
-                    expectContainer( "depth3-cont1",
-                        expectContainer( "depth4-cont1",
-                            expectLeaf( "depth5-leaf1", "depth5-leaf1-value" )
-                        ),
-                        expectLeaf( "depth4-leaf1", "depth4-leaf1-value" )
-                    ),
-                    expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
-                ),
-                expectContainer( "depth2-cont2",
-                    expectContainer( "depth3-cont2",
-                        expectContainer( "depth4-cont2",
-                            expectLeaf( "depth5-leaf2", "depth5-leaf2-value" )
-                        ),
-                        expectLeaf( "depth4-leaf2", "depth4-leaf2-value" )
-                    ),
-                    expectLeaf( "depth3-leaf2", "depth3-leaf2-value" )
-                ),
-                expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
-            ) );
+                expectContainer( "depth1-cont",
+                        expectContainer( "depth2-cont1",
+                                expectContainer( "depth3-cont1",
+                                        expectContainer( "depth4-cont1",
+                                                expectLeaf( "depth5-leaf1", "depth5-leaf1-value" )
+                                                ),
+                                                expectLeaf( "depth4-leaf1", "depth4-leaf1-value" )
+                                        ),
+                                        expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
+                                ),
+                                expectContainer( "depth2-cont2",
+                                        expectContainer( "depth3-cont2",
+                                                expectContainer( "depth4-cont2",
+                                                        expectLeaf( "depth5-leaf2", "depth5-leaf2-value" )
+                                                        ),
+                                                        expectLeaf( "depth4-leaf2", "depth4-leaf2-value" )
+                                                ),
+                                                expectLeaf( "depth3-leaf2", "depth3-leaf2-value" )
+                                        ),
+                                        expectLeaf( "depth2-leaf1", "depth2-leaf1-value" )
+                        ) );
 
         // Test operational
 
         CompositeNode depth2Cont1 = toCompositeNode(
-            toCompositeNodeData( toNestedQName( "depth2-cont1" ),
-                toCompositeNodeData( toNestedQName( "depth3-cont1" ),
-                    toCompositeNodeData( toNestedQName( "depth4-cont1" ),
-                        toSimpleNodeData( toNestedQName( "depth5-leaf1" ), "depth5-leaf1-value" )
-                    ),
-                    toSimpleNodeData( toNestedQName( "depth4-leaf1" ), "depth4-leaf1-value" )
-                ),
-                toSimpleNodeData( toNestedQName( "depth3-leaf1" ), "depth3-leaf1-value" )
-            ) );
+                toCompositeNodeData( toNestedQName( "depth2-cont1" ),
+                        toCompositeNodeData( toNestedQName( "depth3-cont1" ),
+                                toCompositeNodeData( toNestedQName( "depth4-cont1" ),
+                                        toSimpleNodeData( toNestedQName( "depth5-leaf1" ), "depth5-leaf1-value" )
+                                        ),
+                                        toSimpleNodeData( toNestedQName( "depth4-leaf1" ), "depth4-leaf1-value" )
+                                ),
+                                toSimpleNodeData( toNestedQName( "depth3-leaf1" ), "depth3-leaf1-value" )
+                        ) );
 
         when( brokerFacade.readOperationalData( any( InstanceIdentifier.class ) ) )
-             .thenReturn( depth2Cont1 );
+        .thenReturn( depth2Cont1 );
 
         response = target( "/operational/nested-module:depth1-cont/depth2-cont1" )
-                       .queryParam( "depth", "3" ).request( "application/xml" ).get();
+                .queryParam( "depth", "3" ).request( "application/xml" ).get();
 
         verifyXMLResponse( response,
-            expectContainer( "depth2-cont1",
-                expectContainer( "depth3-cont1",
-                    expectEmptyContainer( "depth4-cont1" ),
-                    expectLeaf( "depth4-leaf1", "depth4-leaf1-value" )
-                ),
-                expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
-            ) );
+                expectContainer( "depth2-cont1",
+                        expectContainer( "depth3-cont1",
+                                expectEmptyContainer( "depth4-cont1" ),
+                                expectLeaf( "depth4-leaf1", "depth4-leaf1-value" )
+                                ),
+                                expectLeaf( "depth3-leaf1", "depth3-leaf1-value" )
+                        ) );
     }
 
     @Test
@@ -805,12 +805,12 @@ public class RestGetOperationTest extends JerseyTest {
         paramMap.putSingle( "depth", "1o" );
         UriInfo mockInfo = mock( UriInfo.class );
         when( mockInfo.getQueryParameters( false ) ).thenAnswer(
-            new Answer<MultivaluedMap<String,String>>() {
-                @Override
-                public MultivaluedMap<String, String> answer( InvocationOnMock invocation ) {
-                    return paramMap;
-                }
-            } );
+                new Answer<MultivaluedMap<String,String>>() {
+                    @Override
+                    public MultivaluedMap<String, String> answer( final InvocationOnMock invocation ) {
+                        return paramMap;
+                    }
+                } );
 
         getDataWithInvalidDepthParameterTest( mockInfo );
 
@@ -821,18 +821,18 @@ public class RestGetOperationTest extends JerseyTest {
         getDataWithInvalidDepthParameterTest( mockInfo );
     }
 
-    private void getDataWithInvalidDepthParameterTest( UriInfo uriInfo ) {
+    private void getDataWithInvalidDepthParameterTest( final UriInfo uriInfo ) {
         try {
             restconfImpl.readConfigurationData( "nested-module:depth1-cont", uriInfo );
             fail( "Expected RestconfDocumentedException" );
         }
         catch( RestconfDocumentedException e ) {
             assertTrue( "Unexpected error message: " + e.getErrors().get( 0 ).getErrorMessage(),
-                        e.getErrors().get( 0 ).getErrorMessage().contains( "depth" ) );
+                    e.getErrors().get( 0 ).getErrorMessage().contains( "depth" ) );
         }
     }
 
-    private void verifyXMLResponse( Response response, NodeData nodeData ) {
+    private void verifyXMLResponse( final Response response, final NodeData nodeData ) {
 
         Document doc = TestUtils.loadDocumentFrom( (InputStream) response.getEntity() );
         assertNotNull( "Could not parse XML document", doc );
@@ -843,14 +843,14 @@ public class RestGetOperationTest extends JerseyTest {
     }
 
     @SuppressWarnings("unchecked")
-    private void verifyContainerElement( Element element, NodeData nodeData ) {
+    private void verifyContainerElement( final Element element, final NodeData nodeData ) {
 
         assertEquals( "Element local name", nodeData.key, element.getNodeName() );
 
         NodeList childNodes = element.getChildNodes();
         if( nodeData.data == null ) { // empty container
             assertTrue( "Expected no child elements for \"" + element.getNodeName() + "\"",
-                        childNodes.getLength() == 0 );
+                    childNodes.getLength() == 0 );
             return;
         }
 
@@ -868,41 +868,41 @@ public class RestGetOperationTest extends JerseyTest {
             Element actualElement = (Element)actualChild;
             NodeData expChild = expChildMap.remove( actualElement.getNodeName() );
             assertNotNull( "Unexpected child element for parent \"" + element.getNodeName() +
-                           "\": " + actualElement.getNodeName(), expChild );
+                    "\": " + actualElement.getNodeName(), expChild );
 
             if( expChild.data == null || expChild.data instanceof List ) {
                 verifyContainerElement( actualElement, expChild );
             }
             else {
                 assertEquals( "Text content for element: " + actualElement.getNodeName(),
-                              expChild.data, actualElement.getTextContent() );
+                        expChild.data, actualElement.getTextContent() );
             }
         }
 
         if( !expChildMap.isEmpty() ) {
             fail( "Missing elements for parent \"" + element.getNodeName() +
-                  "\": " + expChildMap.keySet() );
+                    "\": " + expChildMap.keySet() );
         }
     }
 
-    private NodeData expectContainer( String name, NodeData... childData ) {
+    private NodeData expectContainer( final String name, final NodeData... childData ) {
         return new NodeData( name, Lists.newArrayList( childData ) );
     }
 
-    private NodeData expectEmptyContainer( String name ) {
+    private NodeData expectEmptyContainer( final String name ) {
         return new NodeData( name, null );
     }
 
-    private NodeData expectLeaf( String name, Object value ) {
+    private NodeData expectLeaf( final String name, final Object value ) {
         return new NodeData( name, value );
     }
 
-    private QName toNestedQName( String localName ) {
+    private QName toNestedQName( final String localName ) {
         return QName.create( "urn:nested:module", "2014-06-3", localName );
     }
 
     @SuppressWarnings("unchecked")
-    private CompositeNode toCompositeNode( NodeData nodeData ) {
+    private CompositeNode toCompositeNode( final NodeData nodeData ) {
         CompositeNodeBuilder<ImmutableCompositeNode> builder = ImmutableCompositeNode.builder();
         builder.setQName( (QName) nodeData.key );
 
@@ -918,11 +918,11 @@ public class RestGetOperationTest extends JerseyTest {
         return builder.toInstance();
     }
 
-    private NodeData toCompositeNodeData( QName key, NodeData... childData ) {
+    private NodeData toCompositeNodeData( final QName key, final NodeData... childData ) {
         return new NodeData( key, Lists.newArrayList( childData ) );
     }
 
-    private NodeData toSimpleNodeData( QName key, Object value ) {
+    private NodeData toSimpleNodeData( final QName key, final Object value ) {
         return new NodeData( key, value );
     }
 }