← Back to branch summary

~ubuntu-branches/debian/sid/wagon2/sid

« back to all changes in this revision

Viewing changes to wagon-provider-test/src/main/java/org/apache/maven/wagon/http/HttpWagonTestCase.java

  • Committer: Package Import Robot
  • Author(s): Emmanuel Bourg
  • Date: 2015-09-02 23:46:43 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20150902234643-byu832r11djlzjbs
Tags: 2.9-1
* Team upload.
* New upstream release
  - Refreshed the patches
* Removed the build dependency on libmaven-enforcer-plugin-java
* No longer build and install the unused wagon-scm and wagon-ssh modules
  to reduce the dependencies of libwagon2-java.

Show diffs side-by-side

added added

removed removed

Lines of Context:
wagon-provider-test/src/main/java/org/apache/maven/wagon/http/HttpWagonTestCase.java
28
28
import org.apache.maven.wagon.authentication.AuthenticationInfo;
29
29
import org.apache.maven.wagon.authorization.AuthorizationException;
30
30
import org.apache.maven.wagon.proxy.ProxyInfo;
 
31
import org.apache.maven.wagon.proxy.ProxyInfoProvider;
31
32
import org.apache.maven.wagon.repository.Repository;
32
33
import org.apache.maven.wagon.resource.Resource;
33
34
import org.codehaus.plexus.util.FileUtils;
76
77
public abstract class HttpWagonTestCase
77
78
    extends StreamingWagonTestCase
78
79
{
 
80
    public static final int SC_TOO_MANY_REQUESTS = 429;
 
81
 
79
82
    private Server server;
80
83
 
81
84
    protected void setupWagonTestingFixtures()
204
207
        assertEquals( "Maven-Wagon/1.0", handler.headers.get( "User-Agent" ) );
205
208
    }
206
209
 
 
210
    public void testUserAgentHeaderIsPresentByDefault()
 
211
        throws Exception
 
212
    {
 
213
        StreamingWagon wagon = (StreamingWagon) getWagon();
 
214
        Server server = new Server( 0 );
 
215
        TestHeaderHandler handler = new TestHeaderHandler();
 
216
        server.setHandler( handler );
 
217
        addConnectors( server );
 
218
        server.start();
 
219
        wagon.connect( new Repository( "id", getProtocol() + "://localhost:" 
 
220
          + server.getConnectors()[0].getLocalPort() ) );
 
221
        wagon.getToStream( "resource", new ByteArrayOutputStream() );
 
222
        wagon.disconnect();
 
223
        server.stop();
 
224
 
 
225
        assertNotNull( "default User-Agent header of wagon provider should be present",
 
226
                       handler.headers.get( "User-Agent" ) );
 
227
    }
 
228
 
 
229
    public void testUserAgentHeaderIsPresentOnlyOnceIfSetMultipleTimes()
 
230
        throws Exception
 
231
    {
 
232
        StreamingWagon wagon = (StreamingWagon) getWagon();
 
233
 
 
234
        // 1. set User-Agent header via HttpConfiguration
 
235
        Properties headers1 = new Properties();
 
236
        headers1.setProperty( "User-Agent", "test-user-agent" );
 
237
        setHttpHeaders( wagon, headers1 );
 
238
 
 
239
        // 2. redundantly set User-Agent header via setHttpHeaders()
 
240
        Properties headers2 = new Properties();
 
241
        headers2.setProperty( "User-Agent", "test-user-agent" );
 
242
        Method setHttpHeaders = wagon.getClass().getMethod( "setHttpHeaders", Properties.class );
 
243
        setHttpHeaders.invoke( wagon, headers2 );
 
244
 
 
245
        Server server = new Server( 0 );
 
246
        TestHeaderHandler handler = new TestHeaderHandler();
 
247
        server.setHandler( handler );
 
248
        addConnectors( server );
 
249
        server.start();
 
250
        wagon.connect( new Repository( "id", getProtocol() + "://localhost:"
 
251
          + server.getConnectors()[0].getLocalPort() ) );
 
252
        wagon.getToStream( "resource", new ByteArrayOutputStream() );
 
253
        wagon.disconnect();
 
254
        server.stop();
 
255
 
 
256
        assertEquals( "test-user-agent", handler.headers.get( "User-Agent" ) );
 
257
 
 
258
    }
 
