target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void uriDecode_failed() { expectedException.expect(IllegalArgumentException.class); expectedException .expectMessage(Matchers.is("uriDecode failed, path=\":\".")); expectedException.expectCause(Matchers.instanceOf(URISyntaxException.class)); HttpUtils.uriDecodePath(":"); }
|
public static String uriDecodePath(String path) { if (path == null) { return null; } try { return new URI(path).getPath(); } catch (URISyntaxException e) { throw new IllegalArgumentException(String.format("uriDecode failed, path=\"%s\".", path), e); } }
|
HttpUtils { public static String uriDecodePath(String path) { if (path == null) { return null; } try { return new URI(path).getPath(); } catch (URISyntaxException e) { throw new IllegalArgumentException(String.format("uriDecode failed, path=\"%s\".", path), e); } } }
|
HttpUtils { public static String uriDecodePath(String path) { if (path == null) { return null; } try { return new URI(path).getPath(); } catch (URISyntaxException e) { throw new IllegalArgumentException(String.format("uriDecode failed, path=\"%s\".", path), e); } } private HttpUtils(); }
|
HttpUtils { public static String uriDecodePath(String path) { if (path == null) { return null; } try { return new URI(path).getPath(); } catch (URISyntaxException e) { throw new IllegalArgumentException(String.format("uriDecode failed, path=\"%s\".", path), e); } } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
HttpUtils { public static String uriDecodePath(String path) { if (path == null) { return null; } try { return new URI(path).getPath(); } catch (URISyntaxException e) { throw new IllegalArgumentException(String.format("uriDecode failed, path=\"%s\".", path), e); } } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
@Test public void parseFileNameFromHeaderValue() { String fileName = "测 试.txt"; String encoded = HttpUtils.uriEncodePath(fileName); Assert.assertEquals(fileName, HttpUtils.parseFileNameFromHeaderValue("xx;filename=" + encoded)); }
|
public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); }
|
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } }
|
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } private HttpUtils(); }
|
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
@Test public void parseFileNameFromHeaderValue_defaultName() { Assert.assertEquals("default", HttpUtils.parseFileNameFromHeaderValue("xx")); }
|
public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); }
|
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } }
|
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } private HttpUtils(); }
|
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
@Test public void parseFileNameFromHeaderValue_ignorePath() { Assert.assertEquals("a.txt", HttpUtils.parseFileNameFromHeaderValue("xx;filename=../../a.txt")); }
|
public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); }
|
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } }
|
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } private HttpUtils(); }
|
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
@Test public void getCharsetFromContentType_noContentType() { String character = HttpUtils.getCharsetFromContentType(null); Assert.assertNull(character); }
|
public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
@Test public void getCharsetFromContentType_noCharset() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON); Assert.assertNull(character); }
|
public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
@Test public void getCharsetFromContentType_noSemicolonEnd() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset=utf-8"); Assert.assertEquals("utf-8", character); }
|
public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
@Test public void getCharsetFromContentType_semicolonEnd() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset=utf-8;"); Assert.assertEquals("utf-8", character); }
|
public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
@Test public void getCharsetFromContentType_needTrim() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset= utf-8 ;"); Assert.assertEquals("utf-8", character); }
|
public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
@Test public void testDefaultValues() { Assert.assertNull(oRegisterInstanceResponse.getInstanceId()); }
|
public String getInstanceId() { return instanceId; }
|
RegisterInstanceResponse { public String getInstanceId() { return instanceId; } }
|
RegisterInstanceResponse { public String getInstanceId() { return instanceId; } }
|
RegisterInstanceResponse { public String getInstanceId() { return instanceId; } String getInstanceId(); void setInstanceId(String instanceId); }
|
RegisterInstanceResponse { public String getInstanceId() { return instanceId; } String getInstanceId(); void setInstanceId(String instanceId); }
|
@Test public void getCharsetFromContentType_quotationMarks() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset=\"utf-8\";"); Assert.assertEquals("utf-8", character); }
|
public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
@Test public void getCharsetFromContentType_quotationMarks_needTrim() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset=\" utf-8 \";"); Assert.assertEquals("utf-8", character); }
|
public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); }
|
@Test public void testStandard() { st = HttpStatusUtils.getOrCreateByStatusCode(200); Assert.assertEquals(200, st.getStatusCode()); }
|
public static StatusType getOrCreateByStatusCode(int code) { return MGR.getOrCreateByStatusCode(code); }
|
HttpStatusUtils { public static StatusType getOrCreateByStatusCode(int code) { return MGR.getOrCreateByStatusCode(code); } }
|
HttpStatusUtils { public static StatusType getOrCreateByStatusCode(int code) { return MGR.getOrCreateByStatusCode(code); } private HttpStatusUtils(); }
|
HttpStatusUtils { public static StatusType getOrCreateByStatusCode(int code) { return MGR.getOrCreateByStatusCode(code); } private HttpStatusUtils(); static StatusType getOrCreateByStatusCode(int code); }
|
HttpStatusUtils { public static StatusType getOrCreateByStatusCode(int code) { return MGR.getOrCreateByStatusCode(code); } private HttpStatusUtils(); static StatusType getOrCreateByStatusCode(int code); }
|
@Test public void testNotStandard() { st = mgr.getOrCreateByStatusCode(250); Assert.assertEquals(250, st.getStatusCode()); }
|
public static StatusType getOrCreateByStatusCode(int code) { return MGR.getOrCreateByStatusCode(code); }
|
HttpStatusUtils { public static StatusType getOrCreateByStatusCode(int code) { return MGR.getOrCreateByStatusCode(code); } }
|
HttpStatusUtils { public static StatusType getOrCreateByStatusCode(int code) { return MGR.getOrCreateByStatusCode(code); } private HttpStatusUtils(); }
|
HttpStatusUtils { public static StatusType getOrCreateByStatusCode(int code) { return MGR.getOrCreateByStatusCode(code); } private HttpStatusUtils(); static StatusType getOrCreateByStatusCode(int code); }
|
HttpStatusUtils { public static StatusType getOrCreateByStatusCode(int code) { return MGR.getOrCreateByStatusCode(code); } private HttpStatusUtils(); static StatusType getOrCreateByStatusCode(int code); }
|
@Test public void getInputStream() throws IOException { try (InputStream is = part.getInputStream()) { Assert.assertEquals(content, IOUtils.toString(is, StandardCharsets.UTF_8)); } }
|
@Override public InputStream getInputStream() throws IOException { return new FileInputStream(file); }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public InputStream getInputStream() throws IOException { return new FileInputStream(file); } }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public InputStream getInputStream() throws IOException { return new FileInputStream(file); } FilePart(String name, String file); FilePart(String name, File file); }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public InputStream getInputStream() throws IOException { return new FileInputStream(file); } FilePart(String name, String file); FilePart(String name, File file); @Override InputStream getInputStream(); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override boolean isDeleteAfterFinished(); FilePart setDeleteAfterFinished(boolean deleteAfterFinished); @Override String getAbsolutePath(); }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public InputStream getInputStream() throws IOException { return new FileInputStream(file); } FilePart(String name, String file); FilePart(String name, File file); @Override InputStream getInputStream(); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override boolean isDeleteAfterFinished(); FilePart setDeleteAfterFinished(boolean deleteAfterFinished); @Override String getAbsolutePath(); }
|
@Test public void getSize() { Assert.assertEquals(content.length(), part.getSize()); }
|
@Override public long getSize() { return file.length(); }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public long getSize() { return file.length(); } }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public long getSize() { return file.length(); } FilePart(String name, String file); FilePart(String name, File file); }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public long getSize() { return file.length(); } FilePart(String name, String file); FilePart(String name, File file); @Override InputStream getInputStream(); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override boolean isDeleteAfterFinished(); FilePart setDeleteAfterFinished(boolean deleteAfterFinished); @Override String getAbsolutePath(); }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public long getSize() { return file.length(); } FilePart(String name, String file); FilePart(String name, File file); @Override InputStream getInputStream(); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override boolean isDeleteAfterFinished(); FilePart setDeleteAfterFinished(boolean deleteAfterFinished); @Override String getAbsolutePath(); }
|
@Test public void write() throws IOException { File destFile = new File("testFilePartCopy.txt"); part.write(destFile.getPath()); Assert.assertEquals(content, FileUtils.readFileToString(destFile, StandardCharsets.UTF_8)); FilePart destPart = new FilePart(null, destFile); destPart.delete(); Assert.assertFalse(destFile.exists()); }
|
@Override public void write(String fileName) throws IOException { FileUtils.copyFile(file, new File(fileName)); }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public void write(String fileName) throws IOException { FileUtils.copyFile(file, new File(fileName)); } }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public void write(String fileName) throws IOException { FileUtils.copyFile(file, new File(fileName)); } FilePart(String name, String file); FilePart(String name, File file); }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public void write(String fileName) throws IOException { FileUtils.copyFile(file, new File(fileName)); } FilePart(String name, String file); FilePart(String name, File file); @Override InputStream getInputStream(); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override boolean isDeleteAfterFinished(); FilePart setDeleteAfterFinished(boolean deleteAfterFinished); @Override String getAbsolutePath(); }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public void write(String fileName) throws IOException { FileUtils.copyFile(file, new File(fileName)); } FilePart(String name, String file); FilePart(String name, File file); @Override InputStream getInputStream(); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override boolean isDeleteAfterFinished(); FilePart setDeleteAfterFinished(boolean deleteAfterFinished); @Override String getAbsolutePath(); }
|
@Test public void getAbsolutePath() { Assert.assertEquals(file.getAbsolutePath(), part.getAbsolutePath()); }
|
@Override public String getAbsolutePath() { return file.getAbsolutePath(); }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public String getAbsolutePath() { return file.getAbsolutePath(); } }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public String getAbsolutePath() { return file.getAbsolutePath(); } FilePart(String name, String file); FilePart(String name, File file); }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public String getAbsolutePath() { return file.getAbsolutePath(); } FilePart(String name, String file); FilePart(String name, File file); @Override InputStream getInputStream(); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override boolean isDeleteAfterFinished(); FilePart setDeleteAfterFinished(boolean deleteAfterFinished); @Override String getAbsolutePath(); }
|
FilePart extends AbstractPart implements FilePartForSend { @Override public String getAbsolutePath() { return file.getAbsolutePath(); } FilePart(String name, String file); FilePart(String name, File file); @Override InputStream getInputStream(); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override boolean isDeleteAfterFinished(); FilePart setDeleteAfterFinished(boolean deleteAfterFinished); @Override String getAbsolutePath(); }
|
@Test public void getInputStream() throws IOException { initExpectedException(); part.getInputStream(); }
|
@Override public InputStream getInputStream() throws IOException { throw new Error("not supported method"); }
|
AbstractPart implements Part { @Override public InputStream getInputStream() throws IOException { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public InputStream getInputStream() throws IOException { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public InputStream getInputStream() throws IOException { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
AbstractPart implements Part { @Override public InputStream getInputStream() throws IOException { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
@Test public void getContentType() throws IOException { Assert.assertEquals(MediaType.APPLICATION_OCTET_STREAM, part.getContentType()); String contentType = "abc"; part.contentType(contentType); Assert.assertEquals(contentType, part.getContentType()); }
|
@Override public String getContentType() { return contentType != null ? contentType : MediaType.APPLICATION_OCTET_STREAM; }
|
AbstractPart implements Part { @Override public String getContentType() { return contentType != null ? contentType : MediaType.APPLICATION_OCTET_STREAM; } }
|
AbstractPart implements Part { @Override public String getContentType() { return contentType != null ? contentType : MediaType.APPLICATION_OCTET_STREAM; } }
|
AbstractPart implements Part { @Override public String getContentType() { return contentType != null ? contentType : MediaType.APPLICATION_OCTET_STREAM; } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
AbstractPart implements Part { @Override public String getContentType() { return contentType != null ? contentType : MediaType.APPLICATION_OCTET_STREAM; } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
@Test public void testInitializedValues() { initFields(); Assert.assertEquals("testInstanceID", oRegisterInstanceResponse.getInstanceId()); }
|
public String getInstanceId() { return instanceId; }
|
RegisterInstanceResponse { public String getInstanceId() { return instanceId; } }
|
RegisterInstanceResponse { public String getInstanceId() { return instanceId; } }
|
RegisterInstanceResponse { public String getInstanceId() { return instanceId; } String getInstanceId(); void setInstanceId(String instanceId); }
|
RegisterInstanceResponse { public String getInstanceId() { return instanceId; } String getInstanceId(); void setInstanceId(String instanceId); }
|
@Test public void getName() throws IOException { Assert.assertNull(part.getName()); String name = "abc"; part.name = name; Assert.assertEquals(name, part.getName()); }
|
@Override public String getName() { return name; }
|
AbstractPart implements Part { @Override public String getName() { return name; } }
|
AbstractPart implements Part { @Override public String getName() { return name; } }
|
AbstractPart implements Part { @Override public String getName() { return name; } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
AbstractPart implements Part { @Override public String getName() { return name; } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
@Test public void getSubmittedFileName() throws IOException { Assert.assertNull(part.getSubmittedFileName()); String submittedFileName = "abc"; part.setSubmittedFileName(submittedFileName); Assert.assertEquals(submittedFileName, part.getSubmittedFileName()); }
|
@Override public String getSubmittedFileName() { return submittedFileName; }
|
AbstractPart implements Part { @Override public String getSubmittedFileName() { return submittedFileName; } }
|
AbstractPart implements Part { @Override public String getSubmittedFileName() { return submittedFileName; } }
|
AbstractPart implements Part { @Override public String getSubmittedFileName() { return submittedFileName; } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
AbstractPart implements Part { @Override public String getSubmittedFileName() { return submittedFileName; } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
@Test public void getSize() { initExpectedException(); part.getSize(); }
|
@Override public long getSize() { throw new Error("not supported method"); }
|
AbstractPart implements Part { @Override public long getSize() { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public long getSize() { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public long getSize() { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
AbstractPart implements Part { @Override public long getSize() { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
@Test public void write() throws IOException { initExpectedException(); part.write("file"); }
|
@Override public void write(String fileName) throws IOException { throw new Error("not supported method"); }
|
AbstractPart implements Part { @Override public void write(String fileName) throws IOException { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public void write(String fileName) throws IOException { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public void write(String fileName) throws IOException { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
AbstractPart implements Part { @Override public void write(String fileName) throws IOException { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
@Test public void delete() throws IOException { initExpectedException(); part.delete(); }
|
@Override public void delete() throws IOException { throw new Error("not supported method"); }
|
AbstractPart implements Part { @Override public void delete() throws IOException { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public void delete() throws IOException { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public void delete() throws IOException { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
AbstractPart implements Part { @Override public void delete() throws IOException { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
@Test public void getHeader() { initExpectedException(); part.getHeader("header"); }
|
@Override public String getHeader(String name) { throw new Error("not supported method"); }
|
AbstractPart implements Part { @Override public String getHeader(String name) { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public String getHeader(String name) { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public String getHeader(String name) { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
AbstractPart implements Part { @Override public String getHeader(String name) { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
@Test public void getHeaders() { initExpectedException(); part.getHeaders("header"); }
|
@Override public Collection<String> getHeaders(String name) { throw new Error("not supported method"); }
|
AbstractPart implements Part { @Override public Collection<String> getHeaders(String name) { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public Collection<String> getHeaders(String name) { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public Collection<String> getHeaders(String name) { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
AbstractPart implements Part { @Override public Collection<String> getHeaders(String name) { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
@Test public void getHeaderNames() { initExpectedException(); part.getHeaderNames(); }
|
@Override public Collection<String> getHeaderNames() { throw new Error("not supported method"); }
|
AbstractPart implements Part { @Override public Collection<String> getHeaderNames() { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public Collection<String> getHeaderNames() { throw new Error("not supported method"); } }
|
AbstractPart implements Part { @Override public Collection<String> getHeaderNames() { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
AbstractPart implements Part { @Override public Collection<String> getHeaderNames() { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
|
@Test public void getInputStream() throws IOException { try (InputStream is = part.getInputStream()) { byte[] content = IOUtils.toByteArray(is); Assert.assertArrayEquals(bytes, content); } }
|
@Override public InputStream getInputStream() throws IOException { return resource.getInputStream(); }
|
ResourcePart extends AbstractPart { @Override public InputStream getInputStream() throws IOException { return resource.getInputStream(); } }
|
ResourcePart extends AbstractPart { @Override public InputStream getInputStream() throws IOException { return resource.getInputStream(); } ResourcePart(String name, Resource resource); }
|
ResourcePart extends AbstractPart { @Override public InputStream getInputStream() throws IOException { return resource.getInputStream(); } ResourcePart(String name, Resource resource); @Override InputStream getInputStream(); }
|
ResourcePart extends AbstractPart { @Override public InputStream getInputStream() throws IOException { return resource.getInputStream(); } ResourcePart(String name, Resource resource); @Override InputStream getInputStream(); }
|
@Test public void testNetUtils() { Assert.assertEquals("127.0.0.1", NetUtils.parseIpPort("127.0.0.1:8080").getHostOrIp()); Assert.assertEquals(8080, NetUtils.parseIpPort("127.0.0.1:8080").getPort()); Assert.assertEquals("127.0.0.1", NetUtils.parseIpPort("127.0.0.1").getHostOrIp()); Assert.assertEquals(-1, NetUtils.parseIpPort("127.0.0.1").getPort()); Assert.assertEquals(null, NetUtils.parseIpPort((String) null)); Assert.assertEquals(null, NetUtils.parseIpPortFromURI(null)); Assert.assertEquals("127.0.0.1", NetUtils.parseIpPortFromURI("rest: Assert.assertEquals(8080, NetUtils.parseIpPortFromURI("http: Assert.assertEquals(80, NetUtils.parseIpPortFromURI("http: Assert.assertEquals(8080, NetUtils.parseIpPortFromURI("https: Assert.assertEquals(443, NetUtils.parseIpPortFromURI("https: Assert.assertEquals(30000, NetUtils.parseIpPort("http", "127.0.0.1:30000").getPort()); Assert.assertEquals("127.0.0.1", NetUtils.parseIpPort("http", "127.0.0.1:30000").getHostOrIp()); Assert.assertEquals(30000, NetUtils.parseIpPort("https", "127.0.0.1:30000").getPort()); Assert.assertEquals("127.0.0.1", NetUtils.parseIpPort("https", "127.0.0.1:30000").getHostOrIp()); Assert.assertEquals(80, NetUtils.parseIpPort("http", "127.0.0.1").getPort()); Assert.assertEquals("127.0.0.1", NetUtils.parseIpPort("http", "127.0.0.1").getHostOrIp()); Assert.assertEquals(443, NetUtils.parseIpPort("https", "127.0.0.1").getPort()); Assert.assertEquals("127.0.0.1", NetUtils.parseIpPort("https", "127.0.0.1").getHostOrIp()); Assert.assertNull(NetUtils.parseIpPort("http", null)); checkException(v -> NetUtils.parseIpPort("127.0.0.18080")); checkException(v -> NetUtils.parseIpPortFromURI("ss")); }
|
private NetUtils() { }
|
NetUtils { private NetUtils() { } }
|
NetUtils { private NetUtils() { } private NetUtils(); }
|
NetUtils { private NetUtils() { } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
NetUtils { private NetUtils() { } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
@Test public void testDefaultValues() { Assert.assertNull(oGetServiceResponse.getService()); }
|
public Microservice getService() { return service; }
|
GetServiceResponse { public Microservice getService() { return service; } }
|
GetServiceResponse { public Microservice getService() { return service; } }
|
GetServiceResponse { public Microservice getService() { return service; } Microservice getService(); void setService(Microservice service); }
|
GetServiceResponse { public Microservice getService() { return service; } Microservice getService(); void setService(Microservice service); }
|
@Test public void testGetRealListenAddress() { Assert.assertNull(NetUtils.getRealListenAddress("http", null)); Assert.assertEquals("http: checkException(v -> NetUtils.getRealListenAddress("http:1", "1.1.1.1:8080")); }
|
public static String getRealListenAddress(String schema, String address) { if (address == null) { return null; } try { URI originalURI = new URI(schema + ": IpPort ipPort = NetUtils.parseIpPort(originalURI); if (ipPort == null) { LOGGER.error("address {} is not valid.", address); return null; } return originalURI.toString(); } catch (URISyntaxException e) { LOGGER.error("address {} is not valid.", address); return null; } }
|
NetUtils { public static String getRealListenAddress(String schema, String address) { if (address == null) { return null; } try { URI originalURI = new URI(schema + ": IpPort ipPort = NetUtils.parseIpPort(originalURI); if (ipPort == null) { LOGGER.error("address {} is not valid.", address); return null; } return originalURI.toString(); } catch (URISyntaxException e) { LOGGER.error("address {} is not valid.", address); return null; } } }
|
NetUtils { public static String getRealListenAddress(String schema, String address) { if (address == null) { return null; } try { URI originalURI = new URI(schema + ": IpPort ipPort = NetUtils.parseIpPort(originalURI); if (ipPort == null) { LOGGER.error("address {} is not valid.", address); return null; } return originalURI.toString(); } catch (URISyntaxException e) { LOGGER.error("address {} is not valid.", address); return null; } } private NetUtils(); }
|
NetUtils { public static String getRealListenAddress(String schema, String address) { if (address == null) { return null; } try { URI originalURI = new URI(schema + ": IpPort ipPort = NetUtils.parseIpPort(originalURI); if (ipPort == null) { LOGGER.error("address {} is not valid.", address); return null; } return originalURI.toString(); } catch (URISyntaxException e) { LOGGER.error("address {} is not valid.", address); return null; } } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
NetUtils { public static String getRealListenAddress(String schema, String address) { if (address == null) { return null; } try { URI originalURI = new URI(schema + ": IpPort ipPort = NetUtils.parseIpPort(originalURI); if (ipPort == null) { LOGGER.error("address {} is not valid.", address); return null; } return originalURI.toString(); } catch (URISyntaxException e) { LOGGER.error("address {} is not valid.", address); return null; } } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
@Test public void testCanTcpListenNo() throws IOException { InetAddress address = InetAddress.getByName("127.0.0.1"); try (ServerSocket ss = new ServerSocket(0, 0, address)) { Assert.assertFalse(NetUtils.canTcpListen(address, ss.getLocalPort())); } }
|
@SuppressWarnings({"unused", "try"}) public static boolean canTcpListen(InetAddress address, int port) { try (ServerSocket ss = new ServerSocket(port, 0, address)) { return true; } catch (IOException e) { return false; } }
|
NetUtils { @SuppressWarnings({"unused", "try"}) public static boolean canTcpListen(InetAddress address, int port) { try (ServerSocket ss = new ServerSocket(port, 0, address)) { return true; } catch (IOException e) { return false; } } }
|
NetUtils { @SuppressWarnings({"unused", "try"}) public static boolean canTcpListen(InetAddress address, int port) { try (ServerSocket ss = new ServerSocket(port, 0, address)) { return true; } catch (IOException e) { return false; } } private NetUtils(); }
|
NetUtils { @SuppressWarnings({"unused", "try"}) public static boolean canTcpListen(InetAddress address, int port) { try (ServerSocket ss = new ServerSocket(port, 0, address)) { return true; } catch (IOException e) { return false; } } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
NetUtils { @SuppressWarnings({"unused", "try"}) public static boolean canTcpListen(InetAddress address, int port) { try (ServerSocket ss = new ServerSocket(port, 0, address)) { return true; } catch (IOException e) { return false; } } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
@Test public void testCanTcpListenYes() throws IOException { InetAddress address = InetAddress.getByName("127.0.0.1"); ServerSocket ss = new ServerSocket(0, 0, address); int port = ss.getLocalPort(); ss.close(); Assert.assertTrue(NetUtils.canTcpListen(address, port)); }
|
@SuppressWarnings({"unused", "try"}) public static boolean canTcpListen(InetAddress address, int port) { try (ServerSocket ss = new ServerSocket(port, 0, address)) { return true; } catch (IOException e) { return false; } }
|
NetUtils { @SuppressWarnings({"unused", "try"}) public static boolean canTcpListen(InetAddress address, int port) { try (ServerSocket ss = new ServerSocket(port, 0, address)) { return true; } catch (IOException e) { return false; } } }
|
NetUtils { @SuppressWarnings({"unused", "try"}) public static boolean canTcpListen(InetAddress address, int port) { try (ServerSocket ss = new ServerSocket(port, 0, address)) { return true; } catch (IOException e) { return false; } } private NetUtils(); }
|
NetUtils { @SuppressWarnings({"unused", "try"}) public static boolean canTcpListen(InetAddress address, int port) { try (ServerSocket ss = new ServerSocket(port, 0, address)) { return true; } catch (IOException e) { return false; } } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
NetUtils { @SuppressWarnings({"unused", "try"}) public static boolean canTcpListen(InetAddress address, int port) { try (ServerSocket ss = new ServerSocket(port, 0, address)) { return true; } catch (IOException e) { return false; } } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
@Test public void humanReadableBytes() { Assert.assertEquals("0", NetUtils.humanReadableBytes(0L)); Assert.assertEquals("1", NetUtils.humanReadableBytes(1L)); Assert.assertEquals("1023", NetUtils.humanReadableBytes(1023L)); Assert.assertEquals("1.000K", NetUtils.humanReadableBytes(1024L)); Assert.assertEquals("1.001K", NetUtils.humanReadableBytes(1025L)); Assert.assertEquals("1023.999K", NetUtils.humanReadableBytes(1024L * 1024 - 1)); Assert.assertEquals("1.000M", NetUtils.humanReadableBytes(1024L * 1024)); Assert.assertEquals("1.000M", NetUtils.humanReadableBytes(1024L * 1024 + 1)); Assert.assertEquals("1.001M", NetUtils.humanReadableBytes(1024L * 1024 + 1024)); Assert.assertEquals("1023.999M", NetUtils.humanReadableBytes(1024L * 1024 * 1024 - 1024)); Assert.assertEquals("1024.000M", NetUtils.humanReadableBytes(1024L * 1024 * 1024 - 1)); Assert.assertEquals("1.000G", NetUtils.humanReadableBytes(1024L * 1024 * 1024)); Assert.assertEquals("1.000G", NetUtils.humanReadableBytes(1024L * 1024 * 1024 + 1)); Assert.assertEquals("1.000G", NetUtils.humanReadableBytes(1024L * 1024 * 1024 + 1024)); Assert.assertEquals("1023.999G", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 - 1024 * 1024)); Assert.assertEquals("1024.000G", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 - 1024)); Assert.assertEquals("1.000T", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024)); Assert.assertEquals("1.001T", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 + 1024 * 1024 * 1024)); Assert.assertEquals("1023.999T", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 * 1024 - 1024L * 1024 * 1024)); Assert.assertEquals("1.000P", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 * 1024)); Assert.assertEquals("1.001P", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 * 1024 + 1024L * 1024 * 1024 * 1024)); Assert.assertEquals("1023.999P", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 * 1024 * 1024 - 1024L * 1024 * 1024 * 1024)); Assert.assertEquals("1.000E", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 * 1024 * 1024)); Assert.assertEquals("1.001E", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 * 1024 * 1024 + 1024L * 1024 * 1024 * 1024 * 1024)); Assert.assertEquals("8.000E", NetUtils.humanReadableBytes(Long.MAX_VALUE)); }
|
public static String humanReadableBytes(long bytes) { int unit = 1024; if (bytes < unit) { return String.valueOf(bytes); } int exp = (int) (Math.log(bytes) / Math.log(unit)); char pre = "KMGTPE".charAt(exp - 1); return String.format("%.3f%c", bytes / Math.pow(unit, exp), pre); }
|
NetUtils { public static String humanReadableBytes(long bytes) { int unit = 1024; if (bytes < unit) { return String.valueOf(bytes); } int exp = (int) (Math.log(bytes) / Math.log(unit)); char pre = "KMGTPE".charAt(exp - 1); return String.format("%.3f%c", bytes / Math.pow(unit, exp), pre); } }
|
NetUtils { public static String humanReadableBytes(long bytes) { int unit = 1024; if (bytes < unit) { return String.valueOf(bytes); } int exp = (int) (Math.log(bytes) / Math.log(unit)); char pre = "KMGTPE".charAt(exp - 1); return String.format("%.3f%c", bytes / Math.pow(unit, exp), pre); } private NetUtils(); }
|
NetUtils { public static String humanReadableBytes(long bytes) { int unit = 1024; if (bytes < unit) { return String.valueOf(bytes); } int exp = (int) (Math.log(bytes) / Math.log(unit)); char pre = "KMGTPE".charAt(exp - 1); return String.format("%.3f%c", bytes / Math.pow(unit, exp), pre); } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
NetUtils { public static String humanReadableBytes(long bytes) { int unit = 1024; if (bytes < unit) { return String.valueOf(bytes); } int exp = (int) (Math.log(bytes) / Math.log(unit)); char pre = "KMGTPE".charAt(exp - 1); return String.format("%.3f%c", bytes / Math.pow(unit, exp), pre); } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
@Test public void testGetHostName() { Assert.assertNotEquals(null, NetUtils.getHostName()); Deencapsulation.setField(NetUtils.class, "hostName", null); Assert.assertNotEquals(null, NetUtils.getHostName()); }
|
public static String getHostName() { if (hostName == null) { doGetHostNameAndHostAddress(); } return hostName; }
|
NetUtils { public static String getHostName() { if (hostName == null) { doGetHostNameAndHostAddress(); } return hostName; } }
|
NetUtils { public static String getHostName() { if (hostName == null) { doGetHostNameAndHostAddress(); } return hostName; } private NetUtils(); }
|
NetUtils { public static String getHostName() { if (hostName == null) { doGetHostNameAndHostAddress(); } return hostName; } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
NetUtils { public static String getHostName() { if (hostName == null) { doGetHostNameAndHostAddress(); } return hostName; } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
@Test public void testGetHostAddress() { Assert.assertNotEquals(null, NetUtils.getHostAddress()); Deencapsulation.setField(NetUtils.class, "hostAddress", null); Assert.assertNotEquals(null, NetUtils.getHostAddress()); }
|
public static String getHostAddress() { if (hostAddress == null) { doGetHostNameAndHostAddress(); } return hostAddress; }
|
NetUtils { public static String getHostAddress() { if (hostAddress == null) { doGetHostNameAndHostAddress(); } return hostAddress; } }
|
NetUtils { public static String getHostAddress() { if (hostAddress == null) { doGetHostNameAndHostAddress(); } return hostAddress; } private NetUtils(); }
|
NetUtils { public static String getHostAddress() { if (hostAddress == null) { doGetHostNameAndHostAddress(); } return hostAddress; } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
NetUtils { public static String getHostAddress() { if (hostAddress == null) { doGetHostNameAndHostAddress(); } return hostAddress; } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); }
|
@Test public void testIpPort() { IpPort inst1 = new IpPort(); inst1.setHostOrIp("localhost"); inst1.setPort(3333); IpPort inst2 = new IpPort("localhost", 3333); Assert.assertEquals(inst1.getHostOrIp(), inst2.getHostOrIp()); Assert.assertEquals(inst1.getPort(), inst2.getPort()); Assert.assertEquals(inst1.getSocketAddress().getHostName(), inst2.getSocketAddress().getHostName()); Assert.assertEquals(inst1, inst1); Assert.assertEquals(inst1, inst2); Assert.assertEquals(inst1.toString(), "localhost:3333"); Assert.assertNotEquals(inst1, new Object()); }
|
public IpPort() { }
|
IpPort { public IpPort() { } }
|
IpPort { public IpPort() { } IpPort(); IpPort(String hostOrIp, int port); }
|
IpPort { public IpPort() { } IpPort(); IpPort(String hostOrIp, int port); String getHostOrIp(); void setHostOrIp(String hostOrIp); int getPort(); void setPort(int port); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); InetSocketAddress getSocketAddress(); }
|
IpPort { public IpPort() { } IpPort(); IpPort(String hostOrIp, int port); String getHostOrIp(); void setHostOrIp(String hostOrIp); int getPort(); void setPort(int port); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); InetSocketAddress getSocketAddress(); }
|
@Test public void testFortifyUtils() throws IOException { Assert.assertEquals("", FortifyUtils.getErrorMsg(null)); Assert.assertEquals("", FortifyUtils.getErrorStack(null)); }
|
private FortifyUtils() { }
|
FortifyUtils { private FortifyUtils() { } }
|
FortifyUtils { private FortifyUtils() { } private FortifyUtils(); }
|
FortifyUtils { private FortifyUtils() { } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); }
|
FortifyUtils { private FortifyUtils() { } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); }
|
@Test public void testGetErrorMsg() { Throwable e = new Throwable(); FortifyUtils.getErrorMsg(e); assertNull(FortifyUtils.getErrorMsg(e)); }
|
public static String getErrorMsg(Throwable e) { if (e == null) { return ""; } try { return (String) getMessageMethod.invoke(e); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { return ""; } }
|
FortifyUtils { public static String getErrorMsg(Throwable e) { if (e == null) { return ""; } try { return (String) getMessageMethod.invoke(e); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { return ""; } } }
|
FortifyUtils { public static String getErrorMsg(Throwable e) { if (e == null) { return ""; } try { return (String) getMessageMethod.invoke(e); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { return ""; } } private FortifyUtils(); }
|
FortifyUtils { public static String getErrorMsg(Throwable e) { if (e == null) { return ""; } try { return (String) getMessageMethod.invoke(e); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { return ""; } } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); }
|
FortifyUtils { public static String getErrorMsg(Throwable e) { if (e == null) { return ""; } try { return (String) getMessageMethod.invoke(e); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { return ""; } } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); }
|
@Test public void testGetSecurityXmlDocumentFactory() { try { FortifyUtils.getSecurityXmlDocumentFactory(); assertNotNull(FortifyUtils.getSecurityXmlDocumentFactory()); } catch (Exception e) { Assert.assertTrue(false); } }
|
public static DocumentBuilderFactory getSecurityXmlDocumentFactory() throws ParserConfigurationException { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setFeature("http: factory.setXIncludeAware(false); factory.setExpandEntityReferences(false); factory.setFeature("http: factory.setFeature("http: factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true); factory.setValidating(true); return factory; }
|
FortifyUtils { public static DocumentBuilderFactory getSecurityXmlDocumentFactory() throws ParserConfigurationException { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setFeature("http: factory.setXIncludeAware(false); factory.setExpandEntityReferences(false); factory.setFeature("http: factory.setFeature("http: factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true); factory.setValidating(true); return factory; } }
|
FortifyUtils { public static DocumentBuilderFactory getSecurityXmlDocumentFactory() throws ParserConfigurationException { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setFeature("http: factory.setXIncludeAware(false); factory.setExpandEntityReferences(false); factory.setFeature("http: factory.setFeature("http: factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true); factory.setValidating(true); return factory; } private FortifyUtils(); }
|
FortifyUtils { public static DocumentBuilderFactory getSecurityXmlDocumentFactory() throws ParserConfigurationException { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setFeature("http: factory.setXIncludeAware(false); factory.setExpandEntityReferences(false); factory.setFeature("http: factory.setFeature("http: factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true); factory.setValidating(true); return factory; } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); }
|
FortifyUtils { public static DocumentBuilderFactory getSecurityXmlDocumentFactory() throws ParserConfigurationException { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setFeature("http: factory.setXIncludeAware(false); factory.setExpandEntityReferences(false); factory.setFeature("http: factory.setFeature("http: factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true); factory.setValidating(true); return factory; } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); }
|
@Test public void testInitializedValues() { initFields(); Assert.assertEquals(oMockMicroservice, oGetServiceResponse.getService()); }
|
public Microservice getService() { return service; }
|
GetServiceResponse { public Microservice getService() { return service; } }
|
GetServiceResponse { public Microservice getService() { return service; } }
|
GetServiceResponse { public Microservice getService() { return service; } Microservice getService(); void setService(Microservice service); }
|
GetServiceResponse { public Microservice getService() { return service; } Microservice getService(); void setService(Microservice service); }
|
@Test public void testGetErrorStack() { Throwable e = new Throwable(); FortifyUtils.getErrorStack(e); Assert.assertNotEquals(true, FortifyUtils.getErrorStack(e)); }
|
public static String getErrorStack(Throwable e) { if (null == e) { return ""; } try { StringWriter errors = new StringWriter(); printStackTraceMethod.invoke(e, new PrintWriter(errors)); return errors.toString(); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { return ""; } }
|
FortifyUtils { public static String getErrorStack(Throwable e) { if (null == e) { return ""; } try { StringWriter errors = new StringWriter(); printStackTraceMethod.invoke(e, new PrintWriter(errors)); return errors.toString(); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { return ""; } } }
|
FortifyUtils { public static String getErrorStack(Throwable e) { if (null == e) { return ""; } try { StringWriter errors = new StringWriter(); printStackTraceMethod.invoke(e, new PrintWriter(errors)); return errors.toString(); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { return ""; } } private FortifyUtils(); }
|
FortifyUtils { public static String getErrorStack(Throwable e) { if (null == e) { return ""; } try { StringWriter errors = new StringWriter(); printStackTraceMethod.invoke(e, new PrintWriter(errors)); return errors.toString(); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { return ""; } } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); }
|
FortifyUtils { public static String getErrorStack(Throwable e) { if (null == e) { return ""; } try { StringWriter errors = new StringWriter(); printStackTraceMethod.invoke(e, new PrintWriter(errors)); return errors.toString(); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { return ""; } } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); }
|
@Test public void testGetErrorInfo() { Throwable e = new Throwable(); FortifyUtils.getErrorInfo(e, true); Assert.assertNotEquals(true, FortifyUtils.getErrorInfo(e, true)); }
|
public static String getErrorInfo(Throwable e) { return getErrorInfo(e, true); }
|
FortifyUtils { public static String getErrorInfo(Throwable e) { return getErrorInfo(e, true); } }
|
FortifyUtils { public static String getErrorInfo(Throwable e) { return getErrorInfo(e, true); } private FortifyUtils(); }
|
FortifyUtils { public static String getErrorInfo(Throwable e) { return getErrorInfo(e, true); } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); }
|
FortifyUtils { public static String getErrorInfo(Throwable e) { return getErrorInfo(e, true); } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); }
|
@Test public void testSortedAcceptableMimeTypes1() { String accept = "text/html"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(1, types.size()); assertEquals("text/html", types.get(0)); }
|
public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
@Test public void testSortedAcceptableMimeTypes2() { String accept = "text/html, application/json"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(2, types.size()); assertEquals("text/html", types.get(0)); assertEquals("application/json", types.get(1)); }
|
public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
@Test public void testSortedAcceptableMimeTypes3() { String accept = "text/html,application/json"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(2, types.size()); assertEquals("text/html", types.get(0)); assertEquals("application/json", types.get(1)); }
|
public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
@Test public void testSortedAcceptableMimeTypes4() { String accept = "text/html; q=0.8,application/json; q=0.9"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(2, types.size()); assertEquals("application/json", types.get(0)); assertEquals("text/html", types.get(1)); }
|
public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
@Test public void testSortedAcceptableMimeTypes5() { String accept = "text/html;q=0.8,application/json;q=0.9"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(2, types.size()); assertEquals("application/json", types.get(0)); assertEquals("text/html", types.get(1)); }
|
public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
@Test public void testSortedAcceptableMimeTypes6() { String accept = "text/html; q=0.8,application/json; q=0.9, text/plain"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(3, types.size()); assertEquals("text/plain", types.get(0)); assertEquals("application/json", types.get(1)); assertEquals("text/html", types.get(2)); }
|
public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
@Test public void testSortedAcceptableMimeTypes7() { String accept = "text/html;q=0.8,application/json;q=0.9,text/plain"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(3, types.size()); assertEquals("text/plain", types.get(0)); assertEquals("application/json", types.get(1)); assertEquals("text/html", types.get(2)); }
|
public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
@Test public void getSortedAcceptableMimeTypesNull() { List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(null); Assert.assertSame(Collections.emptyList(), types); }
|
public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); }
|
@Test public void testDefaultValues() { Assert.assertNull(oGetInstancesResponse.getInstances()); }
|
public List<MicroserviceInstance> getInstances() { return instances; }
|
GetInstancesResponse { public List<MicroserviceInstance> getInstances() { return instances; } }
|
GetInstancesResponse { public List<MicroserviceInstance> getInstances() { return instances; } }
|
GetInstancesResponse { public List<MicroserviceInstance> getInstances() { return instances; } List<MicroserviceInstance> getInstances(); void setInstances(List<MicroserviceInstance> instances); }
|
GetInstancesResponse { public List<MicroserviceInstance> getInstances() { return instances; } List<MicroserviceInstance> getInstances(); void setInstances(List<MicroserviceInstance> instances); }
|
@Test public void testCalcMeasurements(@Mocked Id id) { List<String> list = new ArrayList<>(); list.add("useless"); list.add("useless"); list.add("eth0: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0"); new MockUp<FileUtils>() { @Mock public List<String> readLines(File file, Charset encoding) { return list; } }; NetMeter netMeter = new NetMeter(id); list.remove(2); list.add("eth0: 3 1 0 0 0 0 0 1 3 1 1 0 0 0 0 0"); List<Measurement> measurements = new ArrayList<>(); netMeter.calcMeasurements(measurements, 0L, 1); Assert.assertEquals(4, measurements.size()); Measurement receive = measurements.get(0); Measurement send = measurements.get(1); Measurement receivePackets = measurements.get(2); Measurement sendPackets = measurements.get(3); Assert.assertEquals(3.0, send.value(), 0.0); Assert.assertEquals(1.0, sendPackets.value(), 0.0); Assert.assertEquals(3.0, receive.value(), 0.0); Assert.assertEquals(1.0, receivePackets.value(), 0.0); }
|
public void calcMeasurements(List<Measurement> measurements, long msNow, long secondInterval) { refreshNet(secondInterval); interfaceUsageMap.values().forEach(interfaceUsage -> { interfaceUsage.calcMeasurements(measurements, msNow); }); }
|
NetMeter { public void calcMeasurements(List<Measurement> measurements, long msNow, long secondInterval) { refreshNet(secondInterval); interfaceUsageMap.values().forEach(interfaceUsage -> { interfaceUsage.calcMeasurements(measurements, msNow); }); } }
|
NetMeter { public void calcMeasurements(List<Measurement> measurements, long msNow, long secondInterval) { refreshNet(secondInterval); interfaceUsageMap.values().forEach(interfaceUsage -> { interfaceUsage.calcMeasurements(measurements, msNow); }); } NetMeter(Id id); }
|
NetMeter { public void calcMeasurements(List<Measurement> measurements, long msNow, long secondInterval) { refreshNet(secondInterval); interfaceUsageMap.values().forEach(interfaceUsage -> { interfaceUsage.calcMeasurements(measurements, msNow); }); } NetMeter(Id id); void calcMeasurements(List<Measurement> measurements, long msNow, long secondInterval); Map<String, InterfaceUsage> getInterfaceUsageMap(); }
|
NetMeter { public void calcMeasurements(List<Measurement> measurements, long msNow, long secondInterval) { refreshNet(secondInterval); interfaceUsageMap.values().forEach(interfaceUsage -> { interfaceUsage.calcMeasurements(measurements, msNow); }); } NetMeter(Id id); void calcMeasurements(List<Measurement> measurements, long msNow, long secondInterval); Map<String, InterfaceUsage> getInterfaceUsageMap(); static final String STATISTIC; static final String INTERFACE; static final Tag TAG_RECEIVE; static final Tag TAG_PACKETS_RECEIVE; static final Tag TAG_SEND; static final Tag TAG_PACKETS_SEND; }
|
@Test public void testGetTargetServiceNull() { SPIServiceDef0 service = SPIServiceUtils.getTargetService(SPIServiceDef0.class); Assert.assertNull(service); }
|
public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); }
|
@Test public void testGetTargetServiceNotNull() { SPIServiceDef service = SPIServiceUtils.getTargetService(SPIServiceDef.class); Assert.assertTrue(SPIServiceDef.class.isInstance(service)); Assert.assertSame(service, SPIServiceUtils.getTargetService(SPIServiceDef.class)); }
|
public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); }
|
@Test public void testGetTargetService_special_null() { Assert.assertNull(SPIServiceUtils.getTargetService(SPIServiceDef0.class, SPIServiceDef0Impl.class)); }
|
public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); }
|
@Test public void testGetTargetService_special_notNull() { SPIServiceDef service = SPIServiceUtils.getTargetService(SPIServiceDef.class, SPIServiceDefImpl.class); Assert.assertTrue(SPIServiceDefImpl.class.isInstance(service)); }
|
public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); }
|
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); }
|
@Test public void getPriorityHighestService_null() { Assert.assertNull(SPIServiceUtils.getPriorityHighestService(SPIServiceDef0.class)); }
|
public static <T> T getPriorityHighestService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); }
|
SPIServiceUtils { public static <T> T getPriorityHighestService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } }
|
SPIServiceUtils { public static <T> T getPriorityHighestService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); }
|
SPIServiceUtils { public static <T> T getPriorityHighestService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); }
|
SPIServiceUtils { public static <T> T getPriorityHighestService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); }
|
@Test public void getPriorityHighestServices() { Map<String, PriorityIntf> instances = new LinkedHashMap<>(); instances.putIfAbsent("1", new PriorityImpl("n1", 0)); instances.putIfAbsent("2", new PriorityImpl("n1", -1)); instances.putIfAbsent("3", new PriorityImpl("n1", 1)); instances.putIfAbsent("4", new PriorityImpl("n2", 0)); instances.putIfAbsent("5", new PriorityImpl("n2", -1)); instances.putIfAbsent("6", new PriorityImpl("n2", 1)); ServiceLoader<PriorityIntf> serviceLoader = ServiceLoader.load(PriorityIntf.class); Deencapsulation.setField(serviceLoader, "providers", instances); new Expectations(ServiceLoader.class) { { ServiceLoader.load(PriorityIntf.class); result = serviceLoader; } }; Assert.assertThat(SPIServiceUtils.getPriorityHighestServices(inst -> inst.getName(), PriorityIntf.class), Matchers.containsInAnyOrder(instances.get("2"), instances.get("5"))); Map<Class<?>, List<Object>> cache = Deencapsulation.getField(SPIServiceUtils.class, "cache"); cache.clear(); }
|
public static <T> Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } Map<String, T> map = new HashMap<>(); services.forEach(instance -> map.putIfAbsent(keyFunc.apply(instance), instance)); return map.values(); }
|
SPIServiceUtils { public static <T> Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } Map<String, T> map = new HashMap<>(); services.forEach(instance -> map.putIfAbsent(keyFunc.apply(instance), instance)); return map.values(); } }
|
SPIServiceUtils { public static <T> Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } Map<String, T> map = new HashMap<>(); services.forEach(instance -> map.putIfAbsent(keyFunc.apply(instance), instance)); return map.values(); } private SPIServiceUtils(); }
|
SPIServiceUtils { public static <T> Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } Map<String, T> map = new HashMap<>(); services.forEach(instance -> map.putIfAbsent(keyFunc.apply(instance), instance)); return map.values(); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); }
|
SPIServiceUtils { public static <T> Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } Map<String, T> map = new HashMap<>(); services.forEach(instance -> map.putIfAbsent(keyFunc.apply(instance), instance)); return map.values(); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); }
|
@SuppressWarnings("unchecked") @Test public void createLambda_withInstance() throws Throwable { Supplier<Object> getter = LambdaMetafactoryUtils .createLambda(model, Model.class.getMethod("getF1"), Supplier.class); Consumer<Object> setter = LambdaMetafactoryUtils .createLambda(model, Model.class.getMethod("setF1", int.class), Consumer.class); Function<Object, Object> echo = LambdaMetafactoryUtils .createLambda(model, Model.class.getMethod("echo", List.class), Function.class); setter.accept(1); int f1 = (int) getter.get(); Assert.assertEquals(1, f1); Assert.assertThat((List<Integer>) echo.apply(Arrays.asList(2)), Matchers.contains(2)); }
|
@SuppressWarnings("unchecked") public static <T> T createLambda(Object instance, Method instanceMethod, Class<?> functionalIntfCls) { try { Method intfMethod = findAbstractMethod(functionalIntfCls); MethodHandle methodHandle = LOOKUP.unreflect(instanceMethod); MethodType intfMethodType = MethodType.methodType(intfMethod.getReturnType(), intfMethod.getParameterTypes()); MethodType instanceMethodType = MethodType .methodType(instanceMethod.getReturnType(), instanceMethod.getParameterTypes()); CallSite callSite = LambdaMetafactory.metafactory( LOOKUP, intfMethod.getName(), MethodType.methodType(functionalIntfCls, instance.getClass()), intfMethodType, methodHandle, instanceMethodType); return (T) callSite.getTarget().bindTo(instance).invoke(); } catch (Throwable e) { throw new IllegalStateException("Failed to create lambda from " + instanceMethod, e); } }
|
LambdaMetafactoryUtils { @SuppressWarnings("unchecked") public static <T> T createLambda(Object instance, Method instanceMethod, Class<?> functionalIntfCls) { try { Method intfMethod = findAbstractMethod(functionalIntfCls); MethodHandle methodHandle = LOOKUP.unreflect(instanceMethod); MethodType intfMethodType = MethodType.methodType(intfMethod.getReturnType(), intfMethod.getParameterTypes()); MethodType instanceMethodType = MethodType .methodType(instanceMethod.getReturnType(), instanceMethod.getParameterTypes()); CallSite callSite = LambdaMetafactory.metafactory( LOOKUP, intfMethod.getName(), MethodType.methodType(functionalIntfCls, instance.getClass()), intfMethodType, methodHandle, instanceMethodType); return (T) callSite.getTarget().bindTo(instance).invoke(); } catch (Throwable e) { throw new IllegalStateException("Failed to create lambda from " + instanceMethod, e); } } }
|
LambdaMetafactoryUtils { @SuppressWarnings("unchecked") public static <T> T createLambda(Object instance, Method instanceMethod, Class<?> functionalIntfCls) { try { Method intfMethod = findAbstractMethod(functionalIntfCls); MethodHandle methodHandle = LOOKUP.unreflect(instanceMethod); MethodType intfMethodType = MethodType.methodType(intfMethod.getReturnType(), intfMethod.getParameterTypes()); MethodType instanceMethodType = MethodType .methodType(instanceMethod.getReturnType(), instanceMethod.getParameterTypes()); CallSite callSite = LambdaMetafactory.metafactory( LOOKUP, intfMethod.getName(), MethodType.methodType(functionalIntfCls, instance.getClass()), intfMethodType, methodHandle, instanceMethodType); return (T) callSite.getTarget().bindTo(instance).invoke(); } catch (Throwable e) { throw new IllegalStateException("Failed to create lambda from " + instanceMethod, e); } } private LambdaMetafactoryUtils(); }
|
LambdaMetafactoryUtils { @SuppressWarnings("unchecked") public static <T> T createLambda(Object instance, Method instanceMethod, Class<?> functionalIntfCls) { try { Method intfMethod = findAbstractMethod(functionalIntfCls); MethodHandle methodHandle = LOOKUP.unreflect(instanceMethod); MethodType intfMethodType = MethodType.methodType(intfMethod.getReturnType(), intfMethod.getParameterTypes()); MethodType instanceMethodType = MethodType .methodType(instanceMethod.getReturnType(), instanceMethod.getParameterTypes()); CallSite callSite = LambdaMetafactory.metafactory( LOOKUP, intfMethod.getName(), MethodType.methodType(functionalIntfCls, instance.getClass()), intfMethodType, methodHandle, instanceMethodType); return (T) callSite.getTarget().bindTo(instance).invoke(); } catch (Throwable e) { throw new IllegalStateException("Failed to create lambda from " + instanceMethod, e); } } private LambdaMetafactoryUtils(); @SuppressWarnings("unchecked") static T createLambda(Object instance, Method instanceMethod, Class<?> functionalIntfCls); @SuppressWarnings("unchecked") static T createLambda(Method instanceMethod, Class<?> functionalIntfCls); static T createGetter(Method getMethod); @SuppressWarnings("unchecked") static Getter<Object, Object> createObjectGetter(Method getMethod); static Getter<Object, Object> createObjectGetter(BeanPropertyDefinition propertyDefinition); @SuppressWarnings("unchecked") static Getter<C, F> createGetter(Field field); static T createSetter(Method setMethod); @SuppressWarnings("unchecked") static Setter<Object, Object> createObjectSetter(Method setMethod); static Setter<Object, Object> createObjectSetter(BeanPropertyDefinition propertyDefinition); static Setter<C, F> createSetter(Field field); }
|
LambdaMetafactoryUtils { @SuppressWarnings("unchecked") public static <T> T createLambda(Object instance, Method instanceMethod, Class<?> functionalIntfCls) { try { Method intfMethod = findAbstractMethod(functionalIntfCls); MethodHandle methodHandle = LOOKUP.unreflect(instanceMethod); MethodType intfMethodType = MethodType.methodType(intfMethod.getReturnType(), intfMethod.getParameterTypes()); MethodType instanceMethodType = MethodType .methodType(instanceMethod.getReturnType(), instanceMethod.getParameterTypes()); CallSite callSite = LambdaMetafactory.metafactory( LOOKUP, intfMethod.getName(), MethodType.methodType(functionalIntfCls, instance.getClass()), intfMethodType, methodHandle, instanceMethodType); return (T) callSite.getTarget().bindTo(instance).invoke(); } catch (Throwable e) { throw new IllegalStateException("Failed to create lambda from " + instanceMethod, e); } } private LambdaMetafactoryUtils(); @SuppressWarnings("unchecked") static T createLambda(Object instance, Method instanceMethod, Class<?> functionalIntfCls); @SuppressWarnings("unchecked") static T createLambda(Method instanceMethod, Class<?> functionalIntfCls); static T createGetter(Method getMethod); @SuppressWarnings("unchecked") static Getter<Object, Object> createObjectGetter(Method getMethod); static Getter<Object, Object> createObjectGetter(BeanPropertyDefinition propertyDefinition); @SuppressWarnings("unchecked") static Getter<C, F> createGetter(Field field); static T createSetter(Method setMethod); @SuppressWarnings("unchecked") static Setter<Object, Object> createObjectSetter(Method setMethod); static Setter<Object, Object> createObjectSetter(BeanPropertyDefinition propertyDefinition); static Setter<C, F> createSetter(Field field); }
|
@Test public void testIsGenerics() { Assert.assertTrue(GenericsUtils.isGenericResponseType(List.class)); Assert.assertTrue(GenericsUtils.isGenericResponseType(Map.class)); Assert.assertTrue(GenericsUtils.isGenericResponseType(Person.class)); Assert.assertFalse(GenericsUtils.isGenericResponseType(Man.class)); Assert.assertFalse(GenericsUtils.isGenericResponseType(String.class)); Assert.assertFalse(GenericsUtils.isGenericResponseType(GenericsUtils.class)); Assert.assertFalse(GenericsUtils.isGenericResponseType(new ParameterizedTypeReference<List<Man>>() { }.getType())); }
|
public static boolean isGenericResponseType(Type type) { if (type instanceof ParameterizedType) { return false; } if (type instanceof Class<?>) { return ((Class<?>) type).getTypeParameters().length > 0; } return true; }
|
GenericsUtils { public static boolean isGenericResponseType(Type type) { if (type instanceof ParameterizedType) { return false; } if (type instanceof Class<?>) { return ((Class<?>) type).getTypeParameters().length > 0; } return true; } }
|
GenericsUtils { public static boolean isGenericResponseType(Type type) { if (type instanceof ParameterizedType) { return false; } if (type instanceof Class<?>) { return ((Class<?>) type).getTypeParameters().length > 0; } return true; } }
|
GenericsUtils { public static boolean isGenericResponseType(Type type) { if (type instanceof ParameterizedType) { return false; } if (type instanceof Class<?>) { return ((Class<?>) type).getTypeParameters().length > 0; } return true; } static boolean isGenericResponseType(Type type); }
|
GenericsUtils { public static boolean isGenericResponseType(Type type) { if (type instanceof ParameterizedType) { return false; } if (type instanceof Class<?>) { return ((Class<?>) type).getTypeParameters().length > 0; } return true; } static boolean isGenericResponseType(Type type); }
|
@Test public void testExceptionUtils() { Exception e = new Exception("Hello"); Assert.assertEquals("cause:Exception,message:Hello", ExceptionUtils.getExceptionMessageWithoutTrace(e)); Exception e2 = new Exception("FAIL", new IOException("IO")); Assert.assertEquals("cause:Exception,message:FAIL;cause:IOException,message:IO", ExceptionUtils.getExceptionMessageWithoutTrace(e2)); }
|
private ExceptionUtils() { }
|
ExceptionUtils { private ExceptionUtils() { } }
|
ExceptionUtils { private ExceptionUtils() { } private ExceptionUtils(); }
|
ExceptionUtils { private ExceptionUtils() { } private ExceptionUtils(); static String getExceptionMessageWithoutTrace(Throwable e); }
|
ExceptionUtils { private ExceptionUtils() { } private ExceptionUtils(); static String getExceptionMessageWithoutTrace(Throwable e); }
|
@Test public void loadResources_in_jar() throws IOException, URISyntaxException { List<URI> uris = ResourceUtil.findResources("META-INF", p -> p.toString().endsWith("spring.factories")); Assert.assertEquals(1, uris.size()); Assert.assertTrue(uris.get(0).toString().startsWith("jar:file:")); Assert.assertTrue(uris.get(0).toString().endsWith("!/META-INF/spring.factories")); }
|
public static List<URI> findResources(String resourceLocation) throws IOException, URISyntaxException { return findResources(resourceLocation, p -> true); }
|
ResourceUtil { public static List<URI> findResources(String resourceLocation) throws IOException, URISyntaxException { return findResources(resourceLocation, p -> true); } }
|
ResourceUtil { public static List<URI> findResources(String resourceLocation) throws IOException, URISyntaxException { return findResources(resourceLocation, p -> true); } private ResourceUtil(); }
|
ResourceUtil { public static List<URI> findResources(String resourceLocation) throws IOException, URISyntaxException { return findResources(resourceLocation, p -> true); } private ResourceUtil(); static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix); static List<URI> findResources(String resourceLocation); static List<URI> findResources(String resourceLocation, Predicate<Path> filter); }
|
ResourceUtil { public static List<URI> findResources(String resourceLocation) throws IOException, URISyntaxException { return findResources(resourceLocation, p -> true); } private ResourceUtil(); static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix); static List<URI> findResources(String resourceLocation); static List<URI> findResources(String resourceLocation, Predicate<Path> filter); }
|
@Test public void testInitializedValues() { initFields(); Assert.assertEquals(1, oGetInstancesResponse.getInstances().size()); }
|
public List<MicroserviceInstance> getInstances() { return instances; }
|
GetInstancesResponse { public List<MicroserviceInstance> getInstances() { return instances; } }
|
GetInstancesResponse { public List<MicroserviceInstance> getInstances() { return instances; } }
|
GetInstancesResponse { public List<MicroserviceInstance> getInstances() { return instances; } List<MicroserviceInstance> getInstances(); void setInstances(List<MicroserviceInstance> instances); }
|
GetInstancesResponse { public List<MicroserviceInstance> getInstances() { return instances; } List<MicroserviceInstance> getInstances(); void setInstances(List<MicroserviceInstance> instances); }
|
@Test public void loadResources_in_disk() throws IOException, URISyntaxException { List<URI> uris = ResourceUtil.findResourcesBySuffix("META-INF/spring", ".xml"); Assert.assertEquals(1, uris.size()); URI uri = uris.get(0); Assert.assertTrue("unexpected uri: " + uri, uri.toString().startsWith("file:")); Assert.assertTrue("unexpected uri: " + uri, uri.toString().endsWith("META-INF/spring/config.bean.xml")); }
|
public static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix) throws IOException, URISyntaxException { return findResources(resourceLocation, path -> path.toString().endsWith(fileNameSuffix)); }
|
ResourceUtil { public static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix) throws IOException, URISyntaxException { return findResources(resourceLocation, path -> path.toString().endsWith(fileNameSuffix)); } }
|
ResourceUtil { public static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix) throws IOException, URISyntaxException { return findResources(resourceLocation, path -> path.toString().endsWith(fileNameSuffix)); } private ResourceUtil(); }
|
ResourceUtil { public static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix) throws IOException, URISyntaxException { return findResources(resourceLocation, path -> path.toString().endsWith(fileNameSuffix)); } private ResourceUtil(); static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix); static List<URI> findResources(String resourceLocation); static List<URI> findResources(String resourceLocation, Predicate<Path> filter); }
|
ResourceUtil { public static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix) throws IOException, URISyntaxException { return findResources(resourceLocation, path -> path.toString().endsWith(fileNameSuffix)); } private ResourceUtil(); static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix); static List<URI> findResources(String resourceLocation); static List<URI> findResources(String resourceLocation, Predicate<Path> filter); }
|
@Test public void loadResources_exact_file_in_disk() throws IOException, URISyntaxException { List<URI> uris = ResourceUtil.findResources("META-INF/spring/config.bean.xml"); Assert.assertEquals(1, uris.size()); URI uri = uris.get(0); Assert.assertTrue("unexpected uri: " + uri, uri.toString().startsWith("file:")); Assert.assertTrue("unexpected uri: " + uri, uri.toString().endsWith("META-INF/spring/config.bean.xml")); }
|
public static List<URI> findResources(String resourceLocation) throws IOException, URISyntaxException { return findResources(resourceLocation, p -> true); }
|
ResourceUtil { public static List<URI> findResources(String resourceLocation) throws IOException, URISyntaxException { return findResources(resourceLocation, p -> true); } }
|
ResourceUtil { public static List<URI> findResources(String resourceLocation) throws IOException, URISyntaxException { return findResources(resourceLocation, p -> true); } private ResourceUtil(); }
|
ResourceUtil { public static List<URI> findResources(String resourceLocation) throws IOException, URISyntaxException { return findResources(resourceLocation, p -> true); } private ResourceUtil(); static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix); static List<URI> findResources(String resourceLocation); static List<URI> findResources(String resourceLocation, Predicate<Path> filter); }
|
ResourceUtil { public static List<URI> findResources(String resourceLocation) throws IOException, URISyntaxException { return findResources(resourceLocation, p -> true); } private ResourceUtil(); static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix); static List<URI> findResources(String resourceLocation); static List<URI> findResources(String resourceLocation, Predicate<Path> filter); }
|
@Test public void init() { Holder<Boolean> propertiesLoaded = new Holder<>(false); Holder<Boolean> logConfigured = new Holder<>(false); Holder<Boolean> mergedFileWritten = new Holder<>(false); final Properties logProperties = new Properties(); logProperties.setProperty("paas.logs.file", "cse.log"); final ArrayList<Resource> logResList = new ArrayList<>(); new MockUp<PropertiesLoader>() { @Mock Properties load() { propertiesLoaded.value = true; return logProperties; } @Mock List<Resource> getFoundResList() { return logResList; } }; new MockUp<PropertyConfigurator>() { @Mock void configure(Properties properties) { logConfigured.value = true; Assert.assertSame(properties, logProperties); } }; new MockUp<Log4jUtils>() { @Mock void outputFile(List<Resource> resList, Properties properties) { mergedFileWritten.value = true; Assert.assertSame(logResList, resList); Assert.assertSame(logProperties, properties); } }; Assert.assertFalse(Deencapsulation.getField(Log4jUtils.class, "inited")); try { Log4jUtils.init(); } catch (Exception e) { fail(e.getMessage()); } Assert.assertTrue(Deencapsulation.getField(Log4jUtils.class, "inited")); Assert.assertTrue(propertiesLoaded.value); Assert.assertTrue(logConfigured.value); Assert.assertTrue(mergedFileWritten.value); }
|
public static void init() throws Exception { init(Arrays.asList("classpath*:config/base/log4j.properties", "classpath*:config/log4j.properties")); }
|
Log4jUtils { public static void init() throws Exception { init(Arrays.asList("classpath*:config/base/log4j.properties", "classpath*:config/log4j.properties")); } }
|
Log4jUtils { public static void init() throws Exception { init(Arrays.asList("classpath*:config/base/log4j.properties", "classpath*:config/log4j.properties")); } private Log4jUtils(); }
|
Log4jUtils { public static void init() throws Exception { init(Arrays.asList("classpath*:config/base/log4j.properties", "classpath*:config/log4j.properties")); } private Log4jUtils(); static void init(); static void init(String locationPattern); static void init(List<String> locationPatterns); }
|
Log4jUtils { public static void init() throws Exception { init(Arrays.asList("classpath*:config/base/log4j.properties", "classpath*:config/log4j.properties")); } private Log4jUtils(); static void init(); static void init(String locationPattern); static void init(List<String> locationPatterns); static final String OUTPUT_CONFIG_ENABLED; static final String OUTPUT_CONFIG_ENABLED_TRUE; }
|
@Test public void initOnMergedFileOutputDisabled() { Holder<Boolean> propertiesLoaded = new Holder<>(false); Holder<Boolean> logConfigured = new Holder<>(false); Holder<Boolean> mergedFileWritten = new Holder<>(false); final Properties logProperties = new Properties(); logProperties.setProperty("log4j.logger.outputConfig.enabled", "false"); final ArrayList<Resource> logResList = new ArrayList<>(); new MockUp<PropertiesLoader>() { @Mock Properties load() { propertiesLoaded.value = true; return logProperties; } }; new MockUp<PropertyConfigurator>() { @Mock void configure(Properties properties) { logConfigured.value = true; Assert.assertSame(properties, logProperties); } }; new MockUp<Log4jUtils>() { @Mock void outputFile(List<Resource> resList, Properties properties) { mergedFileWritten.value = true; Assert.assertSame(logResList, resList); Assert.assertSame(logProperties, properties); } }; Assert.assertFalse(Deencapsulation.getField(Log4jUtils.class, "inited")); try { Log4jUtils.init(); } catch (Exception e) { fail(e.getMessage()); } Assert.assertTrue(Deencapsulation.getField(Log4jUtils.class, "inited")); Assert.assertTrue(propertiesLoaded.value); Assert.assertTrue(logConfigured.value); Assert.assertFalse(mergedFileWritten.value); }
|
public static void init() throws Exception { init(Arrays.asList("classpath*:config/base/log4j.properties", "classpath*:config/log4j.properties")); }
|
Log4jUtils { public static void init() throws Exception { init(Arrays.asList("classpath*:config/base/log4j.properties", "classpath*:config/log4j.properties")); } }
|
Log4jUtils { public static void init() throws Exception { init(Arrays.asList("classpath*:config/base/log4j.properties", "classpath*:config/log4j.properties")); } private Log4jUtils(); }
|
Log4jUtils { public static void init() throws Exception { init(Arrays.asList("classpath*:config/base/log4j.properties", "classpath*:config/log4j.properties")); } private Log4jUtils(); static void init(); static void init(String locationPattern); static void init(List<String> locationPatterns); }
|
Log4jUtils { public static void init() throws Exception { init(Arrays.asList("classpath*:config/base/log4j.properties", "classpath*:config/log4j.properties")); } private Log4jUtils(); static void init(); static void init(String locationPattern); static void init(List<String> locationPatterns); static final String OUTPUT_CONFIG_ENABLED; static final String OUTPUT_CONFIG_ENABLED_TRUE; }
|
@Test void should_convert_success_async_to_sync() { CompletableFuture<String> future = CompletableFuture.completedFuture("value"); assertThat(AsyncUtils.toSync(future)).isEqualTo("value"); }
|
public static <T> T toSync(CompletableFuture<T> future) { try { return future.get(); } catch (Throwable e) { rethrow(e.getCause()); return null; } }
|
AsyncUtils { public static <T> T toSync(CompletableFuture<T> future) { try { return future.get(); } catch (Throwable e) { rethrow(e.getCause()); return null; } } }
|
AsyncUtils { public static <T> T toSync(CompletableFuture<T> future) { try { return future.get(); } catch (Throwable e) { rethrow(e.getCause()); return null; } } private AsyncUtils(); }
|
AsyncUtils { public static <T> T toSync(CompletableFuture<T> future) { try { return future.get(); } catch (Throwable e) { rethrow(e.getCause()); return null; } } private AsyncUtils(); static CompletableFuture<T> tryCatch(Supplier<CompletableFuture<T>> supplier); static CompletableFuture<T> completeExceptionally(Throwable throwable); @SuppressWarnings("unchecked") static void rethrow(Throwable exception); static T toSync(CompletableFuture<T> future); }
|
AsyncUtils { public static <T> T toSync(CompletableFuture<T> future) { try { return future.get(); } catch (Throwable e) { rethrow(e.getCause()); return null; } } private AsyncUtils(); static CompletableFuture<T> tryCatch(Supplier<CompletableFuture<T>> supplier); static CompletableFuture<T> completeExceptionally(Throwable throwable); @SuppressWarnings("unchecked") static void rethrow(Throwable exception); static T toSync(CompletableFuture<T> future); }
|
@Test public void findMainClass_notExist() { Assert.assertNull(JvmUtils.findMainClass()); }
|
public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
@Test public void findMainClass_existButEmpty() { System.setProperty(JvmUtils.SUN_JAVA_COMMAND, ""); Assert.assertNull(JvmUtils.findMainClass()); }
|
public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
@Test public void findMainClass_invalid() { LogCollector logCollector = new LogCollector(); System.setProperty(JvmUtils.SUN_JAVA_COMMAND, "invalidCls"); Assert.assertNull(JvmUtils.findMainClass()); Assert.assertEquals("\"invalidCls\" is not a valid class.", logCollector.getEvents().get(0).getMessage()); logCollector.teardown(); }
|
public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
@Test public void findMainClass_class_normal() { System.setProperty(JvmUtils.SUN_JAVA_COMMAND, TestJvmUtils.class.getName() + " arg"); Assert.assertEquals(TestJvmUtils.class, JvmUtils.findMainClass()); }
|
public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
@Test public void findMainClass_jar_normal() throws Exception { URL url = PowerMockito.mock(URL.class); String command = "a.jar"; String manifestUri = "jar:file:" + new File(command).getAbsolutePath() + "!/" + JarFile.MANIFEST_NAME; PowerMockito.whenNew(URL.class).withParameterTypes(String.class) .withArguments(manifestUri).thenReturn(url); String content = String.format("Manifest-Version: 1.0\nMain-Class: %s\n", TestJvmUtils.class.getName()); InputStream inputStream = new ByteArrayInputStream(content.getBytes()); PowerMockito.when(url.openStream()).thenReturn(inputStream); System.setProperty(JvmUtils.SUN_JAVA_COMMAND, command + " arg"); Assert.assertEquals(TestJvmUtils.class, JvmUtils.findMainClass()); }
|
public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
@Test public void testServiceRegistryConfig() { ServiceRegistryConfig oConfig = new ServiceRegistryConfigBuilder().build(); Assert.assertNull(oConfig.getAccessKey()); Assert.assertEquals(1000, oConfig.getConnectionTimeout()); Assert.assertNotEquals(null, oConfig.getHeartbeatInterval()); Assert.assertEquals("HTTP_1_1", oConfig.getHttpVersion().name()); Assert.assertEquals("rest", oConfig.getTransport()); Assert.assertEquals(1, oConfig.getInstances()); Assert.assertTrue(oConfig.isSsl()); Assert.assertEquals(30000, oConfig.getRequestTimeout()); Assert.assertEquals(3000, oConfig.getHeartBeatRequestTimeout()); Assert.assertNotEquals(null, oConfig.getResendHeartBeatTimes()); Assert.assertFalse(oConfig.isPreferIpAddress()); Assert.assertTrue(oConfig.isWatch()); Assert.assertEquals(ServiceRegistryConfig.NO_TENANT, oConfig.getTenantName()); Assert.assertNull(oConfig.getSecretKey()); List<IpPort> ipPorts = oConfig.getIpPort(); Assert.assertEquals("127.0.0.1:80", ipPorts.get(0).toString()); Assert.assertEquals("127.0.0.1:443", ipPorts.get(1).toString()); Assert.assertFalse(oConfig.isProxyEnable()); Assert.assertEquals("127.0.0.1", oConfig.getProxyHost()); Assert.assertEquals(8080, oConfig.getProxyPort()); Assert.assertNull(oConfig.getProxyUsername()); Assert.assertNull(oConfig.getProxyPasswd()); }
|
public ServiceRegistryConfig() { }
|
ServiceRegistryConfig { public ServiceRegistryConfig() { } }
|
ServiceRegistryConfig { public ServiceRegistryConfig() { } ServiceRegistryConfig(); }
|
ServiceRegistryConfig { public ServiceRegistryConfig() { } ServiceRegistryConfig(); static ServiceRegistryConfig buildFromConfiguration(); String getTransport(); String getRegistryName(); ServiceRegistryConfig setRegistryName(String registryName); HttpVersion getHttpVersion(); ServiceRegistryConfig setHttpVersion(HttpVersion httpVersion); int getInstances(); ServiceRegistryConfig setInstances(int instances); boolean isSsl(); ServiceRegistryConfig setSsl(boolean ssl); String getClientName(); ServiceRegistryConfig setClientName(String clientName); String getWatchClientName(); ServiceRegistryConfig setWatchClientName(String watchClientName); ArrayList<IpPort> getIpPort(); ServiceRegistryConfig setIpPort(ArrayList<IpPort> ipPort); int getConnectionTimeout(); ServiceRegistryConfig setConnectionTimeout(int connectionTimeout); int getIdleConnectionTimeout(); ServiceRegistryConfig setIdleConnectionTimeout(int idleConnectionTimeout); int getRequestTimeout(); ServiceRegistryConfig setRequestTimeout(int requestTimeout); int getHeartBeatRequestTimeout(); ServiceRegistryConfig setHeartBeatRequestTimeout(int heartBeatRequestTimeout); int getHeartbeatInterval(); ServiceRegistryConfig setHeartbeatInterval(int heartbeatInterval); int getInstancePullInterval(); ServiceRegistryConfig setInstancePullInterval(int instancePullInterval); boolean isRegistryAutoDiscovery(); ServiceRegistryConfig setRegistryAutoDiscovery(boolean registryAutoDiscovery); int getResendHeartBeatTimes(); ServiceRegistryConfig setResendHeartBeatTimes(int resendHeartBeatTimes); boolean isAlwaysOverrideSchema(); ServiceRegistryConfig setAlwaysOverrideSchema(boolean alwaysOverrideSchema); boolean isPreferIpAddress(); ServiceRegistryConfig setPreferIpAddress(boolean preferIpAddress); boolean isWatch(); ServiceRegistryConfig setWatch(boolean watch); String getRegistryApiVersion(); ServiceRegistryConfig setRegistryApiVersion(String registryApiVersion); String getTenantName(); ServiceRegistryConfig setTenantName(String tenantName); String getDomainName(); ServiceRegistryConfig setDomainName(String domainName); String getAccessKey(); ServiceRegistryConfig setAccessKey(String accessKey); String getSecretKey(); ServiceRegistryConfig setSecretKey(String secretKey); Boolean isProxyEnable(); ServiceRegistryConfig setProxyEnable(Boolean proxyEnable); String getProxyHost(); ServiceRegistryConfig setProxyHost(String proxyHost); int getProxyPort(); ServiceRegistryConfig setProxyPort(int proxyPort); String getProxyUsername(); ServiceRegistryConfig setProxyUsername(String proxyUsername); String getProxyPasswd(); ServiceRegistryConfig setProxyPasswd(String proxyPasswd); List<AuthHeaderProvider> getAuthHeaderProviders(); ServiceRegistryConfig setAuthHeaderProviders(
List<AuthHeaderProvider> authHeaderProviders); ServiceRegistryConfig setServiceRegistryClientConstructor(
Function<ServiceRegistry, ServiceRegistryClient> serviceRegistryClientConstructor); ServiceRegistryClient createServiceRegistryClient(ServiceRegistry serviceRegistry); }
|
ServiceRegistryConfig { public ServiceRegistryConfig() { } ServiceRegistryConfig(); static ServiceRegistryConfig buildFromConfiguration(); String getTransport(); String getRegistryName(); ServiceRegistryConfig setRegistryName(String registryName); HttpVersion getHttpVersion(); ServiceRegistryConfig setHttpVersion(HttpVersion httpVersion); int getInstances(); ServiceRegistryConfig setInstances(int instances); boolean isSsl(); ServiceRegistryConfig setSsl(boolean ssl); String getClientName(); ServiceRegistryConfig setClientName(String clientName); String getWatchClientName(); ServiceRegistryConfig setWatchClientName(String watchClientName); ArrayList<IpPort> getIpPort(); ServiceRegistryConfig setIpPort(ArrayList<IpPort> ipPort); int getConnectionTimeout(); ServiceRegistryConfig setConnectionTimeout(int connectionTimeout); int getIdleConnectionTimeout(); ServiceRegistryConfig setIdleConnectionTimeout(int idleConnectionTimeout); int getRequestTimeout(); ServiceRegistryConfig setRequestTimeout(int requestTimeout); int getHeartBeatRequestTimeout(); ServiceRegistryConfig setHeartBeatRequestTimeout(int heartBeatRequestTimeout); int getHeartbeatInterval(); ServiceRegistryConfig setHeartbeatInterval(int heartbeatInterval); int getInstancePullInterval(); ServiceRegistryConfig setInstancePullInterval(int instancePullInterval); boolean isRegistryAutoDiscovery(); ServiceRegistryConfig setRegistryAutoDiscovery(boolean registryAutoDiscovery); int getResendHeartBeatTimes(); ServiceRegistryConfig setResendHeartBeatTimes(int resendHeartBeatTimes); boolean isAlwaysOverrideSchema(); ServiceRegistryConfig setAlwaysOverrideSchema(boolean alwaysOverrideSchema); boolean isPreferIpAddress(); ServiceRegistryConfig setPreferIpAddress(boolean preferIpAddress); boolean isWatch(); ServiceRegistryConfig setWatch(boolean watch); String getRegistryApiVersion(); ServiceRegistryConfig setRegistryApiVersion(String registryApiVersion); String getTenantName(); ServiceRegistryConfig setTenantName(String tenantName); String getDomainName(); ServiceRegistryConfig setDomainName(String domainName); String getAccessKey(); ServiceRegistryConfig setAccessKey(String accessKey); String getSecretKey(); ServiceRegistryConfig setSecretKey(String secretKey); Boolean isProxyEnable(); ServiceRegistryConfig setProxyEnable(Boolean proxyEnable); String getProxyHost(); ServiceRegistryConfig setProxyHost(String proxyHost); int getProxyPort(); ServiceRegistryConfig setProxyPort(int proxyPort); String getProxyUsername(); ServiceRegistryConfig setProxyUsername(String proxyUsername); String getProxyPasswd(); ServiceRegistryConfig setProxyPasswd(String proxyPasswd); List<AuthHeaderProvider> getAuthHeaderProviders(); ServiceRegistryConfig setAuthHeaderProviders(
List<AuthHeaderProvider> authHeaderProviders); ServiceRegistryConfig setServiceRegistryClientConstructor(
Function<ServiceRegistry, ServiceRegistryClient> serviceRegistryClientConstructor); ServiceRegistryClient createServiceRegistryClient(ServiceRegistry serviceRegistry); static final ServiceRegistryConfig INSTANCE; static final int DEFAULT_TIMEOUT_IN_SECONDS; static final int DEFAULT_REQUEST_TIMEOUT_IN_MS; static final int DEFAULT_REQUEST_HEARTBEAT_TIMEOUT_IN_MS; static final int DEFAULT_CHECK_INTERVAL_IN_S; static final int DEFAULT_CHECK_TIMES; static final String AUTH_ENABLED; static final String TENANT_ACCESS_KEY; static final String TENANT_SECRET_KEY; static final String REGISTRY_API_VERSION; static final String TENANT_NAME; static final String DOMAIN_NAME; static final String NO_TENANT; static final String NO_DOMAIN; static final String VERTICLE_INSTANCES; static final String EVENT_LOOP_POOL_SIZE; static final String WORKER_POOL_SIZE; }
|
@Test public void findMainClass_jar_null() throws Exception { String content = "Manifest-Version: 1.0\n"; InputStream inputStream = new ByteArrayInputStream(content.getBytes()); URL url = PowerMockito.mock(URL.class); String command = "a.jar"; String manifestUri = "jar:file:/" + new File(command).getAbsolutePath() + "!/" + JarFile.MANIFEST_NAME; PowerMockito.whenNew(URL.class).withParameterTypes(String.class) .withArguments(manifestUri).thenReturn(url); PowerMockito.when(url.openStream()).thenReturn(inputStream); System.setProperty(JvmUtils.SUN_JAVA_COMMAND, command + " arg"); Assert.assertNull(JvmUtils.findMainClass()); }
|
public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
@Test public void findMainClass_jar_readFailed() throws Exception { URL url = PowerMockito.mock(URL.class); String command = "a.jar"; String manifestUri = "jar:file:" + new File(command).getAbsolutePath() + "!/" + JarFile.MANIFEST_NAME; PowerMockito.whenNew(URL.class).withParameterTypes(String.class) .withArguments(manifestUri).thenReturn(url); PowerMockito.when(url.openStream()).thenThrow(new RuntimeExceptionWithoutStackTrace()); System.setProperty(JvmUtils.SUN_JAVA_COMMAND, command + " arg"); Assert.assertNull(JvmUtils.findMainClass()); }
|
public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
@Test public void findMainClassByStackTrace_normal() throws Exception{ RuntimeException re = PowerMockito.mock(RuntimeException.class); PowerMockito.when(re.getStackTrace()).thenReturn(new StackTraceElement[]{ new StackTraceElement("declaring.class.fileName", "methodName", "fileName", 100), new StackTraceElement("java.lang.String", "main", "fileName", 120) }); PowerMockito.whenNew(RuntimeException.class).withNoArguments().thenReturn(re); Assert.assertEquals(String.class, JvmUtils.findMainClassByStackTrace()); }
|
public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
@Test public void findMainClassByStackTrace_invalidClass() throws Exception{ RuntimeException re = PowerMockito.mock(RuntimeException.class); PowerMockito.when(re.getStackTrace()).thenReturn(new StackTraceElement[]{ new StackTraceElement("declaring.class.fileName", "methodName", "fileName", 100), new StackTraceElement("InvalidClass", "main", "fileName", 120) }); PowerMockito.whenNew(RuntimeException.class).withNoArguments().thenReturn(re); Assert.assertNull(JvmUtils.findMainClassByStackTrace()); }
|
public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
@Test public void findMainClassByStackTrace_withoutMainMethod() throws Exception{ RuntimeException re = PowerMockito.mock(RuntimeException.class); PowerMockito.when(re.getStackTrace()).thenReturn(new StackTraceElement[]{ new StackTraceElement("declaring.class.fileName", "methodName", "fileName", 100), new StackTraceElement("InvalidClass", "methodName", "fileName", 120) }); PowerMockito.whenNew(RuntimeException.class).withNoArguments().thenReturn(re); Assert.assertNull(JvmUtils.findMainClassByStackTrace()); }
|
public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
@Test public void findMainClassByStackTrace_emptyStackTrace() throws Exception{ RuntimeException re = PowerMockito.mock(RuntimeException.class); PowerMockito.when(re.getStackTrace()).thenReturn(new StackTraceElement[]{}); PowerMockito.whenNew(RuntimeException.class).withNoArguments().thenReturn(re); Assert.assertNull(JvmUtils.findMainClassByStackTrace()); }
|
public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
@Test public void findMainClassByStackTrace_nullStackTrace() throws Exception{ RuntimeException re = PowerMockito.mock(RuntimeException.class); PowerMockito.when(re.getStackTrace()).thenReturn(null); PowerMockito.whenNew(RuntimeException.class).withNoArguments().thenReturn(re); Assert.assertNull(JvmUtils.findMainClassByStackTrace()); }
|
public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); }
|
@Test public void test() { Intf target = new Impl(); AspectJProxyFactory factory = new AspectJProxyFactory(target); MyAspect aspect = new MyAspect(); factory.addAspect(aspect); Intf proxy = factory.getProxy(); Assert.assertEquals(Impl.class, BeanUtils.getImplClassFromBean(proxy)); Assert.assertEquals(Impl.class, BeanUtils.getImplClassFromBean(new Impl())); }
|
public static Class<?> getImplClassFromBean(Object bean) { return AopProxyUtils.ultimateTargetClass(bean); }
|
BeanUtils { public static Class<?> getImplClassFromBean(Object bean) { return AopProxyUtils.ultimateTargetClass(bean); } }
|
BeanUtils { public static Class<?> getImplClassFromBean(Object bean) { return AopProxyUtils.ultimateTargetClass(bean); } private BeanUtils(); }
|
BeanUtils { public static Class<?> getImplClassFromBean(Object bean) { return AopProxyUtils.ultimateTargetClass(bean); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); }
|
BeanUtils { public static Class<?> getImplClassFromBean(Object bean) { return AopProxyUtils.ultimateTargetClass(bean); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); static final String DEFAULT_BEAN_CORE_RESOURCE; static final String DEFAULT_BEAN_NORMAL_RESOURCE; static final String[] DEFAULT_BEAN_RESOURCE; static final String SCB_SCAN_PACKAGE; }
|
@Test public void prepareServiceCombScanPackage_noExist_noMain() { System.clearProperty(BeanUtils.SCB_SCAN_PACKAGE); new Expectations(JvmUtils.class) { { JvmUtils.findMainClass(); result = null; JvmUtils.findMainClassByStackTrace(); result = null; } }; BeanUtils.prepareServiceCombScanPackage(); Assert.assertEquals("org.apache.servicecomb", System.getProperty(BeanUtils.SCB_SCAN_PACKAGE)); }
|
public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); static final String DEFAULT_BEAN_CORE_RESOURCE; static final String DEFAULT_BEAN_NORMAL_RESOURCE; static final String[] DEFAULT_BEAN_RESOURCE; static final String SCB_SCAN_PACKAGE; }
|
@Test public void prepareServiceCombScanPackage_noExist_scbMain() { System.clearProperty(BeanUtils.SCB_SCAN_PACKAGE); new Expectations(JvmUtils.class) { { JvmUtils.findMainClass(); result = TestBeanUtils.class; JvmUtils.findMainClassByStackTrace(); result = TestBeanUtils.class; } }; BeanUtils.prepareServiceCombScanPackage(); Assert.assertEquals("org.apache.servicecomb", System.getProperty(BeanUtils.SCB_SCAN_PACKAGE)); }
|
public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); static final String DEFAULT_BEAN_CORE_RESOURCE; static final String DEFAULT_BEAN_NORMAL_RESOURCE; static final String[] DEFAULT_BEAN_RESOURCE; static final String SCB_SCAN_PACKAGE; }
|
@Test public void convertCacheToMicroserviceInstances() { MockedMicroserviceCache microserviceCache = new MockedMicroserviceCache(); microserviceCache.setStatus(MicroserviceCacheStatus.CLIENT_ERROR); MicroserviceInstances microserviceInstances = RegistryUtils .convertCacheToMicroserviceInstances(microserviceCache); Assert.assertNull(microserviceInstances); microserviceCache = new MockedMicroserviceCache(); microserviceCache.setStatus(MicroserviceCacheStatus.SETTING_CACHE_ERROR); microserviceInstances = RegistryUtils.convertCacheToMicroserviceInstances(microserviceCache); Assert.assertNull(microserviceInstances); microserviceCache = new MockedMicroserviceCache(); microserviceCache.setStatus(MicroserviceCacheStatus.INIT); microserviceInstances = RegistryUtils.convertCacheToMicroserviceInstances(microserviceCache); Assert.assertNull(microserviceInstances); microserviceCache = new MockedMicroserviceCache(); microserviceCache.setStatus(MicroserviceCacheStatus.SERVICE_NOT_FOUND); microserviceInstances = RegistryUtils.convertCacheToMicroserviceInstances(microserviceCache); Assert.assertTrue(microserviceInstances.isMicroserviceNotExist()); Assert.assertFalse(microserviceInstances.isNeedRefresh()); Assert.assertEquals("", microserviceInstances.getRevision()); Assert.assertNull(microserviceInstances.getInstancesResponse()); microserviceCache = new MockedMicroserviceCache(); microserviceCache.setStatus(MicroserviceCacheStatus.REFRESHED); microserviceCache.setRevisionId("0166f3c18702617d5e55cf911e4e412cc8760dab"); MicroserviceInstance microserviceInstance = new MicroserviceInstance(); microserviceCache.setInstances(Collections.singletonList(microserviceInstance)); microserviceInstances = RegistryUtils.convertCacheToMicroserviceInstances(microserviceCache); Assert.assertFalse(microserviceInstances.isMicroserviceNotExist()); Assert.assertTrue(microserviceInstances.isNeedRefresh()); Assert.assertEquals("0166f3c18702617d5e55cf911e4e412cc8760dab", microserviceInstances.getRevision()); Assert.assertEquals(1, microserviceInstances.getInstancesResponse().getInstances().size()); Assert.assertSame(microserviceInstance, microserviceInstances.getInstancesResponse().getInstances().get(0)); microserviceCache = new MockedMicroserviceCache(); microserviceCache.setStatus(MicroserviceCacheStatus.NO_CHANGE); microserviceCache.setRevisionId("0166f3c18702617d5e55cf911e4e412cc8760dab"); microserviceInstances = RegistryUtils.convertCacheToMicroserviceInstances(microserviceCache); Assert.assertFalse(microserviceInstances.isMicroserviceNotExist()); Assert.assertFalse(microserviceInstances.isNeedRefresh()); Assert.assertEquals("0166f3c18702617d5e55cf911e4e412cc8760dab", microserviceInstances.getRevision()); Assert.assertNull(microserviceInstances.getInstancesResponse()); }
|
public static MicroserviceInstances convertCacheToMicroserviceInstances(MicroserviceCache microserviceCache) { MicroserviceInstances microserviceInstances = new MicroserviceInstances(); switch (microserviceCache.getStatus()) { case SERVICE_NOT_FOUND: microserviceInstances.setMicroserviceNotExist(true); microserviceInstances.setNeedRefresh(false); microserviceInstances.setRevision(""); microserviceInstances.setInstancesResponse(null); return microserviceInstances; case NO_CHANGE: microserviceInstances.setMicroserviceNotExist(false); microserviceInstances.setNeedRefresh(false); microserviceInstances.setRevision(microserviceCache.getRevisionId()); return microserviceInstances; case REFRESHED: microserviceInstances.setMicroserviceNotExist(false); microserviceInstances.setNeedRefresh(true); microserviceInstances.setRevision(microserviceCache.getRevisionId()); FindInstancesResponse findInstancesResponse = new FindInstancesResponse(); findInstancesResponse.setInstances(new ArrayList<>(microserviceCache.getInstances())); microserviceInstances.setInstancesResponse(findInstancesResponse); return microserviceInstances; default: return null; } }
|
RegistryUtils { public static MicroserviceInstances convertCacheToMicroserviceInstances(MicroserviceCache microserviceCache) { MicroserviceInstances microserviceInstances = new MicroserviceInstances(); switch (microserviceCache.getStatus()) { case SERVICE_NOT_FOUND: microserviceInstances.setMicroserviceNotExist(true); microserviceInstances.setNeedRefresh(false); microserviceInstances.setRevision(""); microserviceInstances.setInstancesResponse(null); return microserviceInstances; case NO_CHANGE: microserviceInstances.setMicroserviceNotExist(false); microserviceInstances.setNeedRefresh(false); microserviceInstances.setRevision(microserviceCache.getRevisionId()); return microserviceInstances; case REFRESHED: microserviceInstances.setMicroserviceNotExist(false); microserviceInstances.setNeedRefresh(true); microserviceInstances.setRevision(microserviceCache.getRevisionId()); FindInstancesResponse findInstancesResponse = new FindInstancesResponse(); findInstancesResponse.setInstances(new ArrayList<>(microserviceCache.getInstances())); microserviceInstances.setInstancesResponse(findInstancesResponse); return microserviceInstances; default: return null; } } }
|
RegistryUtils { public static MicroserviceInstances convertCacheToMicroserviceInstances(MicroserviceCache microserviceCache) { MicroserviceInstances microserviceInstances = new MicroserviceInstances(); switch (microserviceCache.getStatus()) { case SERVICE_NOT_FOUND: microserviceInstances.setMicroserviceNotExist(true); microserviceInstances.setNeedRefresh(false); microserviceInstances.setRevision(""); microserviceInstances.setInstancesResponse(null); return microserviceInstances; case NO_CHANGE: microserviceInstances.setMicroserviceNotExist(false); microserviceInstances.setNeedRefresh(false); microserviceInstances.setRevision(microserviceCache.getRevisionId()); return microserviceInstances; case REFRESHED: microserviceInstances.setMicroserviceNotExist(false); microserviceInstances.setNeedRefresh(true); microserviceInstances.setRevision(microserviceCache.getRevisionId()); FindInstancesResponse findInstancesResponse = new FindInstancesResponse(); findInstancesResponse.setInstances(new ArrayList<>(microserviceCache.getInstances())); microserviceInstances.setInstancesResponse(findInstancesResponse); return microserviceInstances; default: return null; } } private RegistryUtils(); }
|
RegistryUtils { public static MicroserviceInstances convertCacheToMicroserviceInstances(MicroserviceCache microserviceCache) { MicroserviceInstances microserviceInstances = new MicroserviceInstances(); switch (microserviceCache.getStatus()) { case SERVICE_NOT_FOUND: microserviceInstances.setMicroserviceNotExist(true); microserviceInstances.setNeedRefresh(false); microserviceInstances.setRevision(""); microserviceInstances.setInstancesResponse(null); return microserviceInstances; case NO_CHANGE: microserviceInstances.setMicroserviceNotExist(false); microserviceInstances.setNeedRefresh(false); microserviceInstances.setRevision(microserviceCache.getRevisionId()); return microserviceInstances; case REFRESHED: microserviceInstances.setMicroserviceNotExist(false); microserviceInstances.setNeedRefresh(true); microserviceInstances.setRevision(microserviceCache.getRevisionId()); FindInstancesResponse findInstancesResponse = new FindInstancesResponse(); findInstancesResponse.setInstances(new ArrayList<>(microserviceCache.getInstances())); microserviceInstances.setInstancesResponse(findInstancesResponse); return microserviceInstances; default: return null; } } private RegistryUtils(); static synchronized void init(); static void run(); static void destroy(); static ServiceRegistry getServiceRegistry(); static void setServiceRegistry(ServiceRegistry serviceRegistry); @Deprecated static ServiceRegistryClient getServiceRegistryClient(); static String getAppId(); static Microservice getMicroservice(); static List<Microservice> getAllMicroservices(); static MicroserviceInstance getMicroserviceInstance(); static List<MicroserviceInstance> findServiceInstance(String appId, String serviceName,
String versionRule); static boolean updateInstanceProperties(Map<String, String> instanceProperties); static Microservice getMicroservice(String microserviceId); static MicroserviceInstances findServiceInstances(String appId, String serviceName,
String versionRule); static MicroserviceInstances convertCacheToMicroserviceInstances(MicroserviceCache microserviceCache); static String calcSchemaSummary(String schemaContent); static String getAggregatedSchema(String microserviceId, String schemaId); static Microservice getAggregatedRemoteMicroservice(String microserviceId); static T getResultFromFirstValidServiceRegistry(Function<ServiceRegistry, T> action); static void executeOnEachServiceRegistry(Consumer<ServiceRegistry> action); static void addExtraServiceRegistry(ServiceRegistry serviceRegistry); static void validateRegistryName(String name); }
|
RegistryUtils { public static MicroserviceInstances convertCacheToMicroserviceInstances(MicroserviceCache microserviceCache) { MicroserviceInstances microserviceInstances = new MicroserviceInstances(); switch (microserviceCache.getStatus()) { case SERVICE_NOT_FOUND: microserviceInstances.setMicroserviceNotExist(true); microserviceInstances.setNeedRefresh(false); microserviceInstances.setRevision(""); microserviceInstances.setInstancesResponse(null); return microserviceInstances; case NO_CHANGE: microserviceInstances.setMicroserviceNotExist(false); microserviceInstances.setNeedRefresh(false); microserviceInstances.setRevision(microserviceCache.getRevisionId()); return microserviceInstances; case REFRESHED: microserviceInstances.setMicroserviceNotExist(false); microserviceInstances.setNeedRefresh(true); microserviceInstances.setRevision(microserviceCache.getRevisionId()); FindInstancesResponse findInstancesResponse = new FindInstancesResponse(); findInstancesResponse.setInstances(new ArrayList<>(microserviceCache.getInstances())); microserviceInstances.setInstancesResponse(findInstancesResponse); return microserviceInstances; default: return null; } } private RegistryUtils(); static synchronized void init(); static void run(); static void destroy(); static ServiceRegistry getServiceRegistry(); static void setServiceRegistry(ServiceRegistry serviceRegistry); @Deprecated static ServiceRegistryClient getServiceRegistryClient(); static String getAppId(); static Microservice getMicroservice(); static List<Microservice> getAllMicroservices(); static MicroserviceInstance getMicroserviceInstance(); static List<MicroserviceInstance> findServiceInstance(String appId, String serviceName,
String versionRule); static boolean updateInstanceProperties(Map<String, String> instanceProperties); static Microservice getMicroservice(String microserviceId); static MicroserviceInstances findServiceInstances(String appId, String serviceName,
String versionRule); static MicroserviceInstances convertCacheToMicroserviceInstances(MicroserviceCache microserviceCache); static String calcSchemaSummary(String schemaContent); static String getAggregatedSchema(String microserviceId, String schemaId); static Microservice getAggregatedRemoteMicroservice(String microserviceId); static T getResultFromFirstValidServiceRegistry(Function<ServiceRegistry, T> action); static void executeOnEachServiceRegistry(Consumer<ServiceRegistry> action); static void addExtraServiceRegistry(ServiceRegistry serviceRegistry); static void validateRegistryName(String name); }
|
@Test public void prepareServiceCombScanPackage_noExist_otherMain() { System.clearProperty(BeanUtils.SCB_SCAN_PACKAGE); new Expectations(JvmUtils.class) { { JvmUtils.findMainClass(); result = String.class; JvmUtils.findMainClassByStackTrace(); result = BigDecimal.class; } }; BeanUtils.prepareServiceCombScanPackage(); Assert.assertEquals("org.apache.servicecomb,java.lang,java.math", System.getProperty(BeanUtils.SCB_SCAN_PACKAGE)); }
|
public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); static final String DEFAULT_BEAN_CORE_RESOURCE; static final String DEFAULT_BEAN_NORMAL_RESOURCE; static final String[] DEFAULT_BEAN_RESOURCE; static final String SCB_SCAN_PACKAGE; }
|
@Test public void prepareServiceCombScanPackage_exist() { System.setProperty(BeanUtils.SCB_SCAN_PACKAGE, "a.b,,c.d"); new Expectations(JvmUtils.class) { { JvmUtils.findMainClass(); result = null; JvmUtils.findMainClassByStackTrace(); result = null; } }; BeanUtils.prepareServiceCombScanPackage(); Assert.assertEquals("a.b,c.d,org.apache.servicecomb", System.getProperty(BeanUtils.SCB_SCAN_PACKAGE)); }
|
public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); }
|
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); static final String DEFAULT_BEAN_CORE_RESOURCE; static final String DEFAULT_BEAN_NORMAL_RESOURCE; static final String[] DEFAULT_BEAN_RESOURCE; static final String SCB_SCAN_PACKAGE; }
|
@Test public void init(@Mocked ClassPathXmlApplicationContext context) { System.clearProperty(BeanUtils.SCB_SCAN_PACKAGE); new Expectations(JvmUtils.class) { { JvmUtils.findMainClass(); result = TestBeanUtils.class; JvmUtils.findMainClassByStackTrace(); result = TestBeanUtils.class; } }; BeanUtils.init(); Assert.assertEquals("org.apache.servicecomb", System.getProperty(BeanUtils.SCB_SCAN_PACKAGE)); }
|
public static void init() { init(DEFAULT_BEAN_RESOURCE); }
|
BeanUtils { public static void init() { init(DEFAULT_BEAN_RESOURCE); } }
|
BeanUtils { public static void init() { init(DEFAULT_BEAN_RESOURCE); } private BeanUtils(); }
|
BeanUtils { public static void init() { init(DEFAULT_BEAN_RESOURCE); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); }
|
BeanUtils { public static void init() { init(DEFAULT_BEAN_RESOURCE); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); static final String DEFAULT_BEAN_CORE_RESOURCE; static final String DEFAULT_BEAN_NORMAL_RESOURCE; static final String[] DEFAULT_BEAN_RESOURCE; static final String SCB_SCAN_PACKAGE; }
|
@Test public void testGetImplClassFromBeanFromCglib(){ TestBean testBeanByCGLIB = new TestBean$$TestBeanByCGLIB$$e1a36bab(); Class<?> generatedClass = BeanUtils.getImplClassFromBean(testBeanByCGLIB); Assert.assertNotNull(generatedClass); Assert.assertEquals(TestBean.class, generatedClass); }
|
public static Class<?> getImplClassFromBean(Object bean) { return AopProxyUtils.ultimateTargetClass(bean); }
|
BeanUtils { public static Class<?> getImplClassFromBean(Object bean) { return AopProxyUtils.ultimateTargetClass(bean); } }
|
BeanUtils { public static Class<?> getImplClassFromBean(Object bean) { return AopProxyUtils.ultimateTargetClass(bean); } private BeanUtils(); }
|
BeanUtils { public static Class<?> getImplClassFromBean(Object bean) { return AopProxyUtils.ultimateTargetClass(bean); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); }
|
BeanUtils { public static Class<?> getImplClassFromBean(Object bean) { return AopProxyUtils.ultimateTargetClass(bean); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); static final String DEFAULT_BEAN_CORE_RESOURCE; static final String DEFAULT_BEAN_NORMAL_RESOURCE; static final String[] DEFAULT_BEAN_RESOURCE; static final String SCB_SCAN_PACKAGE; }
|
@Test public void autoCacheVersion() { VersionedCache cache = new VersionedCache().autoCacheVersion(); Assert.assertEquals(VERSION.get(), cache.cacheVersion()); }
|
public <T extends VersionedCache> T autoCacheVersion() { this.cacheVersion = VERSION.incrementAndGet(); return (T) this; }
|
VersionedCache { public <T extends VersionedCache> T autoCacheVersion() { this.cacheVersion = VERSION.incrementAndGet(); return (T) this; } }
|
VersionedCache { public <T extends VersionedCache> T autoCacheVersion() { this.cacheVersion = VERSION.incrementAndGet(); return (T) this; } }
|
VersionedCache { public <T extends VersionedCache> T autoCacheVersion() { this.cacheVersion = VERSION.incrementAndGet(); return (T) this; } int cacheVersion(); T autoCacheVersion(); T cacheVersion(int cacheVersion); String name(); T name(String name); T subName(VersionedCache parent, String subName); T data(); Map<K, V> mapData(); Collection<T> collectionData(); T[] arrayData(); T data(Object data); boolean isExpired(VersionedCache newCache); boolean isSameVersion(VersionedCache newCache); boolean isEmpty(); }
|
VersionedCache { public <T extends VersionedCache> T autoCacheVersion() { this.cacheVersion = VERSION.incrementAndGet(); return (T) this; } int cacheVersion(); T autoCacheVersion(); T cacheVersion(int cacheVersion); String name(); T name(String name); T subName(VersionedCache parent, String subName); T data(); Map<K, V> mapData(); Collection<T> collectionData(); T[] arrayData(); T data(Object data); boolean isExpired(VersionedCache newCache); boolean isSameVersion(VersionedCache newCache); boolean isEmpty(); }
|
@Test public void setName() { VersionedCache cache = new VersionedCache().name("n"); Assert.assertEquals("n", cache.name()); }
|
public String name() { return name; }
|
VersionedCache { public String name() { return name; } }
|
VersionedCache { public String name() { return name; } }
|
VersionedCache { public String name() { return name; } int cacheVersion(); T autoCacheVersion(); T cacheVersion(int cacheVersion); String name(); T name(String name); T subName(VersionedCache parent, String subName); T data(); Map<K, V> mapData(); Collection<T> collectionData(); T[] arrayData(); T data(Object data); boolean isExpired(VersionedCache newCache); boolean isSameVersion(VersionedCache newCache); boolean isEmpty(); }
|
VersionedCache { public String name() { return name; } int cacheVersion(); T autoCacheVersion(); T cacheVersion(int cacheVersion); String name(); T name(String name); T subName(VersionedCache parent, String subName); T data(); Map<K, V> mapData(); Collection<T> collectionData(); T[] arrayData(); T data(Object data); boolean isExpired(VersionedCache newCache); boolean isSameVersion(VersionedCache newCache); boolean isEmpty(); }
|
@Test public void isExpired() { VersionedCache cacheOld = new VersionedCache().autoCacheVersion(); VersionedCache cacheNew = new VersionedCache().autoCacheVersion(); Assert.assertTrue(cacheOld.isExpired(cacheNew)); Assert.assertFalse(cacheOld.isExpired(cacheOld)); Assert.assertFalse(cacheNew.isExpired(cacheOld)); }
|
public boolean isExpired(VersionedCache newCache) { return newCache.cacheVersion - cacheVersion > 0; }
|
VersionedCache { public boolean isExpired(VersionedCache newCache) { return newCache.cacheVersion - cacheVersion > 0; } }
|
VersionedCache { public boolean isExpired(VersionedCache newCache) { return newCache.cacheVersion - cacheVersion > 0; } }
|
VersionedCache { public boolean isExpired(VersionedCache newCache) { return newCache.cacheVersion - cacheVersion > 0; } int cacheVersion(); T autoCacheVersion(); T cacheVersion(int cacheVersion); String name(); T name(String name); T subName(VersionedCache parent, String subName); T data(); Map<K, V> mapData(); Collection<T> collectionData(); T[] arrayData(); T data(Object data); boolean isExpired(VersionedCache newCache); boolean isSameVersion(VersionedCache newCache); boolean isEmpty(); }
|
VersionedCache { public boolean isExpired(VersionedCache newCache) { return newCache.cacheVersion - cacheVersion > 0; } int cacheVersion(); T autoCacheVersion(); T cacheVersion(int cacheVersion); String name(); T name(String name); T subName(VersionedCache parent, String subName); T data(); Map<K, V> mapData(); Collection<T> collectionData(); T[] arrayData(); T data(Object data); boolean isExpired(VersionedCache newCache); boolean isSameVersion(VersionedCache newCache); boolean isEmpty(); }
|
@Test public void isSameVersion() { VersionedCache cacheOld = new VersionedCache().autoCacheVersion(); VersionedCache cacheNew = new VersionedCache().autoCacheVersion(); VersionedCache cacheSame = new VersionedCache().cacheVersion(cacheNew.cacheVersion()); Assert.assertFalse(cacheOld.isSameVersion(cacheNew)); Assert.assertTrue(cacheSame.isSameVersion(cacheNew)); }
|
public boolean isSameVersion(VersionedCache newCache) { return newCache.cacheVersion == cacheVersion; }
|
VersionedCache { public boolean isSameVersion(VersionedCache newCache) { return newCache.cacheVersion == cacheVersion; } }
|
VersionedCache { public boolean isSameVersion(VersionedCache newCache) { return newCache.cacheVersion == cacheVersion; } }
|
VersionedCache { public boolean isSameVersion(VersionedCache newCache) { return newCache.cacheVersion == cacheVersion; } int cacheVersion(); T autoCacheVersion(); T cacheVersion(int cacheVersion); String name(); T name(String name); T subName(VersionedCache parent, String subName); T data(); Map<K, V> mapData(); Collection<T> collectionData(); T[] arrayData(); T data(Object data); boolean isExpired(VersionedCache newCache); boolean isSameVersion(VersionedCache newCache); boolean isEmpty(); }
|
VersionedCache { public boolean isSameVersion(VersionedCache newCache) { return newCache.cacheVersion == cacheVersion; } int cacheVersion(); T autoCacheVersion(); T cacheVersion(int cacheVersion); String name(); T name(String name); T subName(VersionedCache parent, String subName); T data(); Map<K, V> mapData(); Collection<T> collectionData(); T[] arrayData(); T data(Object data); boolean isExpired(VersionedCache newCache); boolean isSameVersion(VersionedCache newCache); boolean isEmpty(); }
|
@Test public void testInit() { boolean status = false; try { paasNamespaceHandler.init(); } catch (Exception e) { status = true; } Assert.assertFalse(status); }
|
public void init() { Properties properties = null; try { properties = PaaSResourceUtils.loadMergedProperties(NAMESPACE_RES); } catch (Exception e) { LOGGER.error("Failed to load namespace handler define, {}, {}", NAMESPACE_RES, FortifyUtils.getErrorInfo(e)); return; } for (Entry<Object, Object> entry : properties.entrySet()) { String className = entry.getValue().toString(); try { Class<?> clazz = Class.forName(className); Object instance = clazz.newInstance(); registerBeanDefinitionParser(entry.getKey().toString(), (BeanDefinitionParser) instance); } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) { LOGGER.info("Failed to create BeanDefinitionParser instance of {}", className); } } }
|
PaasNamespaceHandler extends NamespaceHandlerSupport { public void init() { Properties properties = null; try { properties = PaaSResourceUtils.loadMergedProperties(NAMESPACE_RES); } catch (Exception e) { LOGGER.error("Failed to load namespace handler define, {}, {}", NAMESPACE_RES, FortifyUtils.getErrorInfo(e)); return; } for (Entry<Object, Object> entry : properties.entrySet()) { String className = entry.getValue().toString(); try { Class<?> clazz = Class.forName(className); Object instance = clazz.newInstance(); registerBeanDefinitionParser(entry.getKey().toString(), (BeanDefinitionParser) instance); } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) { LOGGER.info("Failed to create BeanDefinitionParser instance of {}", className); } } } }
|
PaasNamespaceHandler extends NamespaceHandlerSupport { public void init() { Properties properties = null; try { properties = PaaSResourceUtils.loadMergedProperties(NAMESPACE_RES); } catch (Exception e) { LOGGER.error("Failed to load namespace handler define, {}, {}", NAMESPACE_RES, FortifyUtils.getErrorInfo(e)); return; } for (Entry<Object, Object> entry : properties.entrySet()) { String className = entry.getValue().toString(); try { Class<?> clazz = Class.forName(className); Object instance = clazz.newInstance(); registerBeanDefinitionParser(entry.getKey().toString(), (BeanDefinitionParser) instance); } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) { LOGGER.info("Failed to create BeanDefinitionParser instance of {}", className); } } } }
|
PaasNamespaceHandler extends NamespaceHandlerSupport { public void init() { Properties properties = null; try { properties = PaaSResourceUtils.loadMergedProperties(NAMESPACE_RES); } catch (Exception e) { LOGGER.error("Failed to load namespace handler define, {}, {}", NAMESPACE_RES, FortifyUtils.getErrorInfo(e)); return; } for (Entry<Object, Object> entry : properties.entrySet()) { String className = entry.getValue().toString(); try { Class<?> clazz = Class.forName(className); Object instance = clazz.newInstance(); registerBeanDefinitionParser(entry.getKey().toString(), (BeanDefinitionParser) instance); } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) { LOGGER.info("Failed to create BeanDefinitionParser instance of {}", className); } } } void init(); }
|
PaasNamespaceHandler extends NamespaceHandlerSupport { public void init() { Properties properties = null; try { properties = PaaSResourceUtils.loadMergedProperties(NAMESPACE_RES); } catch (Exception e) { LOGGER.error("Failed to load namespace handler define, {}, {}", NAMESPACE_RES, FortifyUtils.getErrorInfo(e)); return; } for (Entry<Object, Object> entry : properties.entrySet()) { String className = entry.getValue().toString(); try { Class<?> clazz = Class.forName(className); Object instance = clazz.newInstance(); registerBeanDefinitionParser(entry.getKey().toString(), (BeanDefinitionParser) instance); } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) { LOGGER.info("Failed to create BeanDefinitionParser instance of {}", className); } } } void init(); }
|
@Test void should_support_json_encode_decode() { Map<String, Object> map = new HashMap<>(); map.put("k", "v"); DynamicObject dynamicObject = DatabindCodec.mapper().convertValue(map, DynamicObject.class); assertThat(dynamicObject.getDynamic()).isNotSameAs(map); assertThat(dynamicObject.getDynamic()).isEqualTo(map); assertThat(Json.encode(dynamicObject)).isEqualTo("{\"k\":\"v\"}"); }
|
@JsonAnyGetter public Map<String, Object> getDynamic() { return dynamic; }
|
DynamicObject { @JsonAnyGetter public Map<String, Object> getDynamic() { return dynamic; } }
|
DynamicObject { @JsonAnyGetter public Map<String, Object> getDynamic() { return dynamic; } }
|
DynamicObject { @JsonAnyGetter public Map<String, Object> getDynamic() { return dynamic; } @JsonAnyGetter Map<String, Object> getDynamic(); @SuppressWarnings("unchecked") T getDynamic(String key); void setDynamic(Map<String, Object> dynamic); @JsonAnySetter DynamicObject putDynamic(String key, Object value); }
|
DynamicObject { @JsonAnyGetter public Map<String, Object> getDynamic() { return dynamic; } @JsonAnyGetter Map<String, Object> getDynamic(); @SuppressWarnings("unchecked") T getDynamic(String key); void setDynamic(Map<String, Object> dynamic); @JsonAnySetter DynamicObject putDynamic(String key, Object value); }
|
@Test public void testRegisterSchemaNoResponse() { new MockUp<RestClientUtil>() { @Mock void put(IpPort ipPort, String uri, RequestParam requestParam, Handler<RestResponse> responseHandler) { } }; new RegisterSchemaTester() { void doRun(java.util.List<LoggingEvent> events) { oClient.registerSchema("msid", "schemaId", "content"); Assert.assertEquals("Register schema msid/schemaId failed.", events.get(0).getMessage()); } }.run(); }
|
@Override public boolean registerSchema(String microserviceId, String schemaId, String schemaContent) { Holder<ResponseWrapper> holder = new Holder<>(); IpPort ipPort = ipPortManager.getAvailableAddress(); try { CreateSchemaRequest request = new CreateSchemaRequest(); request.setSchema(schemaContent); request.setSummary(RegistryUtils.calcSchemaSummary(schemaContent)); byte[] body = JsonUtils.writeValueAsBytes(request); CountDownLatch countDownLatch = new CountDownLatch(1); restClientUtil.put(ipPort, String.format(Const.REGISTRY_API.MICROSERVICE_SCHEMA, microserviceId, schemaId), new RequestParam().setBody(body), syncHandlerEx(countDownLatch, holder)); countDownLatch.await(); if (holder.value == null) { LOGGER.error("Register schema {}/{} failed.", microserviceId, schemaId); return false; } if (!Status.Family.SUCCESSFUL.equals(Status.Family.familyOf(holder.value.response.statusCode()))) { LOGGER.error("Register schema {}/{} failed, statusCode: {}, statusMessage: {}, description: {}.", microserviceId, schemaId, holder.value.response.statusCode(), holder.value.response.statusMessage(), holder.value.bodyBuffer.toString()); return false; } LOGGER.info("register schema {}/{} success.", microserviceId, schemaId); return true; } catch (Exception e) { LOGGER.error("register schema {}/{} fail.", microserviceId, schemaId, e); } return false; }
|
ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public boolean registerSchema(String microserviceId, String schemaId, String schemaContent) { Holder<ResponseWrapper> holder = new Holder<>(); IpPort ipPort = ipPortManager.getAvailableAddress(); try { CreateSchemaRequest request = new CreateSchemaRequest(); request.setSchema(schemaContent); request.setSummary(RegistryUtils.calcSchemaSummary(schemaContent)); byte[] body = JsonUtils.writeValueAsBytes(request); CountDownLatch countDownLatch = new CountDownLatch(1); restClientUtil.put(ipPort, String.format(Const.REGISTRY_API.MICROSERVICE_SCHEMA, microserviceId, schemaId), new RequestParam().setBody(body), syncHandlerEx(countDownLatch, holder)); countDownLatch.await(); if (holder.value == null) { LOGGER.error("Register schema {}/{} failed.", microserviceId, schemaId); return false; } if (!Status.Family.SUCCESSFUL.equals(Status.Family.familyOf(holder.value.response.statusCode()))) { LOGGER.error("Register schema {}/{} failed, statusCode: {}, statusMessage: {}, description: {}.", microserviceId, schemaId, holder.value.response.statusCode(), holder.value.response.statusMessage(), holder.value.bodyBuffer.toString()); return false; } LOGGER.info("register schema {}/{} success.", microserviceId, schemaId); return true; } catch (Exception e) { LOGGER.error("register schema {}/{} fail.", microserviceId, schemaId, e); } return false; } }
|
ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public boolean registerSchema(String microserviceId, String schemaId, String schemaContent) { Holder<ResponseWrapper> holder = new Holder<>(); IpPort ipPort = ipPortManager.getAvailableAddress(); try { CreateSchemaRequest request = new CreateSchemaRequest(); request.setSchema(schemaContent); request.setSummary(RegistryUtils.calcSchemaSummary(schemaContent)); byte[] body = JsonUtils.writeValueAsBytes(request); CountDownLatch countDownLatch = new CountDownLatch(1); restClientUtil.put(ipPort, String.format(Const.REGISTRY_API.MICROSERVICE_SCHEMA, microserviceId, schemaId), new RequestParam().setBody(body), syncHandlerEx(countDownLatch, holder)); countDownLatch.await(); if (holder.value == null) { LOGGER.error("Register schema {}/{} failed.", microserviceId, schemaId); return false; } if (!Status.Family.SUCCESSFUL.equals(Status.Family.familyOf(holder.value.response.statusCode()))) { LOGGER.error("Register schema {}/{} failed, statusCode: {}, statusMessage: {}, description: {}.", microserviceId, schemaId, holder.value.response.statusCode(), holder.value.response.statusMessage(), holder.value.bodyBuffer.toString()); return false; } LOGGER.info("register schema {}/{} success.", microserviceId, schemaId); return true; } catch (Exception e) { LOGGER.error("register schema {}/{} fail.", microserviceId, schemaId, e); } return false; } ServiceRegistryClientImpl(ServiceRegistryConfig serviceRegistryConfig); }
|
ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public boolean registerSchema(String microserviceId, String schemaId, String schemaContent) { Holder<ResponseWrapper> holder = new Holder<>(); IpPort ipPort = ipPortManager.getAvailableAddress(); try { CreateSchemaRequest request = new CreateSchemaRequest(); request.setSchema(schemaContent); request.setSummary(RegistryUtils.calcSchemaSummary(schemaContent)); byte[] body = JsonUtils.writeValueAsBytes(request); CountDownLatch countDownLatch = new CountDownLatch(1); restClientUtil.put(ipPort, String.format(Const.REGISTRY_API.MICROSERVICE_SCHEMA, microserviceId, schemaId), new RequestParam().setBody(body), syncHandlerEx(countDownLatch, holder)); countDownLatch.await(); if (holder.value == null) { LOGGER.error("Register schema {}/{} failed.", microserviceId, schemaId); return false; } if (!Status.Family.SUCCESSFUL.equals(Status.Family.familyOf(holder.value.response.statusCode()))) { LOGGER.error("Register schema {}/{} failed, statusCode: {}, statusMessage: {}, description: {}.", microserviceId, schemaId, holder.value.response.statusCode(), holder.value.response.statusMessage(), holder.value.bodyBuffer.toString()); return false; } LOGGER.info("register schema {}/{} success.", microserviceId, schemaId); return true; } catch (Exception e) { LOGGER.error("register schema {}/{} fail.", microserviceId, schemaId, e); } return false; } ServiceRegistryClientImpl(ServiceRegistryConfig serviceRegistryConfig); @Override void init(); @Override List<Microservice> getAllMicroservices(); @Override String getMicroserviceId(String appId, String microserviceName, String versionRule, String environment); @Override boolean isSchemaExist(String microserviceId, String schemaId); @Override boolean registerSchema(String microserviceId, String schemaId, String schemaContent); @Override String getSchema(String microserviceId, String schemaId); @Override String getAggregatedSchema(String microserviceId, String schemaId); @Override Holder<List<GetSchemaResponse>> getSchemas(String microserviceId); @Override String registerMicroservice(Microservice microservice); @Override Microservice getMicroservice(String microserviceId); @Override Microservice getAggregatedMicroservice(String microserviceId); @Override String registerMicroserviceInstance(MicroserviceInstance instance); @Override List<MicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); @Override boolean unregisterMicroserviceInstance(String microserviceId, String microserviceInstanceId); @Override HeartbeatResponse heartbeat(String microserviceId, String microserviceInstanceId); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose); @Override List<MicroserviceInstance> findServiceInstance(String consumerId, String appId, String serviceName,
String versionRule); @Override MicroserviceInstances findServiceInstances(String consumerId, String appId, String serviceName,
String versionRule, String revision); @Override boolean updateMicroserviceProperties(String microserviceId, Map<String, String> serviceProperties); @Override boolean updateInstanceProperties(String microserviceId, String microserviceInstanceId,
Map<String, String> instanceProperties); @Override MicroserviceInstance findServiceInstance(String serviceId, String instanceId); @Override ServiceCenterInfo getServiceCenterInfo(); @Override boolean updateMicroserviceInstanceStatus(String microserviceId, String instanceId,
MicroserviceInstanceStatus status); @Subscribe void onMicroserviceHeartbeatTask(MicroserviceInstanceHeartbeatTask event); }
|
ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public boolean registerSchema(String microserviceId, String schemaId, String schemaContent) { Holder<ResponseWrapper> holder = new Holder<>(); IpPort ipPort = ipPortManager.getAvailableAddress(); try { CreateSchemaRequest request = new CreateSchemaRequest(); request.setSchema(schemaContent); request.setSummary(RegistryUtils.calcSchemaSummary(schemaContent)); byte[] body = JsonUtils.writeValueAsBytes(request); CountDownLatch countDownLatch = new CountDownLatch(1); restClientUtil.put(ipPort, String.format(Const.REGISTRY_API.MICROSERVICE_SCHEMA, microserviceId, schemaId), new RequestParam().setBody(body), syncHandlerEx(countDownLatch, holder)); countDownLatch.await(); if (holder.value == null) { LOGGER.error("Register schema {}/{} failed.", microserviceId, schemaId); return false; } if (!Status.Family.SUCCESSFUL.equals(Status.Family.familyOf(holder.value.response.statusCode()))) { LOGGER.error("Register schema {}/{} failed, statusCode: {}, statusMessage: {}, description: {}.", microserviceId, schemaId, holder.value.response.statusCode(), holder.value.response.statusMessage(), holder.value.bodyBuffer.toString()); return false; } LOGGER.info("register schema {}/{} success.", microserviceId, schemaId); return true; } catch (Exception e) { LOGGER.error("register schema {}/{} fail.", microserviceId, schemaId, e); } return false; } ServiceRegistryClientImpl(ServiceRegistryConfig serviceRegistryConfig); @Override void init(); @Override List<Microservice> getAllMicroservices(); @Override String getMicroserviceId(String appId, String microserviceName, String versionRule, String environment); @Override boolean isSchemaExist(String microserviceId, String schemaId); @Override boolean registerSchema(String microserviceId, String schemaId, String schemaContent); @Override String getSchema(String microserviceId, String schemaId); @Override String getAggregatedSchema(String microserviceId, String schemaId); @Override Holder<List<GetSchemaResponse>> getSchemas(String microserviceId); @Override String registerMicroservice(Microservice microservice); @Override Microservice getMicroservice(String microserviceId); @Override Microservice getAggregatedMicroservice(String microserviceId); @Override String registerMicroserviceInstance(MicroserviceInstance instance); @Override List<MicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); @Override boolean unregisterMicroserviceInstance(String microserviceId, String microserviceInstanceId); @Override HeartbeatResponse heartbeat(String microserviceId, String microserviceInstanceId); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose); @Override List<MicroserviceInstance> findServiceInstance(String consumerId, String appId, String serviceName,
String versionRule); @Override MicroserviceInstances findServiceInstances(String consumerId, String appId, String serviceName,
String versionRule, String revision); @Override boolean updateMicroserviceProperties(String microserviceId, Map<String, String> serviceProperties); @Override boolean updateInstanceProperties(String microserviceId, String microserviceInstanceId,
Map<String, String> instanceProperties); @Override MicroserviceInstance findServiceInstance(String serviceId, String instanceId); @Override ServiceCenterInfo getServiceCenterInfo(); @Override boolean updateMicroserviceInstanceStatus(String microserviceId, String instanceId,
MicroserviceInstanceStatus status); @Subscribe void onMicroserviceHeartbeatTask(MicroserviceInstanceHeartbeatTask event); }
|
@Test public void testCreateSSLEngine() { SSLOption option = SSLOption.build(DIR + "/server.ssl.properties"); SSLCustom custom = new SSLCustom() { @Override public String getFullPath(String filename) { return DIR + "/ssl/" + filename; } @Override public char[] decode(char[] encrypted) { return encrypted; } }; SSLEngine aSSLEngine = SSLManager.createSSLEngine(option, custom); Assert.assertEquals(false, aSSLEngine.getUseClientMode()); Assert.assertNotNull(aSSLEngine); }
|
public static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom) { SSLContext context = createSSLContext(option, custom); SSLEngine engine = context.createSSLEngine(); engine.setEnabledProtocols(option.getProtocols().split(",")); String[] supported = engine.getSupportedCipherSuites(); String[] eanbled = option.getCiphers().split(","); engine.setEnabledCipherSuites(getEnabledCiphers(supported, eanbled)); engine.setNeedClientAuth(option.isAuthPeer()); return engine; }
|
SSLManager { public static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom) { SSLContext context = createSSLContext(option, custom); SSLEngine engine = context.createSSLEngine(); engine.setEnabledProtocols(option.getProtocols().split(",")); String[] supported = engine.getSupportedCipherSuites(); String[] eanbled = option.getCiphers().split(","); engine.setEnabledCipherSuites(getEnabledCiphers(supported, eanbled)); engine.setNeedClientAuth(option.isAuthPeer()); return engine; } }
|
SSLManager { public static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom) { SSLContext context = createSSLContext(option, custom); SSLEngine engine = context.createSSLEngine(); engine.setEnabledProtocols(option.getProtocols().split(",")); String[] supported = engine.getSupportedCipherSuites(); String[] eanbled = option.getCiphers().split(","); engine.setEnabledCipherSuites(getEnabledCiphers(supported, eanbled)); engine.setNeedClientAuth(option.isAuthPeer()); return engine; } private SSLManager(); }
|
SSLManager { public static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom) { SSLContext context = createSSLContext(option, custom); SSLEngine engine = context.createSSLEngine(); engine.setEnabledProtocols(option.getProtocols().split(",")); String[] supported = engine.getSupportedCipherSuites(); String[] eanbled = option.getCiphers().split(","); engine.setEnabledCipherSuites(getEnabledCiphers(supported, eanbled)); engine.setNeedClientAuth(option.isAuthPeer()); return engine; } private SSLManager(); static SSLContext createSSLContext(SSLOption option, SSLCustom custom); static SSLSocketFactory createSSLSocketFactory(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom, String peerHost, int peerPort); static SSLServerSocket createSSLServerSocket(SSLOption option,
SSLCustom custom); static SSLSocket createSSLSocket(SSLOption option, SSLCustom custom); static String[] getEnalbedCiphers(String enabledCiphers); }
|
SSLManager { public static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom) { SSLContext context = createSSLContext(option, custom); SSLEngine engine = context.createSSLEngine(); engine.setEnabledProtocols(option.getProtocols().split(",")); String[] supported = engine.getSupportedCipherSuites(); String[] eanbled = option.getCiphers().split(","); engine.setEnabledCipherSuites(getEnabledCiphers(supported, eanbled)); engine.setNeedClientAuth(option.isAuthPeer()); return engine; } private SSLManager(); static SSLContext createSSLContext(SSLOption option, SSLCustom custom); static SSLSocketFactory createSSLSocketFactory(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom, String peerHost, int peerPort); static SSLServerSocket createSSLServerSocket(SSLOption option,
SSLCustom custom); static SSLSocket createSSLSocket(SSLOption option, SSLCustom custom); static String[] getEnalbedCiphers(String enabledCiphers); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.