Datasets:
Minata
/
1024src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files
xet
Community
1
method2testcases
stringlengths
118
6.63k
### Question: 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); }### Answer: @Test public void parseFileNameFromHeaderValue() { String fileName = "测 试.txt"; String encoded = HttpUtils.uriEncodePath(fileName); Assert.assertEquals(fileName, HttpUtils.parseFileNameFromHeaderValue("xx;filename=" + encoded)); } @Test public void parseFileNameFromHeaderValue_defaultName() { Assert.assertEquals("default", HttpUtils.parseFileNameFromHeaderValue("xx")); } @Test public void parseFileNameFromHeaderValue_ignorePath() { Assert.assertEquals("a.txt", HttpUtils.parseFileNameFromHeaderValue("xx;filename=../../a.txt")); }
### Question: 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); }### Answer: @Test public void getCharsetFromContentType_noContentType() { String character = HttpUtils.getCharsetFromContentType(null); Assert.assertNull(character); } @Test public void getCharsetFromContentType_noCharset() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON); Assert.assertNull(character); } @Test public void getCharsetFromContentType_noSemicolonEnd() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset=utf-8"); Assert.assertEquals("utf-8", character); } @Test public void getCharsetFromContentType_semicolonEnd() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset=utf-8;"); Assert.assertEquals("utf-8", character); } @Test public void getCharsetFromContentType_needTrim() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset= utf-8 ;"); Assert.assertEquals("utf-8", character); } @Test public void getCharsetFromContentType_quotationMarks() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset=\"utf-8\";"); Assert.assertEquals("utf-8", character); } @Test public void getCharsetFromContentType_quotationMarks_needTrim() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset=\" utf-8 \";"); Assert.assertEquals("utf-8", character); }
### Question: RegisterInstanceResponse { public String getInstanceId() { return instanceId; } String getInstanceId(); void setInstanceId(String instanceId); }### Answer: @Test public void testDefaultValues() { Assert.assertNull(oRegisterInstanceResponse.getInstanceId()); } @Test public void testInitializedValues() { initFields(); Assert.assertEquals("testInstanceID", oRegisterInstanceResponse.getInstanceId()); }
### Question: HttpStatusUtils { public static StatusType getOrCreateByStatusCode(int code) { return MGR.getOrCreateByStatusCode(code); } private HttpStatusUtils(); static StatusType getOrCreateByStatusCode(int code); }### Answer: @Test public void testStandard() { st = HttpStatusUtils.getOrCreateByStatusCode(200); Assert.assertEquals(200, st.getStatusCode()); } @Test public void testNotStandard() { st = mgr.getOrCreateByStatusCode(250); Assert.assertEquals(250, st.getStatusCode()); }
### Question: 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(); }### Answer: @Test public void getInputStream() throws IOException { try (InputStream is = part.getInputStream()) { Assert.assertEquals(content, IOUtils.toString(is, StandardCharsets.UTF_8)); } }
### Question: 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(); }### Answer: @Test public void getSize() { Assert.assertEquals(content.length(), part.getSize()); }
### Question: 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(); }### Answer: @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()); }
### Question: 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(); }### Answer: @Test public void getAbsolutePath() { Assert.assertEquals(file.getAbsolutePath(), part.getAbsolutePath()); }
### Question: 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(); }### Answer: @Test public void getInputStream() throws IOException { initExpectedException(); part.getInputStream(); }
### Question: 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(); }### Answer: @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()); }
### Question: 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(); }### Answer: @Test public void getName() throws IOException { Assert.assertNull(part.getName()); String name = "abc"; part.name = name; Assert.assertEquals(name, part.getName()); }
### Question: 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(); }### Answer: @Test public void getSubmittedFileName() throws IOException { Assert.assertNull(part.getSubmittedFileName()); String submittedFileName = "abc"; part.setSubmittedFileName(submittedFileName); Assert.assertEquals(submittedFileName, part.getSubmittedFileName()); }
### Question: 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(); }### Answer: @Test public void getSize() { initExpectedException(); part.getSize(); }
### Question: 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(); }### Answer: @Test public void write() throws IOException { initExpectedException(); part.write("file"); }
### Question: 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(); }### Answer: @Test public void delete() throws IOException { initExpectedException(); part.delete(); }
### Question: 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(); }### Answer: @Test public void getHeader() { initExpectedException(); part.getHeader("header"); }
### Question: 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(); }### Answer: @Test public void getHeaders() { initExpectedException(); part.getHeaders("header"); }
### Question: 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(); }### Answer: @Test public void getHeaderNames() { initExpectedException(); part.getHeaderNames(); }
### Question: ResourcePart extends AbstractPart { @Override public InputStream getInputStream() throws IOException { return resource.getInputStream(); } ResourcePart(String name, Resource resource); @Override InputStream getInputStream(); }### Answer: @Test public void getInputStream() throws IOException { try (InputStream is = part.getInputStream()) { byte[] content = IOUtils.toByteArray(is); Assert.assertArrayEquals(bytes, content); } }
### Question: 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); }### Answer: @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")); }
### Question: GetServiceResponse { public Microservice getService() { return service; } Microservice getService(); void setService(Microservice service); }### Answer: @Test public void testDefaultValues() { Assert.assertNull(oGetServiceResponse.getService()); } @Test public void testInitializedValues() { initFields(); Assert.assertEquals(oMockMicroservice, oGetServiceResponse.getService()); }
### Question: 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); }### Answer: @Test public void testGetRealListenAddress() { Assert.assertNull(NetUtils.getRealListenAddress("http", null)); Assert.assertEquals("http: checkException(v -> NetUtils.getRealListenAddress("http:1", "1.1.1.1:8080")); }
### Question: 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); }### Answer: @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())); } } @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)); }
### Question: 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); }### Answer: @Test public void testGetHostName() { Assert.assertNotEquals(null, NetUtils.getHostName()); Deencapsulation.setField(NetUtils.class, "hostName", null); Assert.assertNotEquals(null, NetUtils.getHostName()); }
### Question: 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); }### Answer: @Test public void testGetHostAddress() { Assert.assertNotEquals(null, NetUtils.getHostAddress()); Deencapsulation.setField(NetUtils.class, "hostAddress", null); Assert.assertNotEquals(null, NetUtils.getHostAddress()); }
### Question: 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(); }### Answer: @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()); }
### Question: 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(); }### Answer: @Test public void testFortifyUtils() throws IOException { Assert.assertEquals("", FortifyUtils.getErrorMsg(null)); Assert.assertEquals("", FortifyUtils.getErrorStack(null)); }
### Question: 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(); }### Answer: @Test public void testGetErrorMsg() { Throwable e = new Throwable(); FortifyUtils.getErrorMsg(e); assertNull(FortifyUtils.getErrorMsg(e)); }
### Question: 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(); }### Answer: @Test public void testGetSecurityXmlDocumentFactory() { try { FortifyUtils.getSecurityXmlDocumentFactory(); assertNotNull(FortifyUtils.getSecurityXmlDocumentFactory()); } catch (Exception e) { Assert.assertTrue(false); } }
### Question: 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(); }### Answer: @Test public void testGetErrorStack() { Throwable e = new Throwable(); FortifyUtils.getErrorStack(e); Assert.assertNotEquals(true, FortifyUtils.getErrorStack(e)); }
### Question: 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(); }### Answer: @Test public void testGetErrorInfo() { Throwable e = new Throwable(); FortifyUtils.getErrorInfo(e, true); Assert.assertNotEquals(true, FortifyUtils.getErrorInfo(e, true)); }
### Question: 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); }### Answer: @Test public void testSortedAcceptableMimeTypes1() { String accept = "text/html"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(1, types.size()); assertEquals("text/html", types.get(0)); } @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)); } @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)); } @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)); } @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)); } @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)); } @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)); } @Test public void getSortedAcceptableMimeTypesNull() { List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(null); Assert.assertSame(Collections.emptyList(), types); }
### Question: GetInstancesResponse { public List<MicroserviceInstance> getInstances() { return instances; } List<MicroserviceInstance> getInstances(); void setInstances(List<MicroserviceInstance> instances); }### Answer: @Test public void testDefaultValues() { Assert.assertNull(oGetInstancesResponse.getInstances()); } @Test public void testInitializedValues() { initFields(); Assert.assertEquals(1, oGetInstancesResponse.getInstances().size()); }
### Question: 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; }### Answer: @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); }
### Question: 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); }### Answer: @Test public void testGetTargetServiceNull() { SPIServiceDef0 service = SPIServiceUtils.getTargetService(SPIServiceDef0.class); Assert.assertNull(service); } @Test public void testGetTargetServiceNotNull() { SPIServiceDef service = SPIServiceUtils.getTargetService(SPIServiceDef.class); Assert.assertTrue(SPIServiceDef.class.isInstance(service)); Assert.assertSame(service, SPIServiceUtils.getTargetService(SPIServiceDef.class)); } @Test public void testGetTargetService_special_null() { Assert.assertNull(SPIServiceUtils.getTargetService(SPIServiceDef0.class, SPIServiceDef0Impl.class)); } @Test public void testGetTargetService_special_notNull() { SPIServiceDef service = SPIServiceUtils.getTargetService(SPIServiceDef.class, SPIServiceDefImpl.class); Assert.assertTrue(SPIServiceDefImpl.class.isInstance(service)); }
### Question: 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); }### Answer: @Test public void getPriorityHighestService_null() { Assert.assertNull(SPIServiceUtils.getPriorityHighestService(SPIServiceDef0.class)); }
### Question: 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); }### Answer: @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(); }
### Question: 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); }### Answer: @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)); }
### Question: 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); }### Answer: @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())); }
### Question: ExceptionUtils { private ExceptionUtils() { } private ExceptionUtils(); static String getExceptionMessageWithoutTrace(Throwable e); }### Answer: @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)); }
### Question: 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); }### Answer: @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")); } @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")); }
### Question: 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); }### Answer: @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")); }
### Question: 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; }### Answer: @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); } @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); }
### Question: 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); }### Answer: @Test void should_convert_success_async_to_sync() { CompletableFuture<String> future = CompletableFuture.completedFuture("value"); assertThat(AsyncUtils.toSync(future)).isEqualTo("value"); }
### Question: 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(); }### Answer: @Test public void findMainClass_notExist() { Assert.assertNull(JvmUtils.findMainClass()); } @Test public void findMainClass_existButEmpty() { System.setProperty(JvmUtils.SUN_JAVA_COMMAND, ""); Assert.assertNull(JvmUtils.findMainClass()); } @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(); } @Test public void findMainClass_class_normal() { System.setProperty(JvmUtils.SUN_JAVA_COMMAND, TestJvmUtils.class.getName() + " arg"); Assert.assertEquals(TestJvmUtils.class, JvmUtils.findMainClass()); } @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()); } @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()); } @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()); }
### Question: 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(); }### Answer: @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()); } @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()); } @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()); } @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()); } @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()); }
### Question: 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; }### Answer: @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())); } @Test public void testGetImplClassFromBeanFromCglib(){ TestBean testBeanByCGLIB = new TestBean$$TestBeanByCGLIB$$e1a36bab(); Class<?> generatedClass = BeanUtils.getImplClassFromBean(testBeanByCGLIB); Assert.assertNotNull(generatedClass); Assert.assertEquals(TestBean.class, generatedClass); }
### Question: 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; }### Answer: @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)); } @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)); } @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)); } @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)); }
### Question: 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; }### Answer: @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)); }
### Question: 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(); }### Answer: @Test public void autoCacheVersion() { VersionedCache cache = new VersionedCache().autoCacheVersion(); Assert.assertEquals(VERSION.get(), cache.cacheVersion()); }
### Question: 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(); }### Answer: @Test public void setName() { VersionedCache cache = new VersionedCache().name("n"); Assert.assertEquals("n", cache.name()); }
### Question: 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(); }### Answer: @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)); }
### Question: 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(); }### Answer: @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)); }
### Question: 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(); }### Answer: @Test public void testInit() { boolean status = false; try { paasNamespaceHandler.init(); } catch (Exception e) { status = true; } Assert.assertFalse(status); }
### Question: 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); }### Answer: @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\"}"); }
### Question: 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); }### Answer: @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); } @Test public void testCreateSSLEnginewithPort() { 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; } }; int port = 39093; String peerHost = "host1"; SSLEngine aSSLEngine = SSLManager.createSSLEngine(option, custom, peerHost, port); Assert.assertNotNull(aSSLEngine); Assert.assertEquals("host1", aSSLEngine.getPeerHost().toString()); }
### Question: SSLManager { public static SSLContext createSSLContext(SSLOption option, SSLCustom custom) { try { String keyStoreName = custom.getFullPath(option.getKeyStore()); KeyManager[] keymanager; if (keyStoreName != null && new File(keyStoreName).exists()) { char[] keyStoreValue = custom.decode(option.getKeyStoreValue().toCharArray()); KeyStore keyStore = KeyStoreUtil.createKeyStore(keyStoreName, option.getKeyStoreType(), keyStoreValue); keymanager = KeyStoreUtil.createKeyManagers(keyStore, keyStoreValue); } else { keymanager = null; } String trustStoreName = custom.getFullPath(option.getTrustStore()); TrustManager[] trustManager; if (trustStoreName != null && new File(trustStoreName).exists()) { char[] trustStoreValue = custom.decode(option.getTrustStoreValue().toCharArray()); KeyStore trustStore = KeyStoreUtil.createKeyStore(trustStoreName, option.getTrustStoreType(), trustStoreValue); trustManager = KeyStoreUtil.createTrustManagers(trustStore); } else { trustManager = new TrustManager[] {new TrustAllManager()}; } TrustManager[] wrapped = new TrustManager[trustManager.length]; for (int i = 0; i < trustManager.length; i++) { wrapped[i] = new TrustManagerExt((X509ExtendedTrustManager) trustManager[i], option, custom); } SSLContext context = SSLContext.getInstance("TLS"); context.init(keymanager, wrapped, new SecureRandom()); return context; } catch (NoSuchAlgorithmException e) { throw new IllegalArgumentException("NoSuchAlgorithmException." + e.getMessage()); } catch (KeyManagementException e) { throw new IllegalArgumentException("KeyManagementException." + e.getMessage()); } } 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); }### Answer: @Test public void testCreateSSLContextException() { 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; } }; new MockUp<SSLContext>() { @Mock public final SSLContext getInstance(String type) throws NoSuchAlgorithmException { throw new NoSuchAlgorithmException(); } }; try { SSLContext context = SSLManager.createSSLContext(option, custom); Assert.assertNotNull(context); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } } @Test public void testCreateSSLContextKeyManagementException() { 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; } }; new MockUp<SSLContext>() { @Mock public final SSLContext getInstance(String type) throws KeyManagementException { throw new KeyManagementException(); } }; try { SSLContext context = SSLManager.createSSLContext(option, custom); Assert.assertNotNull(context); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } }
### Question: SSLManager { public static SSLServerSocket createSSLServerSocket(SSLOption option, SSLCustom custom) { try { SSLContext context = createSSLContext(option, custom); SSLServerSocketFactory factory = context.getServerSocketFactory(); SSLServerSocket socket = (SSLServerSocket) factory.createServerSocket(); socket.setEnabledProtocols(option.getProtocols().split(",")); String[] supported = socket.getSupportedCipherSuites(); String[] eanbled = option.getCiphers().split(","); socket.setEnabledCipherSuites(getEnabledCiphers(supported, eanbled)); socket.setNeedClientAuth(option.isAuthPeer()); return socket; } catch (UnknownHostException e) { throw new IllegalArgumentException("unkown host"); } catch (IOException e) { throw new IllegalArgumentException("unable create socket"); } } 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); }### Answer: @Test public void testCreateSSLServerSocketException() { 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; } }; new MockUp<SSLContext>() { @Mock public final SSLContext getInstance(String type) throws UnknownHostException { throw new UnknownHostException(); } }; try { SSLServerSocket context = SSLManager.createSSLServerSocket(option, custom); Assert.assertNotNull(context); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } } @Test public void testCreateSSLServerSocketIOException() { 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; } }; new MockUp<SSLContext>() { @Mock public final SSLContext getInstance(String type) throws IOException { throw new IOException(); } }; try { SSLServerSocket context = SSLManager.createSSLServerSocket(option, custom); Assert.assertNotNull(context); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } }
### Question: SSLManager { public static SSLSocket createSSLSocket(SSLOption option, SSLCustom custom) { try { SSLContext context = createSSLContext(option, custom); SSLSocketFactory facroty = context.getSocketFactory(); SSLSocket socket = (SSLSocket) facroty.createSocket(); socket.setEnabledProtocols(option.getProtocols().split(",")); String[] supported = socket.getSupportedCipherSuites(); String[] eanbled = option.getCiphers().split(","); socket.setEnabledCipherSuites(getEnabledCiphers(supported, eanbled)); return socket; } catch (UnknownHostException e) { throw new IllegalArgumentException("unkown host"); } catch (IOException e) { throw new IllegalArgumentException("unable create socket"); } } 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); }### Answer: @Test public void testCreateSSLSocketException() { 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; } }; new MockUp<SSLContext>() { @Mock public final SSLContext getInstance(String type) throws UnknownHostException { throw new UnknownHostException(); } }; try { SSLSocket context = SSLManager.createSSLSocket(option, custom); Assert.assertNotNull(context); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } } @Test public void testCreateSSLSocketIOException() { 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; } }; new MockUp<SSLContext>() { @Mock public final SSLContext getInstance(String type) throws IOException { throw new IOException(); } }; try { SSLSocket context = SSLManager.createSSLSocket(option, custom); Assert.assertNotNull(context); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } }
### Question: SSLManager { public static SSLSocketFactory createSSLSocketFactory(SSLOption option, SSLCustom custom) { SSLContext context = createSSLContext(option, custom); SSLSocketFactory factory = context.getSocketFactory(); String[] supported = factory.getSupportedCipherSuites(); String[] eanbled = option.getCiphers().split(","); return new SSLSocketFactoryExt(factory, getEnabledCiphers(supported, eanbled), option.getProtocols().split(",")); } 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); }### Answer: @Test public void testCreateSSLSocketFactory() { 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; } }; SSLSocketFactory aSSLSocketFactory = SSLManager.createSSLSocketFactory(option, custom); Assert.assertNotNull(aSSLSocketFactory.getDefaultCipherSuites()[0]); }
### Question: SSLOption { public static SSLOption build(String optionfile) { File file = new File(optionfile); if (!file.isFile()) { throw new IllegalArgumentException("Bad file name."); } try { SSLOption option = new SSLOption(); option.load(file.getCanonicalPath()); return option; } catch (IOException e) { throw new IllegalArgumentException("Bad file name."); } } String getEngine(); void setEngine(String engine); void setProtocols(String protocols); void setCiphers(String ciphers); void setAuthPeer(boolean authPeer); void setCheckCNHost(boolean checkCNHost); void setCheckCNWhite(boolean checkCNWhite); void setCheckCNWhiteFile(String checkCNWhiteFile); void setAllowRenegociate(boolean allowRenegociate); void setStorePath(String storePath); void setTrustStore(String trustStore); void setTrustStoreType(String trustStoreType); void setTrustStoreValue(String trustStoreValue); void setKeyStore(String keyStore); void setKeyStoreType(String keyStoreType); void setKeyStoreValue(String keyStoreValue); void setCrl(String crl); String getProtocols(); String getCiphers(); boolean isAuthPeer(); boolean isCheckCNHost(); boolean isCheckCNWhite(); String getCheckCNWhiteFile(); boolean isAllowRenegociate(); String getStorePath(); String getTrustStore(); String getTrustStoreType(); String getTrustStoreValue(); String getKeyStore(); String getKeyStoreType(); String getKeyStoreValue(); String getCrl(); static SSLOption build(String optionfile); static SSLOption build(InputStream inputStream); static String getStringProperty(ConcurrentCompositeConfiguration configSource, String defaultValue, String... keys); static SSLOption buildFromYaml(String tag, ConcurrentCompositeConfiguration configSource); static SSLOption buildFromYaml(String tag); String getSslCustomClass(); void setSslCustomClass(String sslCustomClass); static final String DEFAULT_CIPHERS; }### Answer: @SuppressWarnings("unused") @Test public void testSSLOptionNull() { try { SSLOption option = SSLOption.build(DIR + "/servers.ssl.properties"); } catch (IllegalArgumentException e) { Assert.assertEquals("Bad file name.", e.getMessage()); } } @Test public void testBuildException() { new MockUp<File>() { @Mock public String getCanonicalPath() throws IOException { throw new IOException(); } }; try { SSLOption option = SSLOption.build(DIR + "/server.ssl.properties"); Assert.assertNotNull(option); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } } @Test public void testBuildInputStream() { try { URL url = this.getClass().getResource("/server.ssl.properties"); InputStream inputStream = url.openStream(); SSLOption option = SSLOption.build(inputStream); Assert.assertNotNull(option); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } }
### Question: CertificateUtil { public static Set<String> getCN(X509Certificate cert) { Set<String> names = new HashSet<>(); String subjectDN = cert.getSubjectX500Principal().getName(); String[] pairs = subjectDN.split(","); for (String p : pairs) { String[] kv = p.split("="); if (kv.length == 2 && kv[0].equals("CN")) { names.add(kv[1]); } } try { Collection<List<?>> collection = cert.getSubjectAlternativeNames(); if (collection != null) { for (List<?> list : collection) { if (list.size() == 2) { Object key = list.get(0); Object value = list.get(1); if (key instanceof Integer && value instanceof String) { int intKey = ((Integer) key).intValue(); String strValue = (String) value; if (intKey == SUBALTNAME_DNSNAME || intKey == SUBALTNAME_IPADDRESS) { names.add(strValue); } } } } } } catch (CertificateParsingException e) { throw new IllegalArgumentException("can not read AlternativeNames."); } return names; } private CertificateUtil(); static X509Certificate findOwner(X509Certificate[] cerChain); static Set<String> getCN(X509Certificate cert); }### Answer: @Test public void testGetCN(@Mocked X500Principal aX500Principal, @Mocked MyX509Certificate myX509Certificate) { new Expectations() { { aX500Principal.getName(); result = "CN=Test1234"; myX509Certificate.getSubjectX500Principal(); result = aX500Principal; } }; MyX509Certificate xxmyX509Certificate = new MyX509Certificate(); Set<String> strExpect = CertificateUtil.getCN(xxmyX509Certificate); Assert.assertEquals(true, strExpect.contains("Test1234")); } @Test public void testGetCNException(@Mocked X500Principal aX500Principal, @Mocked MyX509Certificate myX509Certificate) { new Expectations() { { aX500Principal.getName(); result = "NOCN=Test1234"; myX509Certificate.getSubjectX500Principal(); result = aX500Principal; } }; MyX509Certificate xxmyX509Certificate = new MyX509Certificate(); try { Set<String> strExpect = CertificateUtil.getCN(xxmyX509Certificate); Assert.assertEquals(strExpect.size(), 0); } catch (IllegalArgumentException e) { Assert.assertNotNull(null); } }
### Question: CertificateUtil { public static X509Certificate findOwner(X509Certificate[] cerChain) { X509Certificate[] sorted = sort(cerChain); return sorted[sorted.length - 1]; } private CertificateUtil(); static X509Certificate findOwner(X509Certificate[] cerChain); static Set<String> getCN(X509Certificate cert); }### Answer: @Test public void testFindOwner(@Mocked X500Principal aX500Principal1, @Mocked X500Principal aX500Principal2, @Mocked MyX509Certificate myX509Certificate) { new Expectations() { { aX500Principal1.getName(); result = "Huawei"; } { aX500Principal2.getName(); result = "Huawei"; } { myX509Certificate.getSubjectX500Principal(); result = aX500Principal1; myX509Certificate.getIssuerX500Principal(); result = aX500Principal2; } }; MyX509Certificate myX509Certificate1 = new MyX509Certificate(); MyX509Certificate myX509Certificate2 = new MyX509Certificate(); MyX509Certificate[] xxmyX509Certificate = new MyX509Certificate[2]; xxmyX509Certificate[0] = myX509Certificate1; xxmyX509Certificate[1] = myX509Certificate2; X509Certificate aX509Certificate = CertificateUtil.findOwner(xxmyX509Certificate); Assert.assertNull(aX509Certificate); } @Test public void testFindRootCAException(@Mocked X500Principal aX500Principal1, @Mocked X500Principal aX500Principal2, @Mocked MyX509Certificate myX509Certificate) { new Expectations() { { aX500Principal1.getName(); result = "Huawei1"; } { aX500Principal2.getName(); result = "Huawei3"; } { myX509Certificate.getSubjectX500Principal(); result = aX500Principal1; myX509Certificate.getIssuerX500Principal(); result = aX500Principal2; } }; MyX509Certificate myX509Certificate1 = new MyX509Certificate(); MyX509Certificate myX509Certificate2 = new MyX509Certificate(); MyX509Certificate[] xxmyX509Certificate = new MyX509Certificate[2]; xxmyX509Certificate[0] = myX509Certificate1; xxmyX509Certificate[1] = myX509Certificate2; try { X509Certificate aX509Certificate = CertificateUtil.findOwner(xxmyX509Certificate); Assert.assertNull(aX509Certificate); } catch (IllegalArgumentException e) { Assert.assertEquals("bad certificate chain: no root CA.", e.getMessage()); } }
### Question: TrustManagerExt extends X509ExtendedTrustManager { @Override public X509Certificate[] getAcceptedIssuers() { return trustManager.getAcceptedIssuers(); } TrustManagerExt(X509ExtendedTrustManager manager, SSLOption option, SSLCustom custom); @Override void checkClientTrusted(X509Certificate[] chain, String authType); @Override void checkServerTrusted(X509Certificate[] chain, String authType); @Override X509Certificate[] getAcceptedIssuers(); @Override void checkClientTrusted(X509Certificate[] chain, String authType, Socket socket); @Override void checkClientTrusted(X509Certificate[] chain, String authType, SSLEngine engine); @Override void checkServerTrusted(X509Certificate[] chain, String authType, Socket socket); @Override void checkServerTrusted(X509Certificate[] chain, String authType, SSLEngine engine); }### Answer: @SuppressWarnings("unused") @Test public void testConstructor() { String keyStoreName = custom.getFullPath(option.getKeyStore()); char[] keyStoreValue = custom.decode(option.getKeyStoreValue().toCharArray()); String trustStoreName = custom.getFullPath(option.getTrustStore()); char[] trustStoreValue = custom.decode(option.getTrustStoreValue().toCharArray()); KeyStore trustStore = KeyStoreUtil.createKeyStore(trustStoreName, option.getTrustStoreType(), trustStoreValue); TrustManager[] trustManager = KeyStoreUtil.createTrustManagers(trustStore); TrustManagerExt trustManagerExt = new TrustManagerExt((X509ExtendedTrustManager) trustManager[0], option, custom); Assert.assertEquals(3, trustManagerExt.getAcceptedIssuers()[0].getVersion()); Assert.assertNotNull(trustManagerExt); }
### Question: TrustManagerExt extends X509ExtendedTrustManager { @Override public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { if (!option.isAuthPeer()) { return; } checkTrustedCustom(chain, null); trustManager.checkClientTrusted(chain, authType); } TrustManagerExt(X509ExtendedTrustManager manager, SSLOption option, SSLCustom custom); @Override void checkClientTrusted(X509Certificate[] chain, String authType); @Override void checkServerTrusted(X509Certificate[] chain, String authType); @Override X509Certificate[] getAcceptedIssuers(); @Override void checkClientTrusted(X509Certificate[] chain, String authType, Socket socket); @Override void checkClientTrusted(X509Certificate[] chain, String authType, SSLEngine engine); @Override void checkServerTrusted(X509Certificate[] chain, String authType, Socket socket); @Override void checkServerTrusted(X509Certificate[] chain, String authType, SSLEngine engine); }### Answer: @Test public void testCheckClientTrusted(@Mocked CertificateUtil certificateUtil) { MyX509Certificate myX509Certificate1 = new MyX509Certificate(); MyX509Certificate myX509Certificate2 = new MyX509Certificate(); MyX509Certificate[] MyX509CertificateArray = new MyX509Certificate[2]; MyX509CertificateArray[0] = myX509Certificate1; MyX509CertificateArray[1] = myX509Certificate2; new Expectations() { { CertificateUtil.findOwner((X509Certificate[]) any); result = any; CertificateUtil.getCN((X509Certificate) any); result = "10.67.147.115"; } }; MyX509ExtendedTrustManager myX509ExtendedTrustManager = new MyX509ExtendedTrustManager(); TrustManagerExt trustManagerExt = new TrustManagerExt(myX509ExtendedTrustManager, option, custom); Socket socket = null; SSLEngine sslengine = null; boolean validAssert = true; try { trustManagerExt.checkClientTrusted(MyX509CertificateArray, "pks", socket); trustManagerExt.checkClientTrusted(MyX509CertificateArray, "pks", sslengine); trustManagerExt.checkServerTrusted(MyX509CertificateArray, "pks", socket); trustManagerExt.checkServerTrusted(MyX509CertificateArray, "pks", sslengine); } catch (Exception e) { validAssert = false; } Assert.assertTrue(validAssert); } @Test public void testCatchException(@Mocked CertificateUtil certificateUtil) { MyX509Certificate myX509Certificate1 = new MyX509Certificate(); MyX509Certificate myX509Certificate2 = new MyX509Certificate(); MyX509Certificate[] MyX509CertificateArray = new MyX509Certificate[2]; MyX509CertificateArray[0] = myX509Certificate1; MyX509CertificateArray[1] = myX509Certificate2; new Expectations() { { CertificateUtil.findOwner((X509Certificate[]) any); result = any; CertificateUtil.getCN((X509Certificate) any); result = "10.67.147.114"; } }; MyX509ExtendedTrustManager myX509ExtendedTrustManager = new MyX509ExtendedTrustManager(); TrustManagerExt trustManagerExt = new TrustManagerExt(myX509ExtendedTrustManager, option, custom); boolean validAssert = true; try { trustManagerExt.checkClientTrusted(MyX509CertificateArray, "pks"); } catch (CertificateException e) { Assert.assertEquals("CN does not match IP: e=[10.67.147.114],t=null", e.getMessage()); validAssert = false; } Assert.assertFalse(validAssert); }
### Question: SSLSocketFactoryExt extends SSLSocketFactory { @Override public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException { return wrapSocket((SSLSocket) this.sslSocketFactory.createSocket(s, host, port, autoClose)); } SSLSocketFactoryExt(SSLSocketFactory factory, String[] ciphers, String[] protos); @Override Socket createSocket(Socket s, String host, int port, boolean autoClose); @Override String[] getDefaultCipherSuites(); @Override String[] getSupportedCipherSuites(); @Override Socket createSocket(String host, int port); @Override Socket createSocket(InetAddress host, int port); @Override Socket createSocket(String host, int port, InetAddress localHost, int localPort); @Override Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort); }### Answer: @Test public void testCreateSocketException() { boolean validAssert = true; try { instance.createSocket("host", 8080); } catch (Exception e) { validAssert = false; } Assert.assertFalse(validAssert); }
### Question: KeyStoreUtil { public static KeyStore createKeyStore(String storename, String storetype, char[] storevalue) { InputStream is = null; try { KeyStore keystore = KeyStore.getInstance(storetype); is = new FileInputStream(storename); keystore.load(is, storevalue); return keystore; } catch (Exception e) { throw new IllegalArgumentException("Bad key store or value." + e.getMessage()); } finally { if (is != null) { try { is.close(); } catch (IOException e) { ignore(); } } } } private KeyStoreUtil(); static KeyStore createKeyStore(String storename, String storetype, char[] storevalue); @SuppressWarnings({"rawtypes", "unchecked"}) static CRL[] createCRL(String crlfile); static KeyManager[] createKeyManagers(final KeyStore keystore, char[] keyvalue); static TrustManager[] createTrustManagers(final KeyStore keystore); }### Answer: @Test public void testCreateKeyStoreException() { String storename = ""; String storetype = "testType"; char[] storevalue = "Changeme_123".toCharArray(); try { KeyStoreUtil.createKeyStore(storename, storetype, storevalue); } catch (IllegalArgumentException e) { Assert.assertEquals("Bad key store or value.testType not found", e.getMessage()); } } @Test public void testCreateKeyStoreException2() { String storename = strFilePath + "/ssl/trust.jks"; String storetype = "PKCS12"; char[] storevalue = "Changeme_123".toCharArray(); try { KeyStoreUtil.createKeyStore(storename, storetype, storevalue); } catch (IllegalArgumentException e) { Assert.assertEquals("Bad key store or value.DerInputStream.getLength(): lengthTag=109, too big.", e.getMessage()); } }
### Question: KeyStoreUtil { @SuppressWarnings({"rawtypes", "unchecked"}) public static CRL[] createCRL(String crlfile) { InputStream is = null; try { CertificateFactory cf = CertificateFactory.getInstance("X.509"); is = new FileInputStream(crlfile); Collection c = cf.generateCRLs(is); CRL[] crls = (CRL[]) c.toArray(new CRL[c.size()]); return crls; } catch (CertificateException e) { throw new IllegalArgumentException("bad cert file."); } catch (FileNotFoundException e) { throw new IllegalArgumentException("crl file not found."); } catch (CRLException e) { throw new IllegalArgumentException("bad crl file."); } finally { if (is != null) { try { is.close(); } catch (IOException e) { ignore(); } } } } private KeyStoreUtil(); static KeyStore createKeyStore(String storename, String storetype, char[] storevalue); @SuppressWarnings({"rawtypes", "unchecked"}) static CRL[] createCRL(String crlfile); static KeyManager[] createKeyManagers(final KeyStore keystore, char[] keyvalue); static TrustManager[] createTrustManagers(final KeyStore keystore); }### Answer: @Test public void testCreateCRL() { String crlfile = strFilePath + "/ssl/server.p12"; mockGenerateCRLs(); boolean validAssert = true; try { CRL[] crl = KeyStoreUtil.createCRL(crlfile); Assert.assertNull(crl); } catch (Exception e) { validAssert = false; } Assert.assertTrue(validAssert); } @Test public void testCreateCRLException() { String crlfile = strFilePath + "/ssl/server.p12"; boolean validAssert = true; try { new MockUp<CertificateFactory>() { @Mock public final CertificateFactory getInstance(String type) throws CertificateException { throw new CertificateException(); } }; KeyStoreUtil.createCRL(crlfile); } catch (Exception e) { validAssert = false; } Assert.assertFalse(validAssert); } @Test public void testExceptionFileNotFound() { String crlfile = strFilePath + "/ssl/server.p12"; boolean validAssert = true; try { new MockUp<CertificateFactory>() { @Mock public final CertificateFactory getInstance( String type) throws CertificateException, FileNotFoundException { throw new FileNotFoundException(); } }; KeyStoreUtil.createCRL(crlfile); } catch (Exception e) { validAssert = false; Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } Assert.assertFalse(validAssert); } @Test public void testExceptionCRLException() { String crlfile = strFilePath + "/ssl/server.p12"; boolean validAssert = true; try { new MockUp<CertificateFactory>() { @Mock public final CertificateFactory getInstance(String type) throws CertificateException, CRLException { throw new CRLException(); } }; KeyStoreUtil.createCRL(crlfile); } catch (Exception e) { validAssert = false; Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } Assert.assertFalse(validAssert); }
### Question: ProtoParser { public Proto parse(String name) { ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); try { if (classLoader == null) { Thread.currentThread().setContextClassLoader(ProtoParser.class.getClassLoader()); } ProtoContext context = loader.load(defaultReader, name); return context.getProto(); } finally { Thread.currentThread().setContextClassLoader(classLoader); } } Proto parseFromContent(String content); Proto parse(String name); }### Answer: @Test public void parse() throws IOException { URL url = Thread.currentThread().getContextClassLoader().getResource("protobufRoot.proto"); String content = IOUtils.toString(url, StandardCharsets.UTF_8); ProtoParser parser = new ProtoParser(); Proto protoFromContent = parser.parseFromContent(content); Proto protoFromName = parser.parse("protobufRoot.proto"); Assert.assertNotNull(protoFromContent.getMessage("Root")); Assert.assertNotNull(protoFromContent.getMessage("User")); Assert.assertEquals(MoreObjects.toStringHelper(protoFromContent) .omitNullValues() .add("messages", protoFromContent.getMessages()) .toString(), MoreObjects.toStringHelper(protoFromName) .omitNullValues() .add("messages", protoFromName.getMessages()) .toString()); }
### Question: BeanDescriptorManager { public BeanDescriptor getOrCreateBeanDescriptor(Type type) { return beanDescriptors.computeIfAbsent(type, this::createBeanDescriptor); } BeanDescriptorManager(SerializationConfig serializationConfig); BeanDescriptor getOrCreateBeanDescriptor(Type type); }### Answer: @Test public void generic() { Method method = ReflectUtils.findMethod(GenericSchema.class, "genericMethod"); BeanDescriptor beanDescriptor = beanDescriptorManager .getOrCreateBeanDescriptor(method.getGenericParameterTypes()[0]); Assert.assertEquals(String.class, beanDescriptor.getPropertyDescriptors().get("value").getJavaType().getRawClass()); } @Test public void getOrCreate() { Assert.assertSame(beanDescriptor, beanDescriptorManager.getOrCreateBeanDescriptor(Model.class)); Assert.assertSame(Model.class, beanDescriptor.getJavaType().getRawClass()); }
### Question: LatencyDistributionConfig { public List<LatencyScopeConfig> getScopeConfigs() { return scopeConfigs; } LatencyDistributionConfig(String config); List<LatencyScopeConfig> getScopeConfigs(); }### Answer: @Test public void testValidProperty() { String validProperty1 = "0,1,2,10"; String validProperty2 = "0,1, 2 , 10 "; String validProperty3 = "0,1,2,10,"; LatencyDistributionConfig config1 = new LatencyDistributionConfig(validProperty1); LatencyDistributionConfig config2 = new LatencyDistributionConfig(validProperty2); LatencyDistributionConfig config3 = new LatencyDistributionConfig(validProperty3); Assert.assertEquals(4, config1.getScopeConfigs().size()); Assert.assertEquals(4, config2.getScopeConfigs().size()); Assert.assertEquals(4, config3.getScopeConfigs().size()); } @Test public void testInValidProperty1() { expectedException.expect(IllegalStateException.class); expectedException.expectMessage("invalid latency scope, min=2, max=1."); LatencyDistributionConfig latencyDistributionConfig = new LatencyDistributionConfig("2,1,10"); Assert.assertEquals(0, latencyDistributionConfig.getScopeConfigs().size()); } @Test public void testInValidProperty2() { expectedException.expect(NumberFormatException.class); expectedException.expectMessage("For input string: \"a\""); LatencyDistributionConfig latencyDistributionConfig = new LatencyDistributionConfig("a,1,10"); Assert.assertEquals(0, latencyDistributionConfig.getScopeConfigs().size()); }
### Question: DefaultTagFinder implements TagFinder { @Override public String getTagKey() { return tagKey; } DefaultTagFinder(String tagKey); DefaultTagFinder(String tagKey, boolean skipOnNull); @Override boolean skipOnNull(); @Override String getTagKey(); @Override Tag find(Iterable<Tag> tags); }### Answer: @Test public void getTagKey() { Assert.assertEquals("key", finder.getTagKey()); }
### Question: DefaultTagFinder implements TagFinder { @Override public Tag find(Iterable<Tag> tags) { for (Tag tag : tags) { if (tag.key().equals(tagKey)) { return tag; } } return null; } DefaultTagFinder(String tagKey); DefaultTagFinder(String tagKey, boolean skipOnNull); @Override boolean skipOnNull(); @Override String getTagKey(); @Override Tag find(Iterable<Tag> tags); }### Answer: @Test public void readSucc() { Tag tag = new BasicTag("key", "value"); List<Tag> tags = Arrays.asList(new BasicTag("t1", "t1v"), tag); Assert.assertSame(tag, finder.find(tags)); } @Test public void readFail() { List<Tag> tags = Arrays.asList(new BasicTag("t1", "t1v")); Assert.assertNull(finder.find(tags)); }
### Question: MeasurementGroupConfig { public void addGroup(String idName, Object... tagNameOrFinders) { groups.put(idName, Arrays .asList(tagNameOrFinders) .stream() .map(r -> TagFinder.build(r)) .collect(Collectors.toList())); } MeasurementGroupConfig(); MeasurementGroupConfig(String idName, Object... tagNameOrFinders); void addGroup(String idName, Object... tagNameOrFinders); List<TagFinder> findTagFinders(String idName); }### Answer: @Test public void addGroup() { config.addGroup("id1", "tag1.1", "tag1.2"); config.addGroup("id2", "tag2.1", "tag2.2"); Assert.assertThat(groups.keySet(), Matchers.contains("id2", "id1")); Assert.assertThat(groups.get("id1").stream().map(e -> { return e.getTagKey(); }).toArray(), Matchers.arrayContaining("tag1.1", "tag1.2")); Assert.assertThat(groups.get("id2").stream().map(e -> { return e.getTagKey(); }).toArray(), Matchers.arrayContaining("tag2.1", "tag2.2")); }
### Question: MeasurementTree extends MeasurementNode { public void from(Iterator<Meter> meters, MeasurementGroupConfig groupConfig) { meters.forEachRemaining(meter -> { Iterable<Measurement> measurements = meter.measure(); from(measurements, groupConfig); }); } MeasurementTree(); void from(Iterator<Meter> meters, MeasurementGroupConfig groupConfig); void from(Iterable<Measurement> measurements, MeasurementGroupConfig groupConfig); }### Answer: @Test public void from() { timer.record(10, TimeUnit.NANOSECONDS); timer.record(2, TimeUnit.NANOSECONDS); MeasurementGroupConfig config = new MeasurementGroupConfig("id", "g1", "g2", Statistic.count.key()); tree.from(registry.iterator(), config); Assert.assertEquals(2, tree.getChildren().size()); MeasurementNode node = tree.findChild("id", "g1v", "g2v"); Assert.assertEquals(2d, node.findChild(Statistic.count.value()).getMeasurements().get(0).value(), 0); Assert.assertEquals(12d, node.findChild(Statistic.totalTime.value()).getMeasurements().get(0).value(), 0); Assert.assertEquals(0d, tree.findChild("id_notCare").summary(), 0); } @Test public void from_withSkipOnNull() { try { MeasurementGroupConfig config = new MeasurementGroupConfig("id", new DefaultTagFinder("notExist", true)); tree.from(registry.iterator(), config); } catch (Exception e) { Assert.fail("should not throw exception"); } } @Test public void from_failed() { expectedException.expect(IllegalStateException.class); expectedException.expectMessage(Matchers .is("tag key \"notExist\" not exist in Measurement(id:g1=g1v:g2=g2v:statistic=count:t3=t3v:t4=t4v,0,0.0)")); MeasurementGroupConfig config = new MeasurementGroupConfig("id", "notExist"); tree.from(registry.iterator(), config); }
### Question: MeasurementNode { public String getName() { return name; } MeasurementNode(String name, Map<String, MeasurementNode> children); String getName(); Map<String, MeasurementNode> getChildren(); MeasurementNode findChild(String childName); MeasurementNode findChild(String... childNames); MeasurementNode addChild(String childName, Measurement measurement); List<Measurement> getMeasurements(); void addMeasurement(Measurement measurement); double summary(); }### Answer: @Test public void getName() { Assert.assertEquals("name", node.getName()); }
### Question: MeasurementNode { public Map<String, MeasurementNode> getChildren() { return children; } MeasurementNode(String name, Map<String, MeasurementNode> children); String getName(); Map<String, MeasurementNode> getChildren(); MeasurementNode findChild(String childName); MeasurementNode findChild(String... childNames); MeasurementNode addChild(String childName, Measurement measurement); List<Measurement> getMeasurements(); void addMeasurement(Measurement measurement); double summary(); }### Answer: @Test public void getChildren() { Map<String, MeasurementNode> children = new HashMap<>(); node = new MeasurementNode("name", children); Assert.assertSame(children, node.getChildren()); }
### Question: MeasurementNode { public MeasurementNode findChild(String childName) { if (children == null) { return null; } return children.get(childName); } MeasurementNode(String name, Map<String, MeasurementNode> children); String getName(); Map<String, MeasurementNode> getChildren(); MeasurementNode findChild(String childName); MeasurementNode findChild(String... childNames); MeasurementNode addChild(String childName, Measurement measurement); List<Measurement> getMeasurements(); void addMeasurement(Measurement measurement); double summary(); }### Answer: @Test public void findChild_noChildren() { Assert.assertNull(node.findChild("child")); }
### Question: MeasurementNode { public MeasurementNode addChild(String childName, Measurement measurement) { if (children == null) { children = new LinkedHashMap<>(); } MeasurementNode node = children.computeIfAbsent(childName, name -> new MeasurementNode(name, null)); node.addMeasurement(measurement); return node; } MeasurementNode(String name, Map<String, MeasurementNode> children); String getName(); Map<String, MeasurementNode> getChildren(); MeasurementNode findChild(String childName); MeasurementNode findChild(String... childNames); MeasurementNode addChild(String childName, Measurement measurement); List<Measurement> getMeasurements(); void addMeasurement(Measurement measurement); double summary(); }### Answer: @Test public void addChild(@Mocked Measurement measurement) { MeasurementNode c1 = node.addChild("c1", measurement); MeasurementNode c2 = node.addChild("c2", measurement); Assert.assertSame(c1, node.findChild("c1")); Assert.assertSame(c2, node.findChild("c2")); }
### Question: MeasurementNode { public List<Measurement> getMeasurements() { return measurements; } MeasurementNode(String name, Map<String, MeasurementNode> children); String getName(); Map<String, MeasurementNode> getChildren(); MeasurementNode findChild(String childName); MeasurementNode findChild(String... childNames); MeasurementNode addChild(String childName, Measurement measurement); List<Measurement> getMeasurements(); void addMeasurement(Measurement measurement); double summary(); }### Answer: @Test public void getMeasurements(@Mocked Measurement measurement) { node.addMeasurement(measurement); Assert.assertThat(node.getMeasurements(), Matchers.contains(measurement)); }
### Question: MeasurementNode { public double summary() { double result = 0; for (Measurement measurement : measurements) { result += measurement.value(); } return result; } MeasurementNode(String name, Map<String, MeasurementNode> children); String getName(); Map<String, MeasurementNode> getChildren(); MeasurementNode findChild(String childName); MeasurementNode findChild(String... childNames); MeasurementNode addChild(String childName, Measurement measurement); List<Measurement> getMeasurements(); void addMeasurement(Measurement measurement); double summary(); }### Answer: @Test public void summary(@Mocked Measurement measurement) { new Expectations() { { measurement.value(); result = 10; } }; node.addMeasurement(measurement); node.addMeasurement(measurement); Assert.assertEquals(20, node.summary(), 0); }
### Question: MetricsBootstrap { protected void loadMetricsInitializers() { SPIServiceUtils.getSortedService(MetricsInitializer.class) .forEach(initializer -> initializer.init(globalRegistry, eventBus, config)); } void start(GlobalRegistry globalRegistry, EventBus eventBus); void shutdown(); synchronized void pollMeters(); }### Answer: @Test public void loadMetricsInitializers() { List<MetricsInitializer> initList = new ArrayList<>(); MetricsInitializer metricsInitializer = new MetricsInitializer() { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { initList.add(this); } }; new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getSortedService(MetricsInitializer.class); result = Arrays.asList(metricsInitializer, metricsInitializer); } }; bootstrap.start(globalRegistry, eventBus); bootstrap.shutdown(); Assert.assertThat(initList, Matchers.contains(metricsInitializer, metricsInitializer)); }
### Question: MetricsBootstrap { public synchronized void pollMeters() { try { long secondInterval = TimeUnit.MILLISECONDS.toSeconds(config.getMsPollInterval()); PolledEvent polledEvent = globalRegistry.poll(secondInterval); eventBus.post(polledEvent); } catch (Throwable e) { LOGGER.error("poll meters error. ", e); } } void start(GlobalRegistry globalRegistry, EventBus eventBus); void shutdown(); synchronized void pollMeters(); }### Answer: @Test public void pollMeters(@Mocked Registry registry, @Mocked Meter meter, @Mocked Measurement measurement, @Mocked ScheduledExecutorService executor) { List<Meter> meters = Arrays.asList(meter); globalRegistry.add(registry); new Expectations(Executors.class) { { Executors.newScheduledThreadPool(1, (ThreadFactory) any); result = executor; registry.iterator(); result = meters.iterator(); meter.measure(); result = Arrays.asList(measurement); } }; bootstrap.start(globalRegistry, eventBus); PolledEvent result = new PolledEvent(null, null); eventBus.register(new Object() { @Subscribe public void onEvent(PolledEvent event) { result.setMeters(event.getMeters()); result.setMeasurements(event.getMeasurements()); } }); bootstrap.pollMeters(); bootstrap.shutdown(); Assert.assertEquals(meters, result.getMeters()); Assert.assertThat(result.getMeasurements(), Matchers.contains(measurement)); }
### Question: MetricsBootstrap { public void shutdown() { if (executorService != null) { executorService.shutdown(); } List<MetricsInitializer> initializers = new ArrayList<>(SPIServiceUtils.getSortedService(MetricsInitializer.class)); Collections.reverse(initializers); initializers.forEach(initializer -> initializer.destroy()); } void start(GlobalRegistry globalRegistry, EventBus eventBus); void shutdown(); synchronized void pollMeters(); }### Answer: @Test public void shutdown(@Mocked ScheduledExecutorService scheduledExecutorService) { List<MetricsInitializer> destroyList = new ArrayList<>(); MetricsInitializer initializer1 = new MetricsInitializer() { @Override public int getOrder() { return 1; } @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { } @Override public void destroy() { destroyList.add(this); } }; MetricsInitializer initializer2 = new MetricsInitializer() { @Override public int getOrder() { return 2; } @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { } @Override public void destroy() { destroyList.add(this); } }; new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getSortedService(MetricsInitializer.class); result = Arrays.asList(initializer1, initializer2); } }; Deencapsulation.setField(bootstrap, "executorService", scheduledExecutorService); bootstrap.shutdown(); Assert.assertThat(destroyList, Matchers.contains(initializer2, initializer1)); } @Test public void shutdown_notStart() { Assert.assertNull(Deencapsulation.getField(bootstrap, "executorService")); bootstrap.shutdown(); }
### Question: PlaceholderResolver { public List<String> replace(String str, Map<String, Object> parameters) { List<Row> finalRows = replaceToRows(str, parameters); List<String> replaced = new ArrayList<>(); for (Row row : finalRows) { resolve(row, replaced); } for (int idx = 0; idx < replaced.size(); idx++) { String row = replaced.get(idx); replaced.set(idx, row.replace("\\$", "$")); } return replaced; } String replaceFirst(String str); String replaceFirst(String str, Map<String, Object> parameters); List<String> replace(String str, Map<String, Object> parameters); }### Answer: @Test public void unknown() { Assert.assertThat(resolver.replace("prefix${xxx}suffix", parameters), Matchers.contains("prefix${xxx}suffix")); } @Test public void empty() { Assert.assertThat(resolver.replace("prefix${}suffix", parameters), Matchers.contains("prefix${}suffix")); } @Test public void notComplete() { Assert.assertThat(resolver.replace("prefix${suffix", parameters), Matchers.contains("prefix${suffix")); } @Test public void normal() { Assert.assertThat(resolver.replace("prefix.${key}.suffix", parameters), Matchers.contains("prefix.value.suffix")); } @Test public void disable() { Assert.assertThat(resolver.replace("prefix.\\${key}.suffix", parameters), Matchers.contains("prefix.${key}.suffix")); } @Test public void varOfVar() { Assert.assertThat(resolver.replace("prefix.${varOfVar}.suffix", parameters), Matchers.contains("prefix.value.suffix")); } @Test public void list() { Assert.assertThat(resolver.replace("prefix.${low-list}.suffix", parameters), Matchers.contains("prefix.low-1.suffix", "prefix.low-2.suffix")); } @Test public void multi_list() { Assert.assertThat(resolver.replace("prefix.${low-list}.${middle-list}.${high-list}.suffix", parameters), Matchers.contains( "prefix.low-1.middle-1.high-1.suffix", "prefix.low-1.middle-1.high-2.suffix", "prefix.low-1.middle-2.high-1.suffix", "prefix.low-1.middle-2.high-2.suffix", "prefix.low-2.middle-1.high-1.suffix", "prefix.low-2.middle-1.high-2.suffix", "prefix.low-2.middle-2.high-1.suffix", "prefix.low-2.middle-2.high-2.suffix")); } @Test public void nested() { Assert.assertThat(resolver.replace("prefix.${${priority}-list}.suffix", parameters), Matchers.contains("prefix.low-1.suffix", "prefix.low-2.suffix")); } @Test public void mixed() { Assert.assertThat(resolver.replace("prefix.${${priority}-list}.${key}.${high-list}.suffix ${xxx}", parameters), Matchers.contains( "prefix.low-1.value.high-1.suffix ${xxx}", "prefix.low-2.value.high-1.suffix ${xxx}", "prefix.low-1.value.high-2.suffix ${xxx}", "prefix.low-2.value.high-2.suffix ${xxx}")); }
### Question: ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public boolean isSchemaExist(String microserviceId, String schemaId) { Holder<GetExistenceResponse> holder = new Holder<>(); IpPort ipPort = ipPortManager.getAvailableAddress(); CountDownLatch countDownLatch = new CountDownLatch(1); restClientUtil.get(ipPort, Const.REGISTRY_API.MICROSERVICE_EXISTENCE, new RequestParam().addQueryParam("type", "schema") .addQueryParam("serviceId", microserviceId) .addQueryParam("schemaId", schemaId), syncHandler(countDownLatch, GetExistenceResponse.class, holder)); try { countDownLatch.await(); } catch (Exception e) { LOGGER.error("query schema exist {}/{} fail", microserviceId, schemaId, e); } return holder.value != null && schemaId.equals(holder.value.getSchemaId()); } 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); }### Answer: @Test public void isSchemaExist() { String microserviceId = "msId"; String schemaId = "schemaId"; new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { Holder<GetExistenceResponse> holder = Deencapsulation.getField(responseHandler, "arg$4"); holder.value = new GetExistenceResponse(); } }; Assert.assertFalse(oClient.isSchemaExist(microserviceId, schemaId)); }
### Question: ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public Microservice getAggregatedMicroservice(String microserviceId) { return doGetMicroservice(microserviceId, true); } 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); }### Answer: @Test public void getAggregatedMicroservice() { String microserviceId = "msId"; new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { Holder<GetServiceResponse> holder = Deencapsulation.getField(responseHandler, "arg$4"); holder.value = Json .decodeValue( "{\"service\":{\"serviceId\":\"serviceId\",\"framework\":null" + ",\"registerBy\":null,\"environment\":null,\"appId\":\"appId\",\"serviceName\":null," + "\"alias\":null,\"version\":null,\"description\":null,\"level\":null,\"schemas\":[]," + "\"paths\":[],\"status\":\"UP\",\"properties\":{},\"intance\":null}}", GetServiceResponse.class); RequestParam requestParam = requestContext.getParams(); Assert.assertEquals("global=true", requestParam.getQueryParams()); } }; Microservice aggregatedMicroservice = oClient.getAggregatedMicroservice(microserviceId); Assert.assertEquals("serviceId", aggregatedMicroservice.getServiceId()); Assert.assertEquals("appId", aggregatedMicroservice.getAppId()); }
### Question: MetricsBootListener implements BootListener { @Override public void onBeforeProducerProvider(BootEvent event) { if (!DynamicPropertyFactory.getInstance().getBooleanProperty("servicecomb.metrics.endpoint.enabled", true).get()) { return; } MetricsRestPublisher metricsRestPublisher = SPIServiceUtils.getTargetService(MetricsInitializer.class, MetricsRestPublisher.class); event.getScbEngine().getProducerProviderManager() .addProducerMeta("metricsEndpoint", metricsRestPublisher); } MetricsBootstrap getMetricsBootstrap(); SlowInvocationLogger getSlowInvocationLogger(); @Override void onBeforeProducerProvider(BootEvent event); @Override void onAfterRegistry(BootEvent event); @Override void onBeforeClose(BootEvent event); }### Answer: @Test public void onBeforeProducerProvider_metrics_endpoint_enabled_by_default() { final MetricsBootListener listener = new MetricsBootListener(); final List<ProducerMeta> producerMetas = new ArrayList<>(); final BootEvent event = new BootEvent(); final ProducerMeta producerMeta = new ProducerMeta(); final SCBEngine scbEngine = new SCBEngine() { final public ProducerProviderManager producerProviderManager = new ProducerProviderManager(this) { @Override public void addProducerMeta(String schemaId, Object instance) { producerMeta.setSchemaId(schemaId); producerMeta.setInstance(instance); producerMetas.add(producerMeta); } }; @Override public ProducerProviderManager getProducerProviderManager() { return producerProviderManager; } }; event.setScbEngine(scbEngine); listener.onBeforeProducerProvider(event); Assert.assertThat(producerMetas, Matchers.contains(producerMeta)); Assert.assertThat(producerMeta.getSchemaId(), Matchers.equalTo("metricsEndpoint")); Assert.assertThat(producerMeta.getInstance(), Matchers.instanceOf(MetricsRestPublisher.class)); } @Test public void onBeforeProducerProvider_metrics_endpoint_disabled() { ArchaiusUtils.setProperty("servicecomb.metrics.endpoint.enabled", false); final MetricsBootListener listener = new MetricsBootListener(); final List<ProducerMeta> producerMetas = new ArrayList<>(); final BootEvent event = new BootEvent(); final SCBEngine scbEngine = new SCBEngine() { final public ProducerProviderManager producerProviderManager = new ProducerProviderManager(this) { @Override public void addProducerMeta(String schemaId, Object instance) { producerMetas.add(new ProducerMeta(schemaId, instance)); } }; @Override public ProducerProviderManager getProducerProviderManager() { return producerProviderManager; } }; event.setScbEngine(scbEngine); listener.onBeforeProducerProvider(event); Assert.assertThat(producerMetas, Matchers.empty()); }
### Question: ConfigUtil { public static void addConfig(String key, Object value) { localConfig.put(key, value); } private ConfigUtil(); static void setConfigs(Map<String, Object> config); static void addConfig(String key, Object value); static Object getProperty(String key); static Object getProperty(Object config, String key); static List<String> getStringList(@Nonnull Configuration config, @Nonnull String key); static MicroserviceConfigLoader getMicroserviceConfigLoader(); static MicroserviceConfigLoader getMicroserviceConfigLoader(Configuration config); static ConcurrentCompositeConfiguration createLocalConfig(); static AbstractConfiguration convertEnvVariable(AbstractConfiguration source); static AbstractConfiguration createDynamicConfig(); static void installDynamicConfig(); static void destroyConfigCenterConfigurationSource(); static void addExtraConfig(String extraConfigName, Map<String, Object> extraConfig); static void clearExtraConfig(); @SuppressWarnings("unchecked") static ConcurrentHashMap<String, DynamicProperty> getAllDynamicProperties(); @SuppressWarnings("unchecked") static CopyOnWriteArraySet<Runnable> getCallbacks(DynamicProperty property); }### Answer: @Test public void testAddConfig() { Map<String, Object> config = new HashMap<>(); config.put("service_description.name", "service_name_test"); ConfigUtil.setConfigs(config); ConfigUtil.addConfig("service_description.version", "1.0.2"); ConfigUtil.addConfig("cse.test.enabled", true); ConfigUtil.addConfig("cse.test.num", 10); AbstractConfiguration configuration = ConfigUtil.createDynamicConfig(); Assert.assertEquals(configuration.getString("service_description.name"), "service_name_test"); Assert.assertTrue(configuration.getBoolean("cse.test.enabled")); Assert.assertEquals(configuration.getInt("cse.test.num"), 10); }
### Question: ConfigUtil { public static AbstractConfiguration createDynamicConfig() { ConcurrentCompositeConfiguration compositeConfig = ConfigUtil.createLocalConfig(); ConfigCenterConfigurationSource configCenterConfigurationSource = createConfigCenterConfigurationSource(compositeConfig); if (configCenterConfigurationSource != null) { createDynamicWatchedConfiguration(compositeConfig, configCenterConfigurationSource); } return compositeConfig; } private ConfigUtil(); static void setConfigs(Map<String, Object> config); static void addConfig(String key, Object value); static Object getProperty(String key); static Object getProperty(Object config, String key); static List<String> getStringList(@Nonnull Configuration config, @Nonnull String key); static MicroserviceConfigLoader getMicroserviceConfigLoader(); static MicroserviceConfigLoader getMicroserviceConfigLoader(Configuration config); static ConcurrentCompositeConfiguration createLocalConfig(); static AbstractConfiguration convertEnvVariable(AbstractConfiguration source); static AbstractConfiguration createDynamicConfig(); static void installDynamicConfig(); static void destroyConfigCenterConfigurationSource(); static void addExtraConfig(String extraConfigName, Map<String, Object> extraConfig); static void clearExtraConfig(); @SuppressWarnings("unchecked") static ConcurrentHashMap<String, DynamicProperty> getAllDynamicProperties(); @SuppressWarnings("unchecked") static CopyOnWriteArraySet<Runnable> getCallbacks(DynamicProperty property); }### Answer: @Test public void testCreateDynamicConfigHasConfigCenter() { AbstractConfiguration dynamicConfig = ConfigUtil.createDynamicConfig(); Assert.assertEquals(DynamicWatchedConfiguration.class, ((ConcurrentCompositeConfiguration) dynamicConfig).getConfiguration(0).getClass()); }
### Question: ConfigUtil { public static Object getProperty(String key) { Object config = DynamicPropertyFactory.getBackingConfigurationSource(); return getProperty(config, key); } private ConfigUtil(); static void setConfigs(Map<String, Object> config); static void addConfig(String key, Object value); static Object getProperty(String key); static Object getProperty(Object config, String key); static List<String> getStringList(@Nonnull Configuration config, @Nonnull String key); static MicroserviceConfigLoader getMicroserviceConfigLoader(); static MicroserviceConfigLoader getMicroserviceConfigLoader(Configuration config); static ConcurrentCompositeConfiguration createLocalConfig(); static AbstractConfiguration convertEnvVariable(AbstractConfiguration source); static AbstractConfiguration createDynamicConfig(); static void installDynamicConfig(); static void destroyConfigCenterConfigurationSource(); static void addExtraConfig(String extraConfigName, Map<String, Object> extraConfig); static void clearExtraConfig(); @SuppressWarnings("unchecked") static ConcurrentHashMap<String, DynamicProperty> getAllDynamicProperties(); @SuppressWarnings("unchecked") static CopyOnWriteArraySet<Runnable> getCallbacks(DynamicProperty property); }### Answer: @Test public void testGetPropertyInvalidConfig() { Assert.assertNull(ConfigUtil.getProperty(null, "any")); Assert.assertNull(ConfigUtil.getProperty(new Object(), "any")); } @Test public void duplicateServiceCombConfigToCseListValue() { List<String> list = Arrays.asList("a", "b"); AbstractConfiguration config = new DynamicConfiguration(); config.addProperty("cse.list", list); Deencapsulation.invoke(ConfigUtil.class, "duplicateCseConfigToServicecomb", config); Object result = config.getProperty("servicecomb.list"); assertThat(result, instanceOf(List.class)); assertThat(result, equalTo(list)); }
### Question: ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public String getAggregatedSchema(String microserviceId, String schemaId) { return doGetSchema(microserviceId, schemaId, true); } 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); }### Answer: @Test public void getAggregatedSchema() { String microserviceId = "msId"; String schemaId = "schemaId"; new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { Holder<GetSchemaResponse> holder = Deencapsulation.getField(responseHandler, "arg$4"); holder.value = Json .decodeValue( "{ \"schema\": \"schema\", \"schemaId\":\"metricsEndpoint\",\"summary\":\"c1188d709631a9038874f9efc6eb894f\"}", GetSchemaResponse.class); RequestParam requestParam = requestContext.getParams(); Assert.assertEquals("global=true", requestParam.getQueryParams()); } }; LoadingCache<String, Map<String, String>> oldCache = Deencapsulation.getField(oClient, "schemaCache"); LoadingCache<String, Map<String, String>> newCache = CacheBuilder.newBuilder() .expireAfterAccess(60, TimeUnit.SECONDS).build(new CacheLoader<String, Map<String, String>>() { public Map<String, String> load(String key) { Map<String, String> schemas = new HashMap<>(); return schemas; } }); Deencapsulation.setField(oClient, "schemaCache", newCache); String str = oClient.getAggregatedSchema(microserviceId, schemaId); Assert.assertEquals("schema", str); Deencapsulation.setField(oClient, "schemaCache", oldCache); }
### Question: ConfigUtil { public static AbstractConfiguration convertEnvVariable(AbstractConfiguration source) { Iterator<String> keys = source.getKeys(); while (keys.hasNext()) { String key = keys.next(); String[] separatedKey = key.split(CONFIG_KEY_SPLITER); if (separatedKey.length == 1) { continue; } String newKey = String.join(".", separatedKey); source.addProperty(newKey, source.getProperty(key)); } return source; } private ConfigUtil(); static void setConfigs(Map<String, Object> config); static void addConfig(String key, Object value); static Object getProperty(String key); static Object getProperty(Object config, String key); static List<String> getStringList(@Nonnull Configuration config, @Nonnull String key); static MicroserviceConfigLoader getMicroserviceConfigLoader(); static MicroserviceConfigLoader getMicroserviceConfigLoader(Configuration config); static ConcurrentCompositeConfiguration createLocalConfig(); static AbstractConfiguration convertEnvVariable(AbstractConfiguration source); static AbstractConfiguration createDynamicConfig(); static void installDynamicConfig(); static void destroyConfigCenterConfigurationSource(); static void addExtraConfig(String extraConfigName, Map<String, Object> extraConfig); static void clearExtraConfig(); @SuppressWarnings("unchecked") static ConcurrentHashMap<String, DynamicProperty> getAllDynamicProperties(); @SuppressWarnings("unchecked") static CopyOnWriteArraySet<Runnable> getCallbacks(DynamicProperty property); }### Answer: @Test public void testConvertEnvVariable() { String someProperty = "cse_service_registry_address"; AbstractConfiguration config = new DynamicConfiguration(); config.addProperty(someProperty, "testing"); AbstractConfiguration result = ConfigUtil.convertEnvVariable(config); assertThat(result.getString("cse.service.registry.address"), equalTo("testing")); assertThat(result.getString("cse_service_registry_address"), equalTo("testing")); }
### Question: ConfigUtil { public static void destroyConfigCenterConfigurationSource() { SPIServiceUtils.getAllService(ConfigCenterConfigurationSource.class).forEach(source -> { try { source.destroy(); } catch (Throwable e) { LOGGER.error("Failed to destroy {}", source.getClass().getName()); } }); } private ConfigUtil(); static void setConfigs(Map<String, Object> config); static void addConfig(String key, Object value); static Object getProperty(String key); static Object getProperty(Object config, String key); static List<String> getStringList(@Nonnull Configuration config, @Nonnull String key); static MicroserviceConfigLoader getMicroserviceConfigLoader(); static MicroserviceConfigLoader getMicroserviceConfigLoader(Configuration config); static ConcurrentCompositeConfiguration createLocalConfig(); static AbstractConfiguration convertEnvVariable(AbstractConfiguration source); static AbstractConfiguration createDynamicConfig(); static void installDynamicConfig(); static void destroyConfigCenterConfigurationSource(); static void addExtraConfig(String extraConfigName, Map<String, Object> extraConfig); static void clearExtraConfig(); @SuppressWarnings("unchecked") static ConcurrentHashMap<String, DynamicProperty> getAllDynamicProperties(); @SuppressWarnings("unchecked") static CopyOnWriteArraySet<Runnable> getCallbacks(DynamicProperty property); }### Answer: @Test public void destroyConfigCenterConfigurationSource() { AtomicInteger count = new AtomicInteger(); ConfigCenterConfigurationSource source = new MockUp<ConfigCenterConfigurationSource>() { @Mock void destroy() { count.incrementAndGet(); } }.getMockInstance(); new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getAllService(ConfigCenterConfigurationSource.class); result = Arrays.asList(source, source); } }; ConfigUtil.destroyConfigCenterConfigurationSource(); Assert.assertEquals(2, count.get()); }
### Question: DiscoveryTree { public void loadFromSPI(Class<? extends DiscoveryFilter> cls) { filters.addAll(SPIServiceUtils.getSortedService(cls)); } void loadFromSPI(Class<? extends DiscoveryFilter> cls); void addFilter(DiscoveryFilter filter); void sort(); DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName, String versionRule); DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache); }### Answer: @Test public void loadFromSPI(@Mocked DiscoveryFilter f1, @Mocked DiscoveryFilter f2) { Class<? extends DiscoveryFilter> cls = DiscoveryFilter.class; new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getSortedService(cls); result = Arrays.asList(f1, f2); } }; discoveryTree.loadFromSPI(cls); Assert.assertThat(filters, Matchers.contains(f1, f2)); }
### Question: DiscoveryTree { public void sort() { filters.sort(Comparator.comparingInt(DiscoveryFilter::getOrder)); Iterator<DiscoveryFilter> iterator = filters.iterator(); while (iterator.hasNext()) { DiscoveryFilter filter = iterator.next(); if (!filter.enabled()) { iterator.remove(); } LOGGER.info("DiscoveryFilter {}, enabled {}.", filter.getClass().getName(), filter.enabled()); } } void loadFromSPI(Class<? extends DiscoveryFilter> cls); void addFilter(DiscoveryFilter filter); void sort(); DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName, String versionRule); DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache); }### Answer: @Test public void sort(@Mocked DiscoveryFilter f1, @Mocked DiscoveryFilter f2, @Mocked DiscoveryFilter f3) { new Expectations() { { f1.getOrder(); result = -1; f1.enabled(); result = true; f2.getOrder(); result = 0; f2.enabled(); result = true; f3.getOrder(); result = 0; f3.enabled(); result = false; } }; discoveryTree.addFilter(f3); discoveryTree.addFilter(f2); discoveryTree.addFilter(f1); discoveryTree.sort(); Assert.assertThat(filters, Matchers.contains(f1, f2)); }
### Question: DiscoveryTree { protected boolean isMatch(VersionedCache existing, VersionedCache inputCache) { return existing != null && existing.isSameVersion(inputCache); } void loadFromSPI(Class<? extends DiscoveryFilter> cls); void addFilter(DiscoveryFilter filter); void sort(); DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName, String versionRule); DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache); }### Answer: @Test public void isMatch_existingNull() { Assert.assertFalse(discoveryTree.isMatch(null, null)); } @Test public void isMatch_yes() { parent.cacheVersion(1); Assert.assertTrue(discoveryTree.isMatch(new DiscoveryTreeNode().cacheVersion(1), parent)); }
### Question: DiscoveryTree { protected boolean isExpired(VersionedCache existing, VersionedCache inputCache) { return existing == null || existing.isExpired(inputCache); } void loadFromSPI(Class<? extends DiscoveryFilter> cls); void addFilter(DiscoveryFilter filter); void sort(); DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName, String versionRule); DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache); }### Answer: @Test public void isMatch_no() { parent.cacheVersion(0); Assert.assertFalse(discoveryTree.isExpired(new DiscoveryTreeNode().cacheVersion(1), parent)); } @Test public void isExpired_existingNull() { Assert.assertTrue(discoveryTree.isExpired(null, null)); } @Test public void isExpired_yes() { parent.cacheVersion(1); Assert.assertTrue(discoveryTree.isExpired(new DiscoveryTreeNode().cacheVersion(0), parent)); } @Test public void isExpired_no() { parent.cacheVersion(0); Assert.assertFalse(discoveryTree.isExpired(new DiscoveryTreeNode().cacheVersion(0), parent)); }
### Question: DiscoveryTree { public DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName, String versionRule) { VersionedCache instanceVersionedCache = DiscoveryManager.INSTANCE .getInstanceCacheManager() .getOrCreateVersionedCache(appId, microserviceName, versionRule); return discovery(context, instanceVersionedCache); } void loadFromSPI(Class<? extends DiscoveryFilter> cls); void addFilter(DiscoveryFilter filter); void sort(); DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName, String versionRule); DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache); }### Answer: @Test public void easyDiscovery(@Mocked InstanceCacheManager instanceCacheManager) { new Expectations(DiscoveryManager.class) { { DiscoveryManager.INSTANCE.getInstanceCacheManager(); result = instanceCacheManager; instanceCacheManager.getOrCreateVersionedCache(anyString, anyString, anyString); result = parent; } }; result = discoveryTree.discovery(context, null, null, null); Assert.assertEquals(parent.name(), result.name()); Assert.assertEquals(parent.cacheVersion(), result.cacheVersion()); } @Test public void avoidConcurrentProblem() { Deencapsulation.setField(discoveryTree, "root", parent.cacheVersion(1)); Assert.assertTrue(parent.children().isEmpty()); discoveryTree.discovery(context, new VersionedCache().cacheVersion(0).name("input")); Assert.assertTrue(parent.children().isEmpty()); }
### Question: DiscoveryTree { protected DiscoveryTreeNode getOrCreateRoot(VersionedCache inputCache) { DiscoveryTreeNode tmpRoot = root; if (isMatch(tmpRoot, inputCache)) { return tmpRoot; } synchronized (lock) { if (isExpired(root, inputCache)) { root = new DiscoveryTreeNode().cacheVersion(inputCache.cacheVersion()); return root; } if (root.isSameVersion(inputCache)) { return root; } } return new DiscoveryTreeNode().cacheVersion(inputCache.cacheVersion()); } void loadFromSPI(Class<? extends DiscoveryFilter> cls); void addFilter(DiscoveryFilter filter); void sort(); DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName, String versionRule); DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache); }### Answer: @Test public void getOrCreateRoot_match() { Deencapsulation.setField(discoveryTree, "root", parent); DiscoveryTreeNode root = discoveryTree.getOrCreateRoot(parent); Assert.assertSame(parent, root); } @Test public void getOrCreateRoot_expired() { Deencapsulation.setField(discoveryTree, "root", parent); VersionedCache inputCache = new VersionedCache().cacheVersion(parent.cacheVersion() + 1); DiscoveryTreeNode root = discoveryTree.getOrCreateRoot(inputCache); Assert.assertEquals(inputCache.cacheVersion(), root.cacheVersion()); Assert.assertSame(Deencapsulation.getField(discoveryTree, "root"), root); } @Test public void getOrCreateRoot_tempRoot() { Deencapsulation.setField(discoveryTree, "root", parent); VersionedCache inputCache = new VersionedCache().cacheVersion(parent.cacheVersion() - 1); DiscoveryTreeNode root = discoveryTree.getOrCreateRoot(inputCache); Assert.assertEquals(inputCache.cacheVersion(), root.cacheVersion()); Assert.assertNotSame(Deencapsulation.getField(discoveryTree, "root"), root); }