259
 
207
260
    protected abstract void setHttpHeaders( StreamingWagon wagon, Properties properties );
208
261
 
209
262
    protected void addConnectors( Server server )
261
314
                {
262
315
                    if ( called.get() )
263
316
                    {
264
 
                        response.setStatus( 200 );
 
317
                        response.setStatus( HttpServletResponse.SC_OK );
265
318
                        ( (Request) request ).setHandled( true );
266
319
                    }
267
320
                    else
268
321
                    {
269
322
                        called.set( true );
270
 
                        response.setStatus( 429 );
 
323
                        response.setStatus( SC_TOO_MANY_REQUESTS );
271
324
                        ( (Request) request ).setHandled( true );
272
325
 
273
326
                    }
414
467
                    else
415
468
                    {
416
469
                        called.set( true );
417
 
                        response.setStatus( 429 );
 
470
                        response.setStatus( SC_TOO_MANY_REQUESTS );
418
471
                        ( (Request) request ).setHandled( true );
419
472
                    }
420
473
                }
554
607
 
555
608
        if ( supportProxyPreemptiveAuthentication() )
556
609
        {
557
 
            assertEquals( 200, handler.handlerRequestResponses.get( 0 ).responseCode );
558
 
        }
559
 
        else
560
 
        {
561
 
            assertEquals( 407, handler.handlerRequestResponses.get( 0 ).responseCode );
562
 
            assertEquals( 200, handler.handlerRequestResponses.get( 1 ).responseCode );
 
610
            assertEquals( HttpServletResponse.SC_OK, handler.handlerRequestResponses.get( 0 ).responseCode );
 
611
        }
 
612
        else
 
613
        {
 
614
            assertEquals( HttpServletResponse.SC_PROXY_AUTHENTICATION_REQUIRED,
 
615
                          handler.handlerRequestResponses.get( 0 ).responseCode );
 
616
            assertEquals( HttpServletResponse.SC_OK, handler.handlerRequestResponses.get( 1 ).responseCode );
 
617
        }
 
618
 
 
619
    }
 
620
 
 
621
    public void testProxiedRequestWithAuthenticationWithProvider()
 
622
        throws Exception
 
623
    {
 
624
        final ProxyInfo proxyInfo = createProxyInfo();
 
625
        proxyInfo.setUserName( "user" );
 
626
        proxyInfo.setPassword( "secret" );
 
627
        AuthorizingProxyHandler handler = new AuthorizingProxyHandler();
 
628
 
 
629
        ProxyInfoProvider proxyInfoProvider = new ProxyInfoProvider()
 
630
        {
 
631
            public ProxyInfo getProxyInfo( String protocol )
 
632
            {
 
633
                return proxyInfo;
 
634
            }
 
635
        };
 
636
        runTestProxiedRequestWithProvider( proxyInfoProvider, handler );
 
637
 
 
638
        assertTrue( handler.headers.containsKey( "Proxy-Authorization" ) );
 
639
 
 
640
        if ( supportProxyPreemptiveAuthentication() )
 
641
        {
 
642
            assertEquals( HttpServletResponse.SC_OK, handler.handlerRequestResponses.get( 0 ).responseCode );
 
643
        }
 
644
        else
 
645
        {
 
646
            assertEquals( HttpServletResponse.SC_PROXY_AUTHENTICATION_REQUIRED,
 
647
                          handler.handlerRequestResponses.get( 0 ).responseCode );
 
648
            assertEquals( HttpServletResponse.SC_OK, handler.handlerRequestResponses.get( 1 ).responseCode );
563
649
        }
564
650
 
565
651
    }
595
681
 
596
682
        String redirectUrl = protocol + "://localhost:" + server.getConnectors()[0].getLocalPort();
597
683
 
598
 
        RedirectHandler redirectHandler = new RedirectHandler( "Found", 303, redirectUrl, null );
 
684
        RedirectHandler redirectHandler =
 
685
            new RedirectHandler( "Found", HttpServletResponse.SC_SEE_OTHER, redirectUrl, null );
599
686
 
600
687
        redirectServer.setHandler( redirectHandler );
601
688
 
615
702
            String found = FileUtils.fileRead( tmpResult );
616
703
            assertEquals( "found:'" + found + "'", "Hello, World!", found );
617
704
 
