<groupId>org.onap.dmaap.messagerouter.dmaapclient</groupId>
        <artifactId>dmaapClient</artifactId>
        <packaging>jar</packaging>
-       <version>1.1.11-SNAPSHOT</version>
+       <version>1.1.12-SNAPSHOT</version>
        <name>dmaap-messagerouter-dmaapclient</name>
        <description>Client library for MR event routing API</description>
        <url>https://gerrit.onap.org/r/gitweb?p=dmaap/messagerouter/dmaapclient.git</url>
 
  *******************************************************************************/
 package org.onap.dmaap.mr.client.impl;
 
+import java.util.Properties;
+
 import javax.ws.rs.client.Client;
 import javax.ws.rs.client.ClientBuilder;
 import javax.ws.rs.client.Entity;
 import javax.ws.rs.client.WebTarget;
 import javax.ws.rs.core.Response;
 
+import org.glassfish.jersey.client.ClientConfig;
+import org.glassfish.jersey.client.ClientProperties;
 import org.glassfish.jersey.client.authentication.HttpAuthenticationFeature;
 
 public class DmaapClientUtil {
 
        private static final String MR_AUTH_CONSTANT = "X-CambriaAuth";
        private static final String MR_DATE_CONSTANT = "X-CambriaDate";
+       private static final String[] httpClientProperties = { ClientProperties.CONNECT_TIMEOUT,
+                       ClientProperties.READ_TIMEOUT, ClientProperties.PROXY_USERNAME, ClientProperties.PROXY_PASSWORD,
+                       ClientProperties.PROXY_URI };
+
+       public static ClientConfig getClientConfig(Properties properties) {
+               ClientConfig config = new ClientConfig();
+               if (properties != null && !properties.isEmpty()) {
+                       setHttpClientProperties(config, properties);
+               }
+               return config;
+       }
 
-       public static WebTarget getTarget(final String path, final String username, final String password) {
+       private static void setHttpClientProperties(ClientConfig config, Properties properties) {
+               for (int i = 0; i < httpClientProperties.length; i++) {
+                       if ((properties.getProperty(httpClientProperties[i]) != null)) {
+                               config.property(httpClientProperties[i], properties.getProperty(httpClientProperties[i]));
+                       }
+               }
+
+       }
 
-               Client client = ClientBuilder.newClient();
+       public static WebTarget getTarget(ClientConfig config, final String path, final String username,
+                       final String password) {
+               Client client = null;
+               if (config != null) {
+                       client = ClientBuilder.newClient(config);
+               } else {
+                       client = ClientBuilder.newClient();
+               }
                HttpAuthenticationFeature feature = HttpAuthenticationFeature.universal(username, password);
                client.register(feature);
 
                return client.target(path);
        }
 
-       public static WebTarget getTarget(final String path) {
+       public static WebTarget getTarget(ClientConfig config, final String path) {
 
-               Client client = ClientBuilder.newClient();
+               Client client = null;
+               if (config != null&&config.getProperties().size()>0) {
+                       client = ClientBuilder.newClient(config);
+               } else {
+                       client = ClientBuilder.newClient();
+               }
                return client.target(path);
        }
 
                return target.request().header(MR_AUTH_CONSTANT, username).header(MR_DATE_CONSTANT, password).get();
 
        }
-       
-       public static Response postResponsewtCambriaAuth(WebTarget target, String username, String password,byte[] data,  String contentType) {
-               return target.request().header(MR_AUTH_CONSTANT, username).header(MR_DATE_CONSTANT, password).post(Entity.entity(data, contentType));
+
+       public static Response postResponsewtCambriaAuth(WebTarget target, String username, String password, byte[] data,
+                       String contentType) {
+               return target.request().header(MR_AUTH_CONSTANT, username).header(MR_DATE_CONSTANT, password)
+                               .post(Entity.entity(data, contentType));
 
        }
 
                return target.request().header("Authorization", "Basic " + authHeader).get();
 
        }
-       
-       public static Response postResponsewtBasicAuth(WebTarget target, String authHeader,byte[] data,String contentType) {
+
+       public static Response postResponsewtBasicAuth(WebTarget target, String authHeader, byte[] data,
+                       String contentType) {
 
                return target.request().header("Authorization", "Basic " + authHeader).post(Entity.entity(data, contentType));
 
                return target.request().get();
 
        }
-       
+
        public static Response postResponsewtNoAuth(WebTarget target, byte[] data, String contentType) {
                return target.request().post(Entity.entity(data, contentType));
 
 
 import javax.ws.rs.core.Response;
 
 import org.apache.http.HttpException;
+import org.glassfish.jersey.client.ClientConfig;
 import org.glassfish.jersey.internal.util.Base64;
 import org.json.JSONArray;
 import org.json.JSONException;
 
 public class MRBaseClient extends HttpClient implements MRClient {
 
+       private ClientConfig clientConfig = null;
 
        protected MRBaseClient(Collection<String> hosts) throws MalformedURLException {
                super(ConnectionType.HTTP, hosts, MRConstants.kStdMRServicePort);
                fLog = LoggerFactory.getLogger(this.getClass().getName());
        }
 
+       public ClientConfig getClientConfig1() {
+               return clientConfig;
+       }
+
+       public void setClientConfig(ClientConfig config) {
+               this.clientConfig = config;
+       }
+
        @Override
        public void close() {
        }
        public JSONObject post(final String path, final byte[] data, final String contentType, final String username,
                        final String password, final String protocalFlag) throws HttpException, JSONException {
                if ((null != username && null != password)) {
-                       WebTarget target=null;
-                       Response response=null;
-                       target = DmaapClientUtil.getTarget(path, username, password);
+                       WebTarget target = null;
+                       Response response = null;
+                       target = DmaapClientUtil.getTarget(clientConfig,path, username, password);
                        String encoding = Base64.encodeAsString(username + ":" + password);
 
-                       response = DmaapClientUtil.postResponsewtBasicAuth(target, encoding,data, contentType);
+                       response = DmaapClientUtil.postResponsewtBasicAuth(target, encoding, data, contentType);
 
                        return getResponseDataInJson(response);
                } else {
                                        "Authentication Failed: Username/password/AuthKey/AuthDate parameter(s) cannot be null or empty.");
                }
        }
-       
+
        public JSONObject postNoAuth(final String path, final byte[] data, String contentType)
                        throws HttpException, JSONException {
                WebTarget target = null;
                if (contentType == null) {
                        contentType = "text/pain";
                }
-               target = DmaapClientUtil.getTarget(path);
+               target = DmaapClientUtil.getTarget(clientConfig,path);
 
                response = DmaapClientUtil.postResponsewtNoAuth(target, data, contentType);
 
                        throws HttpException, JSONException {
                String responseData = null;
                if ((null != username && null != password)) {
-                       WebTarget target=null;
-                       Response response=null;
-                       target = DmaapClientUtil.getTarget(path, username, password);
+                       WebTarget target = null;
+                       Response response = null;
+                       target = DmaapClientUtil.getTarget(clientConfig,path, username, password);
                        String encoding = Base64.encodeAsString(username + ":" + password);
 
-                       response = DmaapClientUtil.postResponsewtBasicAuth(target, encoding,data, contentType);
+                       response = DmaapClientUtil.postResponsewtBasicAuth(target, encoding, data, contentType);
 
-                       responseData = (String)response.readEntity(String.class);
+                       responseData = (String) response.readEntity(String.class);
                        return responseData;
                } else {
                        throw new HttpException(
                                        "Authentication Failed: Username/password/AuthKey/AuthDate parameter(s) cannot be null or empty.");
                }
        }
-       
+
        public String postNoAuthWithResponse(final String path, final byte[] data, String contentType)
                        throws HttpException, JSONException {
 
                if (contentType == null) {
                        contentType = "text/pain";
                }
-               target = DmaapClientUtil.getTarget(path);
+               target = DmaapClientUtil.getTarget(clientConfig,path);
 
                response = DmaapClientUtil.postResponsewtNoAuth(target, data, contentType);
                responseData = (String) response.readEntity(String.class);
                return responseData;
        }
 
-       public JSONObject postAuth(PostAuthDataObject postAuthDO)
-                       throws HttpException, JSONException {
-        if ((null != postAuthDO.getUsername() && null != postAuthDO.getPassword())) {
-            WebTarget target = null;
-            Response response = null;
-            target = DmaapClientUtil.getTarget(postAuthDO.getPath(), postAuthDO.getUsername(),
-                    postAuthDO.getPassword());
-            response = DmaapClientUtil.postResponsewtCambriaAuth(target, postAuthDO.getAuthKey(),
-                    postAuthDO.getAuthDate(), postAuthDO.getData(), postAuthDO.getContentType());
-            return getResponseDataInJson(response);
-        } else {
+       public JSONObject postAuth(PostAuthDataObject postAuthDO) throws HttpException, JSONException {
+               if ((null != postAuthDO.getUsername() && null != postAuthDO.getPassword())) {
+                       WebTarget target = null;
+                       Response response = null;
+                       target = DmaapClientUtil.getTarget(clientConfig,postAuthDO.getPath(), postAuthDO.getUsername(),
+                                       postAuthDO.getPassword());
+                       response = DmaapClientUtil.postResponsewtCambriaAuth(target, postAuthDO.getAuthKey(),
+                                       postAuthDO.getAuthDate(), postAuthDO.getData(), postAuthDO.getContentType());
+                       return getResponseDataInJson(response);
+               } else {
                        throw new HttpException(
                                        "Authentication Failed: Username/password/AuthKey/AuthDate parameter(s) cannot be null or empty.");
                }
                        final String protocolFlag) throws HttpException, JSONException {
                String responseData = null;
                if ((null != username && null != password)) {
-                       WebTarget target=null;
-                       Response response=null;
-                       target = DmaapClientUtil.getTarget(path, username, password);
+                       WebTarget target = null;
+                       Response response = null;
+                       target = DmaapClientUtil.getTarget(clientConfig,path, username, password);
                        response = DmaapClientUtil.postResponsewtCambriaAuth(target, authKey, authDate, data, contentType);
-                       responseData = (String)response.readEntity(String.class);
+                       responseData = (String) response.readEntity(String.class);
                        return responseData;
 
                } else {
                        throws HttpException, JSONException {
                if (null != username && null != password) {
 
-                        WebTarget target=null;
-                        Response response=null;
-                        
+                       WebTarget target = null;
+                       Response response = null;
+
                        if (ProtocolTypeConstants.AUTH_KEY.getValue().equalsIgnoreCase(protocolFlag)) {
-                               target = DmaapClientUtil.getTarget(path);
+                               target = DmaapClientUtil.getTarget(clientConfig,path);
                                response = DmaapClientUtil.getResponsewtCambriaAuth(target, username, password);
                        } else {
-                               target = DmaapClientUtil.getTarget(path, username, password);
+                               target = DmaapClientUtil.getTarget(clientConfig,path, username, password);
                                String encoding = Base64.encodeAsString(username + ":" + password);
 
                                response = DmaapClientUtil.getResponsewtBasicAuth(target, encoding);
                        final String protocolFlag) throws HttpException, JSONException {
                String responseData = null;
                if (null != username && null != password) {
-                       WebTarget target=null;
-                       Response response=null;
+                       WebTarget target = null;
+                       Response response = null;
                        if (ProtocolTypeConstants.AUTH_KEY.getValue().equalsIgnoreCase(protocolFlag)) {
-                               target = DmaapClientUtil.getTarget(path);
+                               target = DmaapClientUtil.getTarget(clientConfig,path);
                                response = DmaapClientUtil.getResponsewtCambriaAuth(target, username, password);
                        } else {
-                               target = DmaapClientUtil.getTarget(path, username, password);
+                               target = DmaapClientUtil.getTarget(clientConfig,path, username, password);
                                String encoding = Base64.encodeAsString(username + ":" + password);
                                response = DmaapClientUtil.getResponsewtBasicAuth(target, encoding);
                        }
                                fLog.info("TransactionId : " + transactionid);
                        }
 
-                       responseData = (String)response.readEntity(String.class);
+                       responseData = (String) response.readEntity(String.class);
                        return responseData;
                } else {
                        throw new HttpException(
        public JSONObject getAuth(final String path, final String authKey, final String authDate, final String username,
                        final String password, final String protocolFlag) throws HttpException, JSONException {
                if (null != username && null != password) {
-                       WebTarget target=null;
-                       Response response=null;
-                       target = DmaapClientUtil.getTarget(path, username, password);
+                       WebTarget target = null;
+                       Response response = null;
+                       target = DmaapClientUtil.getTarget(clientConfig,path, username, password);
                        response = DmaapClientUtil.getResponsewtCambriaAuth(target, authKey, authDate);
 
                        return getResponseDataInJson(response);
 
                WebTarget target = null;
                Response response = null;
-               target = DmaapClientUtil.getTarget(path);
+               target = DmaapClientUtil.getTarget(clientConfig,path);
                response = DmaapClientUtil.getResponsewtNoAuth(target);
 
                return getResponseDataInJson(response);
                        final String password, final String protocolFlag) throws HttpException, JSONException {
                String responseData = null;
                if (null != username && null != password) {
-                       WebTarget target=null;
-                       Response response=null;
-                       target = DmaapClientUtil.getTarget(path, username, password);
+                       WebTarget target = null;
+                       Response response = null;
+                       target = DmaapClientUtil.getTarget(clientConfig,path, username, password);
                        response = DmaapClientUtil.getResponsewtCambriaAuth(target, authKey, authDate);
 
                        MRClientFactory.HTTPHeadersMap = response.getHeaders();
                                fLog.info("TransactionId : " + transactionid);
                        }
 
-                       responseData = (String)response.readEntity(String.class);
+                       responseData = (String) response.readEntity(String.class);
                        return responseData;
                } else {
                        throw new HttpException(
        public String getNoAuthResponse(String path, final String username, final String password,
                        final String protocolFlag) throws HttpException, JSONException {
                String responseData = null;
-               WebTarget target=null;
-               Response response=null;
-               target = DmaapClientUtil.getTarget(path, username, password);
+               WebTarget target = null;
+               Response response = null;
+               target = DmaapClientUtil.getTarget(clientConfig,path, username, password);
                response = DmaapClientUtil.getResponsewtNoAuth(target);
 
                MRClientFactory.HTTPHeadersMap = response.getHeaders();
                        fLog.info("TransactionId : " + transactionid);
                }
 
-               responseData = (String)response.readEntity(String.class);
+               responseData = (String) response.readEntity(String.class);
                return responseData;
 
        }
 
-
        private JSONObject getResponseDataInJson(Response response) throws JSONException {
                try {
                        MRClientFactory.HTTPHeadersMap = response.getHeaders();
-                       
 
                        // MultivaluedMap<String, Object> headersMap =
                        // for(String key : headersMap.keySet()) {
                                fLog.info("TransactionId : " + transactionid);
                        }
 
-
                        if (response.getStatus() == 403) {
                                JSONObject jsonObject = null;
                                jsonObject = new JSONObject();
                                jsonObject.put("status", response.getStatus());
                                return jsonObject;
                        }
-                       String responseData = (String)response.readEntity(String.class);
+                       String responseData = (String) response.readEntity(String.class);
 
                        JSONTokener jsonTokener = new JSONTokener(responseData);
                        JSONObject jsonObject = null;
 
 
     public void setProps(Properties props) {
         this.props = props;
+        setClientConfig(DmaapClientUtil.getClientConfig(props));
     }
 
     public String getUsername() {
 
 
        public void setProps(Properties props) {
                this.props = props;
+               setClientConfig(DmaapClientUtil.getClientConfig(props));
        }
 
        public String getProtocolFlag() {
 
 
 import static org.junit.Assert.assertEquals;
 import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
 import javax.ws.rs.client.Invocation.Builder;
 import javax.ws.rs.client.WebTarget;
 import javax.ws.rs.core.Response;
+
+import org.glassfish.jersey.client.ClientConfig;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
     Builder builder;
     @Mock
     WebTarget target;
+    private ClientConfig config=null;
 
     @Before
     public void setup(){
     
     @Test
     public void testGetTarget() {
-       WebTarget actual = DmaapClientUtil.getTarget("testpath");
+       WebTarget actual = DmaapClientUtil.getTarget(getClientConfig(),"testpath");
         
         assertEquals("testpath", actual.getUri().getPath());
     }
     
     @Test
     public void testGetTargetWithParams() {
-        WebTarget actual = DmaapClientUtil.getTarget("testpath", "testuser", "testpassword");
+        WebTarget actual = DmaapClientUtil.getTarget(getClientConfig(),"testpath", "testuser", "testpassword");
         
         assertEquals("testpath", actual.getUri().getPath());
     }
         verify(builder, times(2)).header((String) any(), any());
     }
 
-    
+       private ClientConfig getClientConfig(){
+               if(config==null){
+                       config=DmaapClientUtil.getClientConfig(null);
+               }
+               return config;
+               
+       }  
 
 }
 
 import javax.ws.rs.core.Response.ResponseBuilder;
 
 import org.apache.http.HttpException;
+import org.glassfish.jersey.client.ClientConfig;
 import org.glassfish.jersey.internal.util.Base64;
 import org.glassfish.jersey.internal.util.collection.StringKeyIgnoreCaseMultivaluedMap;
 import org.json.JSONException;
 import org.powermock.core.classloader.annotations.PrepareForTest;
 import org.powermock.modules.junit4.PowerMockRunner;
 
+
 @RunWith(PowerMockRunner.class)
 @PowerMockIgnore("org.apache.http.conn.ssl.*")
 @PrepareForTest({ DmaapClientUtil.class })
        private MRBaseClient mrBaseClient;
        private Collection<String> hosts = new HashSet<>(Arrays.asList("localhost:8080"));
        private String clientSignature = "topic" + "::" + "cg" + "::" + "cid";
+       private ClientConfig config=null;
 
        @Before
        public void setup() throws MalformedURLException {
                Mockito.when(response.getHeaders()).thenReturn(map);
 
                Mockito.when(
-                               DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username", "password"))
+                               DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username", "password"))
                                .thenReturn(response);
 
                JSONObject result = mrBaseClient.get("/path", "username", "password", "HTTPAUTH");
        public void testGet_403() throws JSONException, HttpException {
                ResponseBuilder responseBuilder = Response.status(403);
                Mockito
-                               .when(DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username",
+                               .when(DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username",
                                                "password"))
                                .thenReturn(
                                                responseBuilder.header("transactionid", "transactionid").entity("{\"test\":\"test\"}").build());
                Mockito.when(response.readEntity(String.class)).thenReturn("{\"test\":\"test\"}");
                Mockito.when(response.getHeaders()).thenReturn(map);
 
-               Mockito.when(DmaapClientUtil.getResponsewtBasicAuth(DmaapClientUtil.getTarget("/path"),
+               Mockito.when(DmaapClientUtil.getResponsewtBasicAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"),
                                Base64.encodeAsString("username:password"))).thenReturn(response);
 
                JSONObject result = mrBaseClient.get("/path", "username", "password", "HTTPAAF");
        public void testGet_error() throws JSONException, HttpException {
 
                ResponseBuilder responseBuilder = Response.ok();
-               Mockito.when(DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username",
+               Mockito.when(DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username",
                                                "password"))
                                .thenReturn(
                                                responseBuilder.header("transactionid", "transactionid").entity("{\"test\":\"test\"}").build());
                Mockito.when(response.getHeaders()).thenReturn(map);
 
                Mockito.when(
-                               DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username", "password"))
+                               DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username", "password"))
                                .thenReturn(response);
 
                mrBaseClient.get("/path", "username", "password", "HTTPAUTH");
                Mockito.when(response.getHeaders()).thenReturn(map);
 
                Mockito.when(
-                               DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username", "password"))
+                               DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username", "password"))
                                .thenReturn(response);
 
                mrBaseClient.getResponse("/path", "username", "password", "HTTPAUTH");
                Mockito.when(response.readEntity(String.class)).thenReturn("{\"test\":\"test\"}");
                Mockito.when(response.getHeaders()).thenReturn(map);
 
-               Mockito.when(DmaapClientUtil.getResponsewtBasicAuth(DmaapClientUtil.getTarget("/path"),
+               Mockito.when(DmaapClientUtil.getResponsewtBasicAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"),
                                Base64.encodeAsString("username:password"))).thenReturn(response);
 
                mrBaseClient.getResponse("/path", "username", "password", "HTTPAAF");
 
                ResponseBuilder responseBuilder = Response.ok();
                Mockito
-                               .when(DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username",
+                               .when(DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username",
                                                "password"))
                                .thenReturn(
                                                responseBuilder.header("transactionid", "transactionid").entity("{\"test\":\"test\"}").build());
                Mockito.when(response.getHeaders()).thenReturn(map);
 
                Mockito.when(
-                               DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username", "password"))
+                               DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username", "password"))
                                .thenReturn(response);
 
                mrBaseClient.getAuthResponse("/path", "username", "password", "username", "password", "HTTPAUTH");
 
                ResponseBuilder responseBuilder = Response.ok();
                Mockito
-                               .when(DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username",
+                               .when(DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username",
                                                "password"))
                                .thenReturn(
                                                responseBuilder.header("transactionid", "transactionid").entity("{\"test\":\"test\"}").build());
                Mockito.when(response.getHeaders()).thenReturn(map);
 
                Mockito
-                               .when(DmaapClientUtil.postResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username",
+                               .when(DmaapClientUtil.postResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username",
                                                "password", new String("{\"test\":\"test\"}").getBytes(), "application/json"))
                                .thenReturn(response);
 
 
                ResponseBuilder responseBuilder = Response.ok();
                Mockito
-                               .when(DmaapClientUtil.postResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username",
+                               .when(DmaapClientUtil.postResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username",
                                                "password", new String("{\"test\":\"test\"}").getBytes(), "application/json"))
                                .thenReturn(
                                                responseBuilder.header("transactionid", "transactionid").entity("{\"test\":\"test\"}").build());
                Mockito.when(response.readEntity(String.class)).thenReturn("{\"test\":\"test\"}");
                Mockito.when(response.getHeaders()).thenReturn(map);
 
-               Mockito.when(DmaapClientUtil.getResponsewtNoAuth(DmaapClientUtil.getTarget("/path"))).thenReturn(response);
+               Mockito.when(DmaapClientUtil.getResponsewtNoAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"))).thenReturn(response);
 
                mrBaseClient.getNoAuthResponse("/path", "username", "password", "HTTPAUTH");
                assertTrue(true);
                Mockito.when(response.readEntity(String.class)).thenReturn("{\"test\":\"test\"}");
                Mockito.when(response.getHeaders()).thenReturn(map);
 
-               Mockito.when(DmaapClientUtil.postResponsewtBasicAuth(DmaapClientUtil.getTarget("/path"),
+               Mockito.when(DmaapClientUtil.postResponsewtBasicAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"),
                                Base64.encodeAsString("username:password"), new String("{\"test\":\"test\"}").getBytes(), "application/json")).thenReturn(response);
 
                mrBaseClient.post("/path", new String("{\"test\":\"test\"}").getBytes(), "application/json", "username",
 
                ResponseBuilder responseBuilder = Response.ok();
                Mockito
-                               .when(DmaapClientUtil.getResponsewtBasicAuth(DmaapClientUtil.getTarget("/path"),
+                               .when(DmaapClientUtil.getResponsewtBasicAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"),
                                                Base64.encodeAsString("username:password")))
                                .thenReturn(
                                                responseBuilder.header("transactionid", "transactionid").entity("{\"test\":\"test\"}").build());
                Mockito.when(response.getHeaders()).thenReturn(map);
 
                Mockito
-                               .when(DmaapClientUtil.postResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username",
+                               .when(DmaapClientUtil.postResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username",
                                                "password", new String("{\"test\":\"test\"}").getBytes(), "application/json"))
                                .thenReturn(response);
 
 
                ResponseBuilder responseBuilder = Response.ok();
                Mockito
-                               .when(DmaapClientUtil.postResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username",
+                               .when(DmaapClientUtil.postResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username",
                                                "password", new String("{\"test\":\"test\"}").getBytes(), "application/json"))
                                .thenReturn(
                                                responseBuilder.header("transactionid", "transactionid").entity("{\"test\":\"test\"}").build());
                Mockito.when(response.readEntity(String.class)).thenReturn("{\"test\":\"test\"}");
                Mockito.when(response.getHeaders()).thenReturn(map);
 
-               Mockito.when(DmaapClientUtil.postResponsewtBasicAuth(DmaapClientUtil.getTarget("/path"),
+               Mockito.when(DmaapClientUtil.postResponsewtBasicAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"),
                                Base64.encodeAsString("username:password"), new String("{\"test\":\"test\"}").getBytes(), "application/json")).thenReturn(response);
 
                mrBaseClient.postWithResponse("/path", new String("{\"test\":\"test\"}").getBytes(), "application/json",
 
                ResponseBuilder responseBuilder = Response.ok();
                Mockito
-                               .when(DmaapClientUtil.getResponsewtBasicAuth(DmaapClientUtil.getTarget("/path"),
+                               .when(DmaapClientUtil.getResponsewtBasicAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"),
                                                Base64.encodeAsString("username:password")))
                                .thenReturn(
                                                responseBuilder.header("transactionid", "transactionid").entity("{\"test\":\"test\"}").build());
                Mockito.when(response.getHeaders()).thenReturn(map);
 
                Mockito.when(
-                               DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username", "password"))
+                               DmaapClientUtil.getResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username", "password"))
                                .thenReturn(response);
                mrBaseClient.getAuth("/path", "username", "password", "username", "password", "HTTPAUTH");
                assertTrue(true);
 
                ResponseBuilder responseBuilder = Response.ok();
                Mockito
-                               .when(DmaapClientUtil.postResponsewtCambriaAuth(DmaapClientUtil.getTarget("/path"), "username",
+                               .when(DmaapClientUtil.postResponsewtCambriaAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"), "username",
                                                "password", new String("{\"test\":\"test\"}").getBytes(), "application/json"))
                                .thenReturn(
                                                responseBuilder.header("transactionid", "transactionid").entity("{\"test\":\"test\"}").build());
                Mockito.when(response.readEntity(String.class)).thenReturn("{\"test\":\"test\"}");
                Mockito.when(response.getHeaders()).thenReturn(map);
 
-               Mockito.when(DmaapClientUtil.getResponsewtNoAuth(DmaapClientUtil.getTarget("/path"))).thenReturn(response);
+               Mockito.when(DmaapClientUtil.getResponsewtNoAuth(DmaapClientUtil.getTarget(getClientConfig(),"/path"))).thenReturn(response);
                mrBaseClient.getNoAuth("/path");
                assertTrue(true);
 
        public void getGTTPErrorResponseCode() {
                assertEquals("500", mrBaseClient.getHTTPErrorResponseCode("<title>500</title>"));
        }
+       
+       
+       
+       private ClientConfig getClientConfig(){
+               if(config==null){
+                       config=DmaapClientUtil.getClientConfig(null);
+               }
+               return config;
+               
+       }
 
 }
 
 
 major=1
 minor=1
-patch=11
+patch=12
 
 base_version=${major}.${minor}.${patch}