618
 
            assertEquals( 1, handler.handlerRequestResponses.size() );
619
 
            assertEquals( 200, handler.handlerRequestResponses.get( 0 ).responseCode );
620
 
            assertEquals( 1, redirectHandler.handlerRequestResponses.size() );
621
 
            assertEquals( 302, redirectHandler.handlerRequestResponses.get( 0 ).responseCode );
 
705
            checkHandlerResult( handler.handlerRequestResponses, HttpServletResponse.SC_OK );
 
706
            checkHandlerResult( redirectHandler.handlerRequestResponses, HttpServletResponse.SC_FOUND );
622
707
        }
623
708
        finally
624
709
        {
661
746
 
662
747
        String redirectUrl = protocol + "://localhost:" + server.getConnectors()[0].getLocalPort();
663
748
 
664
 
        RedirectHandler redirectHandler = new RedirectHandler( "Found", 303, redirectUrl, null );
 
749
        RedirectHandler redirectHandler =
 
750
            new RedirectHandler( "Found", HttpServletResponse.SC_SEE_OTHER, redirectUrl, null );
665
751
 
666
752
        redirectServer.setHandler( redirectHandler );
667
753
 
677
763
            String found = FileUtils.fileRead( tmpResult );
678
764
            assertEquals( "found:'" + found + "'", "Hello, World!", found );
679
765
 
680
 
            assertEquals( 1, handler.handlerRequestResponses.size() );
681
 
            assertEquals( 200, handler.handlerRequestResponses.get( 0 ).responseCode );
682
 
            assertEquals( 1, redirectHandler.handlerRequestResponses.size() );
683
 
            assertEquals( 302, redirectHandler.handlerRequestResponses.get( 0 ).responseCode );
 
766
            checkHandlerResult( handler.handlerRequestResponses, HttpServletResponse.SC_OK );
 
767
            checkHandlerResult( redirectHandler.handlerRequestResponses, HttpServletResponse.SC_FOUND );
684
768
        }
685
769
        finally
686
770
        {
729
813
 
730
814
        String redirectUrl = protocol + "://localhost:" + realServer.getConnectors()[0].getLocalPort();
731
815
 
732
 
        RedirectHandler redirectHandler = new RedirectHandler( "Found", 303, redirectUrl, repositoryDirectory );
 
816
        RedirectHandler redirectHandler =
 
817
            new RedirectHandler( "Found", HttpServletResponse.SC_SEE_OTHER, redirectUrl, repositoryDirectory );
733
818
 
734
819
        redirectServer.setHandler( redirectHandler );
735
820
 
776
861
    protected void checkRequestResponseForRedirectPutFromStreamWithFullUrl( PutHandler putHandler,
777
862
                                                                            RedirectHandler redirectHandler )
778
863
    {
779
 
        assertEquals( "found:" + putHandler.handlerRequestResponses, 1, putHandler.handlerRequestResponses.size() );
780
 
        assertEquals( "found:" + putHandler.handlerRequestResponses, 201,
781
 
                      putHandler.handlerRequestResponses.get( 0 ).responseCode );
782
 
        assertEquals( "found:" + redirectHandler.handlerRequestResponses, 1,
783
 
                      redirectHandler.handlerRequestResponses.size() );
784
 
        assertEquals( "found:" + redirectHandler.handlerRequestResponses, 302,
785
 
                      redirectHandler.handlerRequestResponses.get( 0 ).responseCode );
 
864
        checkHandlerResult( putHandler.handlerRequestResponses, HttpServletResponse.SC_CREATED );
 
865
        checkHandlerResult( redirectHandler.handlerRequestResponses, HttpServletResponse.SC_FOUND );
786
866
    }
787
867
 
788
868
    public void testRedirectPutFromStreamRelativeUrl()
805
885
        addConnectors( redirectServer );
806
886
 
807
887
        RedirectHandler redirectHandler =
808
 
            new RedirectHandler( "Found", 303, "/redirectRequest/foo", repositoryDirectory );
 
888
            new RedirectHandler( "Found", HttpServletResponse.SC_SEE_OTHER, "/redirectRequest/foo",
 
889
                                 repositoryDirectory );
809
890
 
810
891
        redirectServer.setHandler( redirectHandler );
811
892
 
853
934
    protected void checkRequestResponseForRedirectPutFromStreamWithRelativeUrl( PutHandler putHandler,
854
935
                                                                                RedirectHandler redirectHandler )
855
936
    {
856
 
        assertEquals( "found:" + putHandler.handlerRequestResponses, 0, putHandler.handlerRequestResponses.size() );
857
 
 
858
 
        assertEquals( "found:" + redirectHandler.handlerRequestResponses, 2,
859
 
                      redirectHandler.handlerRequestResponses.size() );
860
 
        assertEquals( "found:" + redirectHandler.handlerRequestResponses, 302,
861
 
                      redirectHandler.handlerRequestResponses.get( 0 ).responseCode );
862
 
        assertEquals( "found:" + redirectHandler.handlerRequestResponses, 201,
863
 
                      redirectHandler.handlerRequestResponses.get( 1 ).responseCode );
864
 
 
 
937
        checkHandlerResult( putHandler.handlerRequestResponses );
 
938
        checkHandlerResult( redirectHandler.handlerRequestResponses, HttpServletResponse.SC_FOUND,
 
939
                            HttpServletResponse.SC_CREATED );
 
940
    }
 
941
 
 
942
    protected void checkHandlerResult( List<HandlerRequestResponse> handlerRequestResponses,
 
943
                                       int... expectedResponseCodes )
 
944
    {
 
945
        boolean success = true;
 
946
        if ( handlerRequestResponses.size() == expectedResponseCodes.length )
 
947
        {
 
948
            for ( int i = 0; i < expectedResponseCodes.length; i++ )
 
949
            {
 
950
                success &= ( expectedResponseCodes[i] == handlerRequestResponses.get( i ).responseCode );
 
951
            }
 
952
        }
 
953
 
 
954
        if ( !success )
 
955
        {
 
956
            fail( "expected " + expectedResponseCodes + ", got " + handlerRequestResponses );
 
957
        }
865
958
    }
866
959
 
867
960
    public void testRedirectPutFileWithFullUrl()
900
993
 
901
994
        String redirectUrl = protocol + "://localhost:" + realServer.getConnectors()[0].getLocalPort();
902
995
 
903
 
        RedirectHandler redirectHandler = new RedirectHandler( "Found", 303, redirectUrl, repositoryDirectory );
 
996
        RedirectHandler redirectHandler =
 
997
            new RedirectHandler( "Found", HttpServletResponse.SC_SEE_OTHER, redirectUrl, repositoryDirectory );
904
998
 
905
999
        redirectServer.setHandler( redirectHandler );
906
1000
 
961
1055
        addConnectors( redirectServer );
962
1056
 
963
1057
        RedirectHandler redirectHandler =
964
 
            new RedirectHandler( "Found", 303, "/redirectRequest/foo", repositoryDirectory );
 
1058
            new RedirectHandler( "Found", HttpServletResponse.SC_SEE_OTHER, "/redirectRequest/foo",
 
1059
                                 repositoryDirectory );
965
1060
 
966
1061
        redirectServer.setHandler( redirectHandler );
967
1062
 
1002
1097
    }
1003
1098
 
1004
1099
 
 
1100
    /**
 
1101
     * 
 
1102
     */
 
1103
    @SuppressWarnings( "checkstyle:visibilitymodifier" )
1005
1104
    public static class RedirectHandler
1006
1105
        extends AbstractHandler
1007
1106
    {
1049
1148
        // what an UGLY hack!
1050
1149
        // but apparently jetty needs some time to free up resources
1051
1150
        // <5s: broken test :(
 
1151
        // CHECKSTYLE_OFF: MagicNumber
1052
1152
        Thread.sleep( 5001L );
 
1153
        // CHECKSTYLE_ON: MagicNumber
1053
1154
 
1054
1155
        Server proxyServer = new Server( 0 );
1055
1156
 
1099
1200
        }
1100
1201
    }
1101
1202
 
 
1203
    private void runTestProxiedRequestWithProvider( ProxyInfoProvider proxyInfoProvider, TestHeaderHandler handler )
 
1204
        throws Exception
 
1205
    {
 
1206
        // what an UGLY hack!
 
1207
        // but apparently jetty needs some time to free up resources
 
1208
        // <5s: broken test :(
 
1209
        // CHECKSTYLE_OFF: MagicNumber
 
1210
        Thread.sleep( 5001L );
 
1211
        // CHECKSTYLE_ON: MagicNumber
 
1212
 
 
1213
        Server proxyServer = new Server( 0 );
 
1214
 
 
1215
        proxyServer.setHandler( handler );
 
1216
 
 
1217
        proxyServer.start();
 
1218
 
 
1219
        proxyInfoProvider.getProxyInfo( null ).setPort( proxyServer.getConnectors()[0].getLocalPort() );
 
1220
 
 
1221
        System.out.println( "start proxy on host/port " + proxyInfoProvider.getProxyInfo( null ).getHost() + "/"
 
1222
                                + proxyInfoProvider.getProxyInfo( null ).getPort() + " with non proxyHosts "
 
1223
                                + proxyInfoProvider.getProxyInfo( null ).getNonProxyHosts() );
 
1224
 
 
1225
        while ( !proxyServer.isRunning() || !proxyServer.isStarted() )
 
1226
        {
 
1227
            Thread.sleep( 10 );
 
1228
        }
 
1229
 
 
1230
        try
 
1231
        {
 
1232
            StreamingWagon wagon = (StreamingWagon) getWagon();
 
1233
 
 
1234
            Repository testRepository = new Repository( "id", "http://www.example.com/" );
 
1235
 
 
1236
            String localRepositoryPath = FileTestUtils.getTestOutputDir().toString();
 
1237
            File sourceFile = new File( localRepositoryPath, "test-proxied-resource" );
 
1238
            FileUtils.fileWrite( sourceFile.getAbsolutePath(), "content" );
 
1239
 
 
1240
            wagon.connect( testRepository, proxyInfoProvider );
 
1241
 
 
1242
            try
 
1243
            {
 
1244
                wagon.getToStream( "test-proxied-resource", new ByteArrayOutputStream() );
 
1245
 
 
1246
                assertTrue( handler.headers.containsKey( "Proxy-Connection" ) );
 
1247
            }
 
1248
            finally
 
1249
            {
 
1250
                System.setProperty( "http.proxyHost", "" );
 
1251
                System.setProperty( "http.proxyPort", "" );
 
1252
                wagon.disconnect();
 
1253
            }
 
1254
        }
 
1255
        finally
 
1256
        {
 
1257
            proxyServer.stop();
 
1258
        }
 
1259
    }
 
1260
 
1102
1261
    private ProxyInfo createProxyInfo()
1103
1262
    {
1104
1263
        ProxyInfo proxyInfo = new ProxyInfo();
1439
1598
                    else
1440
1599
                    {
1441
1600
                        called.set( true );
1442
 
                        response.setStatus( 429 );
 
1601
                        response.setStatus( SC_TOO_MANY_REQUESTS );
1443
1602
                        ( (Request) request ).setHandled( true );
1444
1603
                    }
1445
1604
                }
1727
1886
        {
1728
1887
            assertEquals( "not 1 security handler use " + sh.handlerRequestResponses, 1,
1729
1888
                          sh.handlerRequestResponses.size() );
1730
 
            assertEquals( 200, sh.handlerRequestResponses.get( 0 ).responseCode );
 
1889
            assertEquals( HttpServletResponse.SC_OK, sh.handlerRequestResponses.get( 0 ).responseCode );
1731
1890
        }
1732
1891
        else
1733
1892
        {
1734
1893
            assertEquals( "not 2 security handler use " + sh.handlerRequestResponses, 2,
1735
1894
                          sh.handlerRequestResponses.size() );
1736
 
            assertEquals( 401, sh.handlerRequestResponses.get( 0 ).responseCode );
1737
 
            assertEquals( 200, sh.handlerRequestResponses.get( 1 ).responseCode );
 
1895
            assertEquals( HttpServletResponse.SC_UNAUTHORIZED, sh.handlerRequestResponses.get( 0 ).responseCode );
 
1896
            assertEquals( HttpServletResponse.SC_OK, sh.handlerRequestResponses.get( 1 ).responseCode );
1738
1897
 
1739
1898
        }
1740
1899
    }
1789
1948
        }
1790
1949
    }
1791
1950
 
 
1951
    /**
 
1952
     * 
 
1953
     */
 
1954
    @SuppressWarnings( "checkstyle:visibilitymodifier" )
1792
1955
    public static class PutHandler
1793
1956
        extends AbstractHandler
1794
1957
    {
1808
1971
        public void handle( String target, HttpServletRequest request, HttpServletResponse response, int dispatch )
1809
1972
            throws IOException, ServletException
1810
1973
        {
1811
 
            Request base_request =
 
1974
            Request baseRequest =
1812
1975
                request instanceof Request ? (Request) request : HttpConnection.getCurrentConnection().getRequest();
1813
1976
 
1814
 
            if ( base_request.isHandled() || !"PUT".equals( base_request.getMethod() ) )
 
1977
            if ( baseRequest.isHandled() || !"PUT".equals( baseRequest.getMethod() ) )
1815
1978
            {
1816
1979
                return;
1817
1980
            }
1818
1981
 
1819
 
            base_request.setHandled( true );
 
1982
            baseRequest.setHandled( true );
1820
1983
 
1821
1984
            File file = new File( resourceBase, URLDecoder.decode( request.getPathInfo() ) );
1822
1985
            file.getParentFile().mkdirs();
1861
2024
            if ( request.getHeader( "Proxy-Authorization" ) == null )
1862
2025
            {
1863
2026
                handlerRequestResponses.add(
1864
 
                    new HandlerRequestResponse( request.getMethod(), 407, request.getRequestURI() ) );
1865
 
                response.setStatus( 407 );
 
2027
                    new HandlerRequestResponse( request.getMethod(),
 
2028
                                                HttpServletResponse.SC_PROXY_AUTHENTICATION_REQUIRED,
 
2029
                                                request.getRequestURI() ) );
 
2030
                response.setStatus( HttpServletResponse.SC_PROXY_AUTHENTICATION_REQUIRED );
1866
2031
                response.addHeader( "Proxy-Authenticate", "Basic realm=\"Squid proxy-caching web server\"" );
1867
2032
 
1868
2033
                ( (Request) request ).setHandled( true );
1869
2034
                return;
1870
2035
            }
1871
2036
            handlerRequestResponses.add(
1872
 
                new HandlerRequestResponse( request.getMethod(), 200, request.getRequestURI() ) );
 
2037
                new HandlerRequestResponse( request.getMethod(), HttpServletResponse.SC_OK, request.getRequestURI() ) );
1873
2038
            super.handle( target, request, response, dispatch );
1874
2039
        }
1875
2040
    }
1876
2041
 
 
2042
    /**
 
2043
     * 
 
2044
     */
 
2045
    @SuppressWarnings( "checkstyle:visibilitymodifier" )
1877
2046
    private static class TestHeaderHandler
1878
2047
        extends AbstractHandler
1879
2048
    {
1892
2061
            for ( Enumeration<String> e = request.getHeaderNames(); e.hasMoreElements(); )
1893
2062
            {
1894
2063
                String name = e.nextElement();
1895
 
                headers.put( name, request.getHeader( name ) );
 
2064
                Enumeration headerValues = request.getHeaders( name );
 
2065
                // as per HTTP spec http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html
 
2066
                // multiple values for the same header key are concatenated separated by comma
 
2067
                // otherwise we wouldn't notice headers with same key added multiple times
 
2068
                StringBuffer combinedHeaderValue = new StringBuffer();
 
2069
                for ( int i = 0; headerValues.hasMoreElements(); i++ )
 
2070
                {
 
2071
                    if ( i > 0 )
 
2072
                    {
 
2073
                        combinedHeaderValue.append( "," );
 
2074
                    }
 
2075
                    combinedHeaderValue.append( headerValues.nextElement() );
 
2076
                }
 
2077
                headers.put( name, combinedHeaderValue.toString() );
1896
2078
            }
1897
2079
 
1898
2080
            response.setContentType( "text/plain" );
1928
2110
        return sh;
1929
2111
    }
1930
2112
 
 
2113
    /**
 
2114
     * 
 
2115
     */
 
2116
    @SuppressWarnings( "checkstyle:visibilitymodifier" )
1931
2117
    public static class TestSecurityHandler
1932
2118
        extends SecurityHandler
1933
2119
    {
1947
2133
 
1948
2134
    }
1949
2135
 
 
2136
    /**
 
2137
     * 
 
2138
     */
 
2139
    @SuppressWarnings( "checkstyle:visibilitymodifier" )
1950
2140
    public static class HandlerRequestResponse
1951
2141
    {
1952
2142
        public String method;