method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
VertxResponseWriter implements ContainerResponseWriter { @Override public boolean enableResponseBuffering() { return false; } @Inject VertxResponseWriter(
HttpServerRequest vertxRequest,
Vertx vertx,
List<VertxResponseProcessor> responseProcessors,
List<VertxPostResponseProcessor> postResponseProcessors); @Override OutputStream writeResponseStatusAndHeaders(long contentLength, ContainerResponse responseContext); @Override boolean suspend(long timeOut, TimeUnit timeUnit, TimeoutHandler timeoutHandler); @Override void setSuspendTimeout(long timeOut, TimeUnit timeUnit); @Override void commit(); @Override void failure(Throwable error); @Override boolean enableResponseBuffering(); }### Answer:
@Test public void testEnableResponseBuffering() throws Exception { boolean result; result = writer.enableResponseBuffering(); assertFalse(result); } |
### Question:
GuiceJerseyServer extends DefaultJerseyServer { protected void injectMultibindings(ServiceLocator locator, Injector injector) { injectMultiBindings(locator, injector, new Key<Set<ContainerRequestFilter>>() { }, ContainerRequestFilter.class); injectMultiBindings(locator, injector, new Key<Set<ContainerResponseFilter>>() { }, ContainerResponseFilter.class); injectMultiBindings(locator, injector, new Key<Set<ReaderInterceptor>>() { }, ReaderInterceptor.class); injectMultiBindings(locator, injector, new Key<Set<WriterInterceptor>>() { }, WriterInterceptor.class); injectMultiBindings(locator, injector, new Key<Set<ModelProcessor>>() { }, ModelProcessor.class); injectMultiBindings(locator, injector, new Key<Set<ContainerLifecycleListener>>() { }, ContainerLifecycleListener.class); injectMultiBindings(locator, injector, new Key<Set<ApplicationEventListener>>() { }, ApplicationEventListener.class); injectMultiBindings(locator, injector, new Key<Set<ExceptionMapper>>() { }, ExceptionMapper.class); } @Inject GuiceJerseyServer(JerseyHandler jerseyHandler, VertxContainer container, Provider<JerseyServerOptions> optionsProvider, ServiceLocator locator, Injector injector); }### Answer:
@Test @SuppressWarnings("unchecked") public void testInjectMultiBindings() throws Exception { Key<?> key; key = Key.get(new TypeLiteral<Set<ContainerRequestFilter>>() { }); Set<ContainerRequestFilter> requestFilters = (Set<ContainerRequestFilter>) injector.getInstance(key); assertEquals(1, requestFilters.size()); verify(injector, times(2)).getInstance(eq(key)); key = Key.get(new TypeLiteral<Set<ContainerResponseFilter>>() { }); verify(injector).getInstance(eq(key)); key = Key.get(new TypeLiteral<Set<ReaderInterceptor>>() { }); verify(injector).getInstance(eq(key)); key = Key.get(new TypeLiteral<Set<WriterInterceptor>>() { }); verify(injector).getInstance(eq(key)); key = Key.get(new TypeLiteral<Set<ModelProcessor>>() { }); verify(injector).getInstance(eq(key)); } |
### Question:
GuiceJerseyBinder extends AbstractModule { @Override protected void configure() { ServiceLocator locator = ServiceLocatorFactory.getInstance().create(null); bind(ServiceLocator.class).toInstance(locator); bind(VertxContainer.class).to(DefaultVertxContainer.class); bind(JerseyServer.class).to(GuiceJerseyServer.class); bind(JerseyHandler.class).to(DefaultJerseyHandler.class); bind(JerseyOptions.class).to(DefaultJerseyOptions.class); bind(JerseyServerOptions.class).to(DefaultJerseyOptions.class); bind(ContainerResponseWriterProvider.class).to(VertxResponseWriterProvider.class); bind(MessageBodyWriter.class).to(WriteStreamBodyWriter.class).in(Singleton.class); bind(ApplicationConfigurator.class).toProvider(Providers.of(null)); Multibinder.newSetBinder(binder(), VertxRequestProcessor.class); Multibinder.newSetBinder(binder(), VertxResponseProcessor.class); Multibinder.newSetBinder(binder(), VertxPostResponseProcessor.class); Multibinder.newSetBinder(binder(), ContainerRequestFilter.class); Multibinder.newSetBinder(binder(), ContainerResponseFilter.class); Multibinder.newSetBinder(binder(), ReaderInterceptor.class); Multibinder.newSetBinder(binder(), WriterInterceptor.class); Multibinder.newSetBinder(binder(), ModelProcessor.class); Multibinder.newSetBinder(binder(), ContainerLifecycleListener.class); Multibinder.newSetBinder(binder(), ApplicationEventListener.class); Multibinder.newSetBinder(binder(), ExceptionMapper.class); } }### Answer:
@Test public void testConfigure() throws Exception { binder.configure(builder); verify(builder, times(9)).bind((Class<?>) any(Class.class)); verify(builder, times(11)).install(any(Module.class)); } |
### Question:
BootstrapBinder extends AbstractModule { @Override protected void configure() { install(new GuiceJerseyBinder()); } }### Answer:
@Test public void testConfigure() throws Exception { binder.configure(builder); verify(builder).install(any(GuiceJerseyBinder.class)); } |
### Question:
BootstrapBinder extends AbstractBinder { @Override protected void configure() { install(new HK2JerseyBinder()); } }### Answer:
@Test public void testConfigure() throws Exception { BootstrapBinder binder = new BootstrapBinder(); DynamicConfiguration dynamicConfiguration = mock(DynamicConfiguration.class); binder.bind(dynamicConfiguration); } |
### Question:
SwaggerServletConfig implements ServletConfig { @Override public String getInitParameter(String name) { return initParams.get(name); } @Inject SwaggerServletConfig(ServletContext context, Configuration config); @Override String getServletName(); @Override ServletContext getServletContext(); @Override String getInitParameter(String name); @Override Enumeration<String> getInitParameterNames(); static final String PROPERTY_PREFIX; }### Answer:
@Test public void testInitParamsCreation() throws Exception { servletConfig = new SwaggerServletConfig(context, configuration); assertNotNull(servletConfig); assertEquals(configId, servletConfig.getInitParameter(CONFIG_ID_KEY)); assertEquals(scannerId, servletConfig.getInitParameter(SCANNER_ID_KEY)); assertEquals(contextId, servletConfig.getInitParameter(CONTEXT_ID_KEY)); }
@Test public void testInitParamsCreation_nullProperty() throws Exception { properties.put(CONFIG_ID_KEY, null); servletConfig = new SwaggerServletConfig(context, configuration); assertNotNull(servletConfig); assertNull(servletConfig.getInitParameter(CONFIG_ID_KEY)); }
@Test public void testInitParamsCreation_ignoredProperty() throws Exception { String ignoredKey = "ignore"; properties.put(ignoredKey, "test-value"); servletConfig = new SwaggerServletConfig(context, configuration); assertNotNull(servletConfig); assertNull(servletConfig.getInitParameter(ignoredKey)); } |
### Question:
SwaggerServletConfig implements ServletConfig { @Override public Enumeration<String> getInitParameterNames() { return Collections.enumeration(initParams.keySet()); } @Inject SwaggerServletConfig(ServletContext context, Configuration config); @Override String getServletName(); @Override ServletContext getServletContext(); @Override String getInitParameter(String name); @Override Enumeration<String> getInitParameterNames(); static final String PROPERTY_PREFIX; }### Answer:
@Test public void testGetInitParameterNames() throws Exception { servletConfig = new SwaggerServletConfig(context, configuration); Enumeration<String> paramNames = servletConfig.getInitParameterNames(); assertNotNull(paramNames); while (paramNames.hasMoreElements()) { assertTrue(properties.keySet().contains(paramNames.nextElement())); } } |
### Question:
JerseyVerticle extends AbstractVerticle { @Override public void start(final Future<Void> startedResult) throws Exception { this.start(); jerseyServer.start(ar -> { if (ar.succeeded()) { startedResult.complete(); } else { startedResult.fail(ar.cause()); } }); } @Inject JerseyVerticle(JerseyServer jerseyServer, JerseyOptions options); @Override void start(final Future<Void> startedResult); @Override void stop(); }### Answer:
@Test public void testStart() throws Exception { jerseyVerticle.start(startedResult); verify(startedResult, never()).complete(); verify(startedResult, never()).fail(any(Throwable.class)); verify(jerseyServer).start(handlerCaptor.capture()); when(asyncResult.succeeded()).thenReturn(true).thenReturn(false); handlerCaptor.getValue().handle(asyncResult); verify(startedResult).complete(); verify(startedResult, never()).fail(any(Throwable.class)); handlerCaptor.getValue().handle(asyncResult); verify(startedResult).complete(); verify(startedResult).fail(any(Throwable.class)); } |
### Question:
SwaggerFeature implements Feature { @Override public boolean configure(FeatureContext context) { Configuration config = context.getConfiguration(); if (PropertiesHelper.isProperty(config.getProperties(), PROPERTY_DISABLE)) { return false; } if (!PropertiesHelper.isProperty(config.getProperties(), PROPERTY_CORS_DISABLE)) { context.register(SwaggerCorsFilter.class); } if (!config.isRegistered(ApiListingResource.class)) { context.register(ApiListingResource.class); context.register(SwaggerSerializers.class); } if (ScannerFactory.getScanner() == null) { ScannerFactory.setScanner(new DefaultJaxrsScanner()); } if (!config.isRegistered(ServletContext.class)) { context.register(new SwaggerFeatureBinder()); } return true; } @Override boolean configure(FeatureContext context); static final String PROPERTY_DISABLE; static final String PROPERTY_CORS_DISABLE; }### Answer:
@Test public void testConfigure() throws Exception { boolean result = feature.configure(context); assertTrue(result); verify(context).register(eq(SwaggerCorsFilter.class)); verify(context).register(eq(ApiListingResource.class)); verify(context).register(eq(SwaggerSerializers.class)); }
@Test public void testConfigure_Disable() throws Exception { properties.put(SwaggerFeature.PROPERTY_DISABLE, true); boolean result = feature.configure(context); assertFalse(result); verify(context, never()).register(any()); } |
### Question:
JacksonFeature implements Feature { @Override public boolean configure(FeatureContext context) { Configuration config = context.getConfiguration(); boolean disabled = PropertiesHelper.isProperty(config.getProperties(), PROPERTY_DISABLE); if (disabled) { return false; } if (!config.isRegistered(ObjectMapperConfigurator.class)) { context.register(new Binder()); context.register(ObjectMapperProvider.class); } return true; } @Override boolean configure(FeatureContext context); static final String PROPERTY_DISABLE; }### Answer:
@Test public void testConfigure() throws Exception { boolean result; result = feature.configure(context); assertTrue(result); verify(context).register(Matchers.<JacksonFeature.Binder>any()); verify(context).register(eq(ObjectMapperProvider.class)); }
@Test public void testConfigure_Disable() throws Exception { properties.put(JacksonFeature.PROPERTY_DISABLE, true); boolean result; result = feature.configure(context); assertFalse(result); verify(context, never()).register(Matchers.<JacksonFeature.Binder>any()); verify(context, never()).register(eq(ObjectMapperProvider.class)); } |
### Question:
DefaultVertxContainer implements VertxContainer { @Override public void start() { if (started) { return; } ApplicationHandler handler = getApplicationHandler(); if (handler == null) { throw new IllegalStateException("ApplicationHandler cannot be null"); } handler.onStartup(this); started = true; } @Inject DefaultVertxContainer(Vertx vertx, JerseyOptions options, @Optional @Nullable ServiceLocator locator, @Optional @Nullable ApplicationConfigurator configurator); @Override void start(); @Override void stop(); @Override Vertx getVertx(); @Override JerseyOptions getOptions(); @Override VertxContainer setOptions(JerseyOptions options); @Override ApplicationHandlerDelegate getApplicationHandlerDelegate(); @Override ResourceConfig getConfiguration(); @Override ApplicationHandler getApplicationHandler(); @Override void reload(); @Override void reload(ResourceConfig configuration); }### Answer:
@Test public void testStart() throws Exception { packages.add("com.englishtown.vertx.jersey.resources"); container = new DefaultVertxContainer(vertx, options, locator, null); container.start(); assertEquals(options, container.getOptions()); assertNotNull(container.getConfiguration()); assertNotNull(container.getApplicationHandler()); assertNotNull(container.getApplicationHandlerDelegate()); }
@Test public void testResourceConfigModifier() throws Exception { boolean[] b = {false}; ApplicationConfigurator configurator = rc -> { b[0] = true; return rc; }; packages.add("com.englishtown.vertx.jersey.resources"); container = new DefaultVertxContainer(vertx, options, locator, configurator); container.start(); assertTrue(b[0]); }
@Test public void testInit_Missing_Resources() throws Exception { try { container = new DefaultVertxContainer(vertx, options, locator, null); container.start(); fail(); } catch (IllegalStateException e) { assertEquals("At least one resource package name or component must be specified", e.getMessage()); } } |
### Question:
DefaultVertxContainer implements VertxContainer { @Override public void stop() { if (!started) { return; } getApplicationHandler().onShutdown(this); applicationHandlerDelegate = null; started = false; } @Inject DefaultVertxContainer(Vertx vertx, JerseyOptions options, @Optional @Nullable ServiceLocator locator, @Optional @Nullable ApplicationConfigurator configurator); @Override void start(); @Override void stop(); @Override Vertx getVertx(); @Override JerseyOptions getOptions(); @Override VertxContainer setOptions(JerseyOptions options); @Override ApplicationHandlerDelegate getApplicationHandlerDelegate(); @Override ResourceConfig getConfiguration(); @Override ApplicationHandler getApplicationHandler(); @Override void reload(); @Override void reload(ResourceConfig configuration); }### Answer:
@Test public void testStop() throws Exception { packages.add("com.englishtown.vertx.jersey.resources"); container = new DefaultVertxContainer(vertx, options, locator, null); container.start(); container.stop(); } |
### Question:
DefaultJerseyOptions implements JerseyOptions, JerseyServerOptions { @Override public URI getBaseUri() { String basePath = config.getString(CONFIG_BASE_PATH, "/"); if (!basePath.endsWith("/")) { basePath += "/"; } return URI.create(basePath); } @Inject DefaultJerseyOptions(Vertx vertx); DefaultJerseyOptions(JsonObject config); @Override List<String> getPackages(); @Override Map<String, Object> getProperties(); @Override Set<Class<?>> getComponents(); @Override Set<Object> getInstances(); String getHost(); int getPort(); boolean getSSL(); JksOptions getKeyStoreOptions(); Integer getReceiveBufferSize(); int getAcceptBacklog(); @Override URI getBaseUri(); @Override int getMaxBodySize(); boolean getCompressionSupported(); @Override HttpServerOptions getServerOptions(); final static String CONFIG_HOST; final static String CONFIG_PORT; final static String CONFIG_SSL; final static String CONFIG_JKS_OPTIONS; final static String CONFIG_RECEIVE_BUFFER_SIZE; final static String CONFIG_BACKLOG_SIZE; final static String CONFIG_RESOURCE_CONFIG; final static String CONFIG_PROPERTIES; final static String CONFIG_COMPRESSION_SUPPORTED; static final String CONFIG_BASE_PATH; static final String CONFIG_MAX_BODY_SIZE; static final String CONFIG_RESOURCES; static final String CONFIG_PACKAGES; static final String CONFIG_FEATURES; static final String CONFIG_COMPONENTS; static final String CONFIG_BINDERS; static final String CONFIG_INSTANCES; static final int DEFAULT_MAX_BODY_SIZE; }### Answer:
@Test public void testGetBaseUri() throws Exception { URI uri; String expected = "/"; uri = options.getBaseUri(); assertEquals(expected, uri.getPath()); expected = "test/base/path"; config.put(DefaultJerseyOptions.CONFIG_BASE_PATH, expected); expected += "/"; uri = options.getBaseUri(); assertEquals(expected, uri.getPath()); } |
### Question:
StringUtils { public static boolean isEmpty(CharSequence s) { return s == null || s.length() == 0; } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testIsEmpty() throws Exception { assertThat(isEmpty("")).isTrue(); assertThat(isEmpty(null)).isTrue(); assertThat(isEmpty(" ")).isFalse(); } |
### Question:
EmptyUtils { public static boolean isEmpty(Object obj) { if (obj == null) { return true; } if (obj instanceof String && obj.toString().length() == 0) { return true; } if (obj.getClass().isArray() && Array.getLength(obj) == 0) { return true; } if (obj instanceof Collection && ((Collection) obj).isEmpty()) { return true; } if (obj instanceof Map && ((Map) obj).isEmpty()) { return true; } if (obj instanceof SparseArray && ((SparseArray) obj).size() == 0) { return true; } if (obj instanceof SparseBooleanArray && ((SparseBooleanArray) obj).size() == 0) { return true; } if (obj instanceof SparseIntArray && ((SparseIntArray) obj).size() == 0) { return true; } if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) { if (obj instanceof SparseLongArray && ((SparseLongArray) obj).size() == 0) { return true; } } return false; } private EmptyUtils(); static boolean isEmpty(Object obj); static boolean isNotEmpty(Object obj); }### Answer:
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2) @Test public void isEmpty() throws Exception { String string = ""; String string1 = " "; int[][] arr = new int[][]{}; int[] arr1 = null; LinkedList<Integer> list = new LinkedList<>(); HashMap<String,Integer> map = new HashMap<>(); SparseArray<String> sa = new SparseArray<>(); SparseBooleanArray sba = new SparseBooleanArray(); SparseIntArray sia = new SparseIntArray(); SparseLongArray sla = new SparseLongArray(); assertThat(EmptyUtils.isEmpty(string)).isTrue(); assertThat(EmptyUtils.isEmpty(string1)).isFalse(); assertThat(EmptyUtils.isEmpty(arr)).isTrue(); assertThat(EmptyUtils.isEmpty(arr1)).isTrue(); assertThat(EmptyUtils.isEmpty(list)).isTrue(); assertThat(EmptyUtils.isEmpty(map)).isTrue(); assertThat(EmptyUtils.isEmpty(sa)).isTrue(); assertThat(EmptyUtils.isEmpty(sba)).isTrue(); assertThat(EmptyUtils.isEmpty(sia)).isTrue(); assertThat(EmptyUtils.isEmpty(sla)).isTrue(); assertThat(!EmptyUtils.isNotEmpty(string)).isTrue(); assertThat(!EmptyUtils.isNotEmpty(string1)).isFalse(); assertThat(!EmptyUtils.isNotEmpty(arr)).isTrue(); assertThat(!EmptyUtils.isNotEmpty(arr1)).isTrue(); assertThat(!EmptyUtils.isNotEmpty(list)).isTrue(); assertThat(!EmptyUtils.isNotEmpty(map)).isTrue(); assertThat(!EmptyUtils.isNotEmpty(sa)).isTrue(); assertThat(!EmptyUtils.isNotEmpty(sba)).isTrue(); assertThat(!EmptyUtils.isNotEmpty(sia)).isTrue(); assertThat(!EmptyUtils.isNotEmpty(sla)).isTrue(); } |
### Question:
StringUtils { public static String toSBC(String s) { if (isEmpty(s)) return s; char[] chars = s.toCharArray(); for (int i = 0, len = chars.length; i < len; i++) { if (chars[i] == ' ') { chars[i] = (char) 12288; } else if (33 <= chars[i] && chars[i] <= 126) { chars[i] = (char) (chars[i] + 65248); } else { chars[i] = chars[i]; } } return new String(chars); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testToSBC() throws Exception { assertThat(toSBC(" ,.&")).isEqualTo(" ，．＆"); } |
### Question:
StringUtils { public static boolean isSpace(String s) { if (s == null) return true; for (int i = 0, len = s.length(); i < len; ++i) { if (!Character.isWhitespace(s.charAt(i))) { return false; } } return true; } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testIsSpace() throws Exception { assertThat(isSpace("")).isTrue(); assertThat(isSpace(null)).isTrue(); assertThat(isSpace(" ")).isTrue(); assertThat(isSpace(" \n\t\r")).isTrue(); } |
### Question:
StringUtils { public static boolean equals(CharSequence a, CharSequence b) { if (a == b) return true; int length; if (a != null && b != null && (length = a.length()) == b.length()) { if (a instanceof String && b instanceof String) { return a.equals(b); } else { for (int i = 0; i < length; i++) { if (a.charAt(i) != b.charAt(i)) return false; } return true; } } return false; } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testEquals() throws Exception { assertThat(StringUtils.equals("blankj", "blankj")).isEqualTo(true); assertThat(StringUtils.equals("blankj", "Blankj")).isEqualTo(false); } |
### Question:
StringUtils { public static boolean equalsIgnoreCase(String a, String b) { return a == null ? b == null : a.equalsIgnoreCase(b); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testEqualsIgnoreCase() throws Exception { assertThat(equalsIgnoreCase(null, null)).isEqualTo(true); assertThat(equalsIgnoreCase(null, "blankj")).isEqualTo(false); assertThat(equalsIgnoreCase("blankj", "Blankj")).isEqualTo(true); assertThat(equalsIgnoreCase("blankj", "blankj")).isEqualTo(true); assertThat(equalsIgnoreCase("blankj", "blank")).isEqualTo(false); } |
### Question:
ConvertUtils { public static String bytes2HexString(byte[] bytes) { if (bytes == null) return null; int len = bytes.length; if (len <= 0) return null; char[] ret = new char[len << 1]; for (int i = 0, j = 0; i < len; i++) { ret[j++] = hexDigits[bytes[i] >>> 4 & 0x0f]; ret[j++] = hexDigits[bytes[i] & 0x0f]; } return new String(ret); } private ConvertUtils(); static String bytes2HexString(byte[] bytes); static byte[] hexString2Bytes(String hexString); static byte[] chars2Bytes(char[] chars); static char[] bytes2Chars(byte[] bytes); static long memorySize2Byte(long memorySize, @MemoryConstants.Unit int unit); static double byte2MemorySize(long byteNum, @MemoryConstants.Unit int unit); @SuppressLint("DefaultLocale") static String byte2FitMemorySize(long byteNum); static long timeSpan2Millis(long timeSpan, @TimeConstants.Unit int unit); static long millis2TimeSpan(long millis, @TimeConstants.Unit int unit); @SuppressLint("DefaultLocale") static String millis2FitTimeSpan(long millis, int precision); static String bytes2Bits(byte[] bytes); static byte[] bits2Bytes(String bits); static ByteArrayOutputStream input2OutputStream(InputStream is); ByteArrayInputStream output2InputStream(OutputStream out); static byte[] inputStream2Bytes(InputStream is); static InputStream bytes2InputStream(byte[] bytes); static byte[] outputStream2Bytes(OutputStream out); static OutputStream bytes2OutputStream(byte[] bytes); static String inputStream2String(InputStream is, String charsetName); static InputStream string2InputStream(String string, String charsetName); static String outputStream2String(OutputStream out, String charsetName); static OutputStream string2OutputStream(String string, String charsetName); static byte[] bitmap2Bytes(Bitmap bitmap, Bitmap.CompressFormat format); static Bitmap bytes2Bitmap(byte[] bytes); static Bitmap drawable2Bitmap(Drawable drawable); static Drawable bitmap2Drawable(Bitmap bitmap); static byte[] drawable2Bytes(Drawable drawable, Bitmap.CompressFormat format); static Drawable bytes2Drawable(byte[] bytes); static Bitmap view2Bitmap(View view); static int dp2px(float dpValue); static int px2dp(float pxValue); static int sp2px(float spValue); static int px2sp(float pxValue); }### Answer:
@Test public void testBytes2HexString() throws Exception { assertThat(bytes2HexString(mBytes)).isEqualTo(hexString); } |
### Question:
ConvertUtils { public static byte[] hexString2Bytes(String hexString) { if (isSpace(hexString)) return null; int len = hexString.length(); if (len % 2 != 0) { hexString = "0" + hexString; len = len + 1; } char[] hexBytes = hexString.toUpperCase().toCharArray(); byte[] ret = new byte[len >> 1]; for (int i = 0; i < len; i += 2) { ret[i >> 1] = (byte) (hex2Dec(hexBytes[i]) << 4 | hex2Dec(hexBytes[i + 1])); } return ret; } private ConvertUtils(); static String bytes2HexString(byte[] bytes); static byte[] hexString2Bytes(String hexString); static byte[] chars2Bytes(char[] chars); static char[] bytes2Chars(byte[] bytes); static long memorySize2Byte(long memorySize, @MemoryConstants.Unit int unit); static double byte2MemorySize(long byteNum, @MemoryConstants.Unit int unit); @SuppressLint("DefaultLocale") static String byte2FitMemorySize(long byteNum); static long timeSpan2Millis(long timeSpan, @TimeConstants.Unit int unit); static long millis2TimeSpan(long millis, @TimeConstants.Unit int unit); @SuppressLint("DefaultLocale") static String millis2FitTimeSpan(long millis, int precision); static String bytes2Bits(byte[] bytes); static byte[] bits2Bytes(String bits); static ByteArrayOutputStream input2OutputStream(InputStream is); ByteArrayInputStream output2InputStream(OutputStream out); static byte[] inputStream2Bytes(InputStream is); static InputStream bytes2InputStream(byte[] bytes); static byte[] outputStream2Bytes(OutputStream out); static OutputStream bytes2OutputStream(byte[] bytes); static String inputStream2String(InputStream is, String charsetName); static InputStream string2InputStream(String string, String charsetName); static String outputStream2String(OutputStream out, String charsetName); static OutputStream string2OutputStream(String string, String charsetName); static byte[] bitmap2Bytes(Bitmap bitmap, Bitmap.CompressFormat format); static Bitmap bytes2Bitmap(byte[] bytes); static Bitmap drawable2Bitmap(Drawable drawable); static Drawable bitmap2Drawable(Bitmap bitmap); static byte[] drawable2Bytes(Drawable drawable, Bitmap.CompressFormat format); static Drawable bytes2Drawable(byte[] bytes); static Bitmap view2Bitmap(View view); static int dp2px(float dpValue); static int px2dp(float pxValue); static int sp2px(float spValue); static int px2sp(float pxValue); }### Answer:
@Test public void testHexString2Bytes() throws Exception { assertThat(hexString2Bytes(hexString)).isEqualTo(mBytes); } |
### Question:
ConvertUtils { public static byte[] chars2Bytes(char[] chars) { if (chars == null || chars.length <= 0) return null; int len = chars.length; byte[] bytes = new byte[len]; for (int i = 0; i < len; i++) { bytes[i] = (byte) (chars[i]); } return bytes; } private ConvertUtils(); static String bytes2HexString(byte[] bytes); static byte[] hexString2Bytes(String hexString); static byte[] chars2Bytes(char[] chars); static char[] bytes2Chars(byte[] bytes); static long memorySize2Byte(long memorySize, @MemoryConstants.Unit int unit); static double byte2MemorySize(long byteNum, @MemoryConstants.Unit int unit); @SuppressLint("DefaultLocale") static String byte2FitMemorySize(long byteNum); static long timeSpan2Millis(long timeSpan, @TimeConstants.Unit int unit); static long millis2TimeSpan(long millis, @TimeConstants.Unit int unit); @SuppressLint("DefaultLocale") static String millis2FitTimeSpan(long millis, int precision); static String bytes2Bits(byte[] bytes); static byte[] bits2Bytes(String bits); static ByteArrayOutputStream input2OutputStream(InputStream is); ByteArrayInputStream output2InputStream(OutputStream out); static byte[] inputStream2Bytes(InputStream is); static InputStream bytes2InputStream(byte[] bytes); static byte[] outputStream2Bytes(OutputStream out); static OutputStream bytes2OutputStream(byte[] bytes); static String inputStream2String(InputStream is, String charsetName); static InputStream string2InputStream(String string, String charsetName); static String outputStream2String(OutputStream out, String charsetName); static OutputStream string2OutputStream(String string, String charsetName); static byte[] bitmap2Bytes(Bitmap bitmap, Bitmap.CompressFormat format); static Bitmap bytes2Bitmap(byte[] bytes); static Bitmap drawable2Bitmap(Drawable drawable); static Drawable bitmap2Drawable(Bitmap bitmap); static byte[] drawable2Bytes(Drawable drawable, Bitmap.CompressFormat format); static Drawable bytes2Drawable(byte[] bytes); static Bitmap view2Bitmap(View view); static int dp2px(float dpValue); static int px2dp(float pxValue); static int sp2px(float spValue); static int px2sp(float pxValue); }### Answer:
@Test public void testChars2Bytes() throws Exception { assertThat(chars2Bytes(mChars1)).isEqualTo(mBytes1); } |
### Question:
ConvertUtils { public static char[] bytes2Chars(byte[] bytes) { if (bytes == null) return null; int len = bytes.length; if (len <= 0) return null; char[] chars = new char[len]; for (int i = 0; i < len; i++) { chars[i] = (char) (bytes[i] & 0xff); } return chars; } private ConvertUtils(); static String bytes2HexString(byte[] bytes); static byte[] hexString2Bytes(String hexString); static byte[] chars2Bytes(char[] chars); static char[] bytes2Chars(byte[] bytes); static long memorySize2Byte(long memorySize, @MemoryConstants.Unit int unit); static double byte2MemorySize(long byteNum, @MemoryConstants.Unit int unit); @SuppressLint("DefaultLocale") static String byte2FitMemorySize(long byteNum); static long timeSpan2Millis(long timeSpan, @TimeConstants.Unit int unit); static long millis2TimeSpan(long millis, @TimeConstants.Unit int unit); @SuppressLint("DefaultLocale") static String millis2FitTimeSpan(long millis, int precision); static String bytes2Bits(byte[] bytes); static byte[] bits2Bytes(String bits); static ByteArrayOutputStream input2OutputStream(InputStream is); ByteArrayInputStream output2InputStream(OutputStream out); static byte[] inputStream2Bytes(InputStream is); static InputStream bytes2InputStream(byte[] bytes); static byte[] outputStream2Bytes(OutputStream out); static OutputStream bytes2OutputStream(byte[] bytes); static String inputStream2String(InputStream is, String charsetName); static InputStream string2InputStream(String string, String charsetName); static String outputStream2String(OutputStream out, String charsetName); static OutputStream string2OutputStream(String string, String charsetName); static byte[] bitmap2Bytes(Bitmap bitmap, Bitmap.CompressFormat format); static Bitmap bytes2Bitmap(byte[] bytes); static Bitmap drawable2Bitmap(Drawable drawable); static Drawable bitmap2Drawable(Bitmap bitmap); static byte[] drawable2Bytes(Drawable drawable, Bitmap.CompressFormat format); static Drawable bytes2Drawable(byte[] bytes); static Bitmap view2Bitmap(View view); static int dp2px(float dpValue); static int px2dp(float pxValue); static int sp2px(float spValue); static int px2sp(float pxValue); }### Answer:
@Test public void testBytes2Chars() throws Exception { assertThat(bytes2Chars(mBytes1)).isEqualTo(mChars1); } |
### Question:
ConvertUtils { public static double byte2MemorySize(long byteNum, @MemoryConstants.Unit int unit) { if (byteNum < 0) return -1; return (double) byteNum / unit; } private ConvertUtils(); static String bytes2HexString(byte[] bytes); static byte[] hexString2Bytes(String hexString); static byte[] chars2Bytes(char[] chars); static char[] bytes2Chars(byte[] bytes); static long memorySize2Byte(long memorySize, @MemoryConstants.Unit int unit); static double byte2MemorySize(long byteNum, @MemoryConstants.Unit int unit); @SuppressLint("DefaultLocale") static String byte2FitMemorySize(long byteNum); static long timeSpan2Millis(long timeSpan, @TimeConstants.Unit int unit); static long millis2TimeSpan(long millis, @TimeConstants.Unit int unit); @SuppressLint("DefaultLocale") static String millis2FitTimeSpan(long millis, int precision); static String bytes2Bits(byte[] bytes); static byte[] bits2Bytes(String bits); static ByteArrayOutputStream input2OutputStream(InputStream is); ByteArrayInputStream output2InputStream(OutputStream out); static byte[] inputStream2Bytes(InputStream is); static InputStream bytes2InputStream(byte[] bytes); static byte[] outputStream2Bytes(OutputStream out); static OutputStream bytes2OutputStream(byte[] bytes); static String inputStream2String(InputStream is, String charsetName); static InputStream string2InputStream(String string, String charsetName); static String outputStream2String(OutputStream out, String charsetName); static OutputStream string2OutputStream(String string, String charsetName); static byte[] bitmap2Bytes(Bitmap bitmap, Bitmap.CompressFormat format); static Bitmap bytes2Bitmap(byte[] bytes); static Bitmap drawable2Bitmap(Drawable drawable); static Drawable bitmap2Drawable(Bitmap bitmap); static byte[] drawable2Bytes(Drawable drawable, Bitmap.CompressFormat format); static Drawable bytes2Drawable(byte[] bytes); static Bitmap view2Bitmap(View view); static int dp2px(float dpValue); static int px2dp(float pxValue); static int sp2px(float spValue); static int px2sp(float pxValue); }### Answer:
@Test public void testByte2Unit() throws Exception { assertThat(byte2MemorySize(MemoryConstants.GB, MemoryConstants.MB) - 1024).isWithin(0.001); } |
### Question:
ConvertUtils { @SuppressLint("DefaultLocale") public static String byte2FitMemorySize(long byteNum) { if (byteNum < 0) { return "shouldn't be less than zero!"; } else if (byteNum < MemoryConstants.KB) { return String.format("%.3fB", (double) byteNum + 0.0005); } else if (byteNum < MemoryConstants.MB) { return String.format("%.3fKB", (double) byteNum / MemoryConstants.KB + 0.0005); } else if (byteNum < MemoryConstants.GB) { return String.format("%.3fMB", (double) byteNum / MemoryConstants.MB + 0.0005); } else { return String.format("%.3fGB", (double) byteNum / MemoryConstants.GB + 0.0005); } } private ConvertUtils(); static String bytes2HexString(byte[] bytes); static byte[] hexString2Bytes(String hexString); static byte[] chars2Bytes(char[] chars); static char[] bytes2Chars(byte[] bytes); static long memorySize2Byte(long memorySize, @MemoryConstants.Unit int unit); static double byte2MemorySize(long byteNum, @MemoryConstants.Unit int unit); @SuppressLint("DefaultLocale") static String byte2FitMemorySize(long byteNum); static long timeSpan2Millis(long timeSpan, @TimeConstants.Unit int unit); static long millis2TimeSpan(long millis, @TimeConstants.Unit int unit); @SuppressLint("DefaultLocale") static String millis2FitTimeSpan(long millis, int precision); static String bytes2Bits(byte[] bytes); static byte[] bits2Bytes(String bits); static ByteArrayOutputStream input2OutputStream(InputStream is); ByteArrayInputStream output2InputStream(OutputStream out); static byte[] inputStream2Bytes(InputStream is); static InputStream bytes2InputStream(byte[] bytes); static byte[] outputStream2Bytes(OutputStream out); static OutputStream bytes2OutputStream(byte[] bytes); static String inputStream2String(InputStream is, String charsetName); static InputStream string2InputStream(String string, String charsetName); static String outputStream2String(OutputStream out, String charsetName); static OutputStream string2OutputStream(String string, String charsetName); static byte[] bitmap2Bytes(Bitmap bitmap, Bitmap.CompressFormat format); static Bitmap bytes2Bitmap(byte[] bytes); static Bitmap drawable2Bitmap(Drawable drawable); static Drawable bitmap2Drawable(Bitmap bitmap); static byte[] drawable2Bytes(Drawable drawable, Bitmap.CompressFormat format); static Drawable bytes2Drawable(byte[] bytes); static Bitmap view2Bitmap(View view); static int dp2px(float dpValue); static int px2dp(float pxValue); static int sp2px(float spValue); static int px2sp(float pxValue); }### Answer:
@Test public void testByte2FitSize() throws Exception { assertThat(byte2FitMemorySize(1024 * 1024 * 3 + 1024 * 100)).isEqualTo("3.098MB"); } |
### Question:
ConvertUtils { @SuppressLint("DefaultLocale") public static String millis2FitTimeSpan(long millis, int precision) { if (millis <= 0 || precision <= 0) return null; StringBuilder sb = new StringBuilder(); String[] units = {"天", "小时", "分钟", "秒", "毫秒"}; int[] unitLen = {86400000, 3600000, 60000, 1000, 1}; precision = Math.min(precision, 5); for (int i = 0; i < precision; i++) { if (millis >= unitLen[i]) { long mode = millis / unitLen[i]; millis -= mode * unitLen[i]; sb.append(mode).append(units[i]); } } return sb.toString(); } private ConvertUtils(); static String bytes2HexString(byte[] bytes); static byte[] hexString2Bytes(String hexString); static byte[] chars2Bytes(char[] chars); static char[] bytes2Chars(byte[] bytes); static long memorySize2Byte(long memorySize, @MemoryConstants.Unit int unit); static double byte2MemorySize(long byteNum, @MemoryConstants.Unit int unit); @SuppressLint("DefaultLocale") static String byte2FitMemorySize(long byteNum); static long timeSpan2Millis(long timeSpan, @TimeConstants.Unit int unit); static long millis2TimeSpan(long millis, @TimeConstants.Unit int unit); @SuppressLint("DefaultLocale") static String millis2FitTimeSpan(long millis, int precision); static String bytes2Bits(byte[] bytes); static byte[] bits2Bytes(String bits); static ByteArrayOutputStream input2OutputStream(InputStream is); ByteArrayInputStream output2InputStream(OutputStream out); static byte[] inputStream2Bytes(InputStream is); static InputStream bytes2InputStream(byte[] bytes); static byte[] outputStream2Bytes(OutputStream out); static OutputStream bytes2OutputStream(byte[] bytes); static String inputStream2String(InputStream is, String charsetName); static InputStream string2InputStream(String string, String charsetName); static String outputStream2String(OutputStream out, String charsetName); static OutputStream string2OutputStream(String string, String charsetName); static byte[] bitmap2Bytes(Bitmap bitmap, Bitmap.CompressFormat format); static Bitmap bytes2Bitmap(byte[] bytes); static Bitmap drawable2Bitmap(Drawable drawable); static Drawable bitmap2Drawable(Bitmap bitmap); static byte[] drawable2Bytes(Drawable drawable, Bitmap.CompressFormat format); static Drawable bytes2Drawable(byte[] bytes); static Bitmap view2Bitmap(View view); static int dp2px(float dpValue); static int px2dp(float pxValue); static int sp2px(float spValue); static int px2sp(float pxValue); }### Answer:
@Test public void testMillis2FitTimeSpan() throws Exception { long millis = TimeConstants.DAY * 6 + TimeConstants.HOUR * 6 + TimeConstants.MIN * 6 + TimeConstants.SEC * 6 + 6; System.out.println(millis2FitTimeSpan(millis, 7)); System.out.println(millis2FitTimeSpan(millis, 4)); System.out.println(millis2FitTimeSpan(millis, 3)); System.out.println(millis2FitTimeSpan(millis * 4, 5)); } |
### Question:
ConvertUtils { public static String bytes2Bits(byte[] bytes) { StringBuilder sb = new StringBuilder(); for (byte aByte : bytes) { for (int j = 7; j >= 0; --j) { sb.append(((aByte >> j) & 0x01) == 0 ? '0' : '1'); } } return sb.toString(); } private ConvertUtils(); static String bytes2HexString(byte[] bytes); static byte[] hexString2Bytes(String hexString); static byte[] chars2Bytes(char[] chars); static char[] bytes2Chars(byte[] bytes); static long memorySize2Byte(long memorySize, @MemoryConstants.Unit int unit); static double byte2MemorySize(long byteNum, @MemoryConstants.Unit int unit); @SuppressLint("DefaultLocale") static String byte2FitMemorySize(long byteNum); static long timeSpan2Millis(long timeSpan, @TimeConstants.Unit int unit); static long millis2TimeSpan(long millis, @TimeConstants.Unit int unit); @SuppressLint("DefaultLocale") static String millis2FitTimeSpan(long millis, int precision); static String bytes2Bits(byte[] bytes); static byte[] bits2Bytes(String bits); static ByteArrayOutputStream input2OutputStream(InputStream is); ByteArrayInputStream output2InputStream(OutputStream out); static byte[] inputStream2Bytes(InputStream is); static InputStream bytes2InputStream(byte[] bytes); static byte[] outputStream2Bytes(OutputStream out); static OutputStream bytes2OutputStream(byte[] bytes); static String inputStream2String(InputStream is, String charsetName); static InputStream string2InputStream(String string, String charsetName); static String outputStream2String(OutputStream out, String charsetName); static OutputStream string2OutputStream(String string, String charsetName); static byte[] bitmap2Bytes(Bitmap bitmap, Bitmap.CompressFormat format); static Bitmap bytes2Bitmap(byte[] bytes); static Bitmap drawable2Bitmap(Drawable drawable); static Drawable bitmap2Drawable(Bitmap bitmap); static byte[] drawable2Bytes(Drawable drawable, Bitmap.CompressFormat format); static Drawable bytes2Drawable(byte[] bytes); static Bitmap view2Bitmap(View view); static int dp2px(float dpValue); static int px2dp(float pxValue); static int sp2px(float spValue); static int px2sp(float pxValue); }### Answer:
@Test public void testBytes2Bits() throws Exception { System.out.println(bytes2Bits(new byte[]{0x7F, (byte) 0xFA})); } |
### Question:
ConvertUtils { public static byte[] bits2Bytes(String bits) { int lenMod = bits.length() % 8; int byteLen = bits.length() / 8; if (lenMod != 0) { for (int i = lenMod; i < 8; i++) { bits = "0" + bits; } byteLen++; } byte[] bytes = new byte[byteLen]; for (int i = 0; i < byteLen; ++i) { for (int j = 0; j < 8; ++j) { bytes[i] <<= 1; bytes[i] |= bits.charAt(i * 8 + j) - '0'; } } return bytes; } private ConvertUtils(); static String bytes2HexString(byte[] bytes); static byte[] hexString2Bytes(String hexString); static byte[] chars2Bytes(char[] chars); static char[] bytes2Chars(byte[] bytes); static long memorySize2Byte(long memorySize, @MemoryConstants.Unit int unit); static double byte2MemorySize(long byteNum, @MemoryConstants.Unit int unit); @SuppressLint("DefaultLocale") static String byte2FitMemorySize(long byteNum); static long timeSpan2Millis(long timeSpan, @TimeConstants.Unit int unit); static long millis2TimeSpan(long millis, @TimeConstants.Unit int unit); @SuppressLint("DefaultLocale") static String millis2FitTimeSpan(long millis, int precision); static String bytes2Bits(byte[] bytes); static byte[] bits2Bytes(String bits); static ByteArrayOutputStream input2OutputStream(InputStream is); ByteArrayInputStream output2InputStream(OutputStream out); static byte[] inputStream2Bytes(InputStream is); static InputStream bytes2InputStream(byte[] bytes); static byte[] outputStream2Bytes(OutputStream out); static OutputStream bytes2OutputStream(byte[] bytes); static String inputStream2String(InputStream is, String charsetName); static InputStream string2InputStream(String string, String charsetName); static String outputStream2String(OutputStream out, String charsetName); static OutputStream string2OutputStream(String string, String charsetName); static byte[] bitmap2Bytes(Bitmap bitmap, Bitmap.CompressFormat format); static Bitmap bytes2Bitmap(byte[] bytes); static Bitmap drawable2Bitmap(Drawable drawable); static Drawable bitmap2Drawable(Bitmap bitmap); static byte[] drawable2Bytes(Drawable drawable, Bitmap.CompressFormat format); static Drawable bytes2Drawable(byte[] bytes); static Bitmap view2Bitmap(View view); static int dp2px(float dpValue); static int px2dp(float pxValue); static int sp2px(float spValue); static int px2sp(float pxValue); }### Answer:
@Test public void testBits2Bytes() throws Exception { System.out.println(bytes2HexString(bits2Bytes("111111111111010"))); } |
### Question:
EncodeUtils { public static String urlEncode(String input) { return urlEncode(input, "UTF-8"); } private EncodeUtils(); static String urlEncode(String input); static String urlEncode(String input, String charset); static String urlDecode(String input); static String urlDecode(String input, String charset); static byte[] base64Encode(String input); static byte[] base64Encode(byte[] input); static String base64Encode2String(byte[] input); static byte[] base64Decode(String input); static byte[] base64Decode(byte[] input); static byte[] base64UrlSafeEncode(String input); static String htmlEncode(CharSequence input); @SuppressWarnings("deprecation") static CharSequence htmlDecode(String input); }### Answer:
@Test public void testUrlEncode() throws Exception { assertThat(urlEncode("哈哈哈")).isEqualTo(urlEncodeString); assertThat(urlEncode("哈哈哈", "UTF-8")).isEqualTo(urlEncodeString); } |
### Question:
StringUtils { public static String null2Length0(String s) { return s == null ? "" : s; } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testNull2Length0() throws Exception { assertThat(null2Length0(null)).isEqualTo(""); } |
### Question:
EncodeUtils { public static String urlDecode(String input) { return urlDecode(input, "UTF-8"); } private EncodeUtils(); static String urlEncode(String input); static String urlEncode(String input, String charset); static String urlDecode(String input); static String urlDecode(String input, String charset); static byte[] base64Encode(String input); static byte[] base64Encode(byte[] input); static String base64Encode2String(byte[] input); static byte[] base64Decode(String input); static byte[] base64Decode(byte[] input); static byte[] base64UrlSafeEncode(String input); static String htmlEncode(CharSequence input); @SuppressWarnings("deprecation") static CharSequence htmlDecode(String input); }### Answer:
@Test public void testUrlDecode() throws Exception { assertThat(urlDecode(urlEncodeString)).isEqualTo("哈哈哈"); assertThat(urlDecode(urlEncodeString, "UTF-8")).isEqualTo("哈哈哈"); } |
### Question:
EncodeUtils { public static String htmlEncode(CharSequence input) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) { return Html.escapeHtml(input); } else { StringBuilder out = new StringBuilder(); for (int i = 0, len = input.length(); i < len; i++) { char c = input.charAt(i); if (c == '<') { out.append("<"); } else if (c == '>') { out.append(">"); } else if (c == '&') { out.append("&"); } else if (c >= 0xD800 && c <= 0xDFFF) { if (c < 0xDC00 && i + 1 < len) { char d = input.charAt(i + 1); if (d >= 0xDC00 && d <= 0xDFFF) { i++; int codepoint = 0x010000 | (int) c - 0xD800 << 10 | (int) d - 0xDC00; out.append("&#").append(codepoint).append(";"); } } } else if (c > 0x7E || c < ' ') { out.append("&#").append((int) c).append(";"); } else if (c == ' ') { while (i + 1 < len && input.charAt(i + 1) == ' ') { out.append(" "); i++; } out.append(' '); } else { out.append(c); } } return out.toString(); } } private EncodeUtils(); static String urlEncode(String input); static String urlEncode(String input, String charset); static String urlDecode(String input); static String urlDecode(String input, String charset); static byte[] base64Encode(String input); static byte[] base64Encode(byte[] input); static String base64Encode2String(byte[] input); static byte[] base64Decode(String input); static byte[] base64Decode(byte[] input); static byte[] base64UrlSafeEncode(String input); static String htmlEncode(CharSequence input); @SuppressWarnings("deprecation") static CharSequence htmlDecode(String input); }### Answer:
@Test public void testHtmlEncode() throws Exception { assertThat(htmlEncode(html)).isEqualTo(encodeHtml); } |
### Question:
EncodeUtils { @SuppressWarnings("deprecation") public static CharSequence htmlDecode(String input) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) { return Html.fromHtml(input, Html.FROM_HTML_MODE_LEGACY); } else { return Html.fromHtml(input); } } private EncodeUtils(); static String urlEncode(String input); static String urlEncode(String input, String charset); static String urlDecode(String input); static String urlDecode(String input, String charset); static byte[] base64Encode(String input); static byte[] base64Encode(byte[] input); static String base64Encode2String(byte[] input); static byte[] base64Decode(String input); static byte[] base64Decode(byte[] input); static byte[] base64UrlSafeEncode(String input); static String htmlEncode(CharSequence input); @SuppressWarnings("deprecation") static CharSequence htmlDecode(String input); }### Answer:
@Test public void testHtmlDecode() throws Exception { assertThat(htmlDecode(encodeHtml).toString()).isEqualTo(html); } |
### Question:
PinyinUtils { public static String getPinyinFirstLetter(CharSequence ccs) { if (ccs == null || ccs.length() == 0) return null; return ccs2Pinyin(String.valueOf(ccs.charAt(0))).substring(0, 1); } private PinyinUtils(); static String ccs2Pinyin(CharSequence ccs); static String ccs2Pinyin(CharSequence ccs, CharSequence split); static String getPinyinFirstLetter(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs, CharSequence split); static String getSurnamePinyin(CharSequence name); static String getSurnameFirstLetter(CharSequence name); }### Answer:
@Test public void getPinyinFirstLetter() throws Exception { System.out.println("单: " + PinyinUtils.getPinyinFirstLetter("单")); System.out.println("元: " + PinyinUtils.getPinyinFirstLetter("元")); System.out.println("測: " + PinyinUtils.getPinyinFirstLetter("測")); System.out.println("試: " + PinyinUtils.getPinyinFirstLetter("試")); } |
### Question:
PinyinUtils { public static String getPinyinFirstLetters(CharSequence ccs) { return getPinyinFirstLetters(ccs, ""); } private PinyinUtils(); static String ccs2Pinyin(CharSequence ccs); static String ccs2Pinyin(CharSequence ccs, CharSequence split); static String getPinyinFirstLetter(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs, CharSequence split); static String getSurnamePinyin(CharSequence name); static String getSurnameFirstLetter(CharSequence name); }### Answer:
@Test public void getPinyinFirstLetters() throws Exception { System.out.println("單元測試: " + PinyinUtils.getPinyinFirstLetters("單元測試", ",")); } |
### Question:
PinyinUtils { public static String ccs2Pinyin(CharSequence ccs) { return ccs2Pinyin(ccs, ""); } private PinyinUtils(); static String ccs2Pinyin(CharSequence ccs); static String ccs2Pinyin(CharSequence ccs, CharSequence split); static String getPinyinFirstLetter(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs, CharSequence split); static String getSurnamePinyin(CharSequence name); static String getSurnameFirstLetter(CharSequence name); }### Answer:
@Test public void ccs2Pinyin() throws Exception { long t = System.currentTimeMillis(); System.out.println("已初始化的汉字转拼音用时测试: " + PinyinUtils.ccs2Pinyin("已初始化的汉字转拼音用时测试", " ")); System.out.printf("用时: %dms\n", System.currentTimeMillis() - t); } |
### Question:
PinyinUtils { public static String getSurnamePinyin(CharSequence name) { if (name == null || name.length() == 0) return null; if (name.length() >= 2) { CharSequence str = name.subSequence(0, 2); if (str.equals("澹台")) return "tantai"; else if (str.equals("尉迟")) return "yuchi"; else if (str.equals("万俟")) return "moqi"; else if (str.equals("单于")) return "chanyu"; } char ch = name.charAt(0); if (surnames.containsKey(ch)) { return surnames.get(ch); } if (ch >= 0x4E00 && ch <= 0x9FA5) { int sp = (ch - 0x4E00) * 6; return pinyinTable.substring(sp, sp + 6).trim(); } else { return String.valueOf(ch); } } private PinyinUtils(); static String ccs2Pinyin(CharSequence ccs); static String ccs2Pinyin(CharSequence ccs, CharSequence split); static String getPinyinFirstLetter(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs); static String getPinyinFirstLetters(CharSequence ccs, CharSequence split); static String getSurnamePinyin(CharSequence name); static String getSurnameFirstLetter(CharSequence name); }### Answer:
@Test public void getSurnamePinyin() throws Exception { System.out.println("澹台: " + PinyinUtils.getSurnamePinyin("澹台")); System.out.println("尉迟: " + PinyinUtils.getSurnamePinyin("尉迟")); System.out.println("万俟: " + PinyinUtils.getSurnamePinyin("万俟")); System.out.println("单于: " + PinyinUtils.getSurnamePinyin("单于")); String surnames = "乐乘乜仇会便区单参句召员宓弗折曾朴查洗盖祭种秘繁缪能蕃覃解谌适都阿难黑"; int size = surnames.length(); long t = System.currentTimeMillis(); for (int i = 0; i < size; ++i) { String surname = String.valueOf(surnames.charAt(i)); System.out.printf("%s 正确: %-6s 首字母: %-6s 错误: %-6s\n", surname, PinyinUtils.getSurnamePinyin(surname), PinyinUtils.getSurnameFirstLetter(surname), PinyinUtils.ccs2Pinyin(surname)); } System.out.printf("用时: %dms\n", System.currentTimeMillis() - t); } |
### Question:
RegexUtils { public static boolean isMobileSimple(CharSequence input) { return isMatch(RegexConstants.REGEX_MOBILE_SIMPLE, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testIsMobileSimple() throws Exception { assertThat(isMobileSimple("11111111111")).isTrue(); } |
### Question:
RegexUtils { public static boolean isMobileExact(CharSequence input) { return isMatch(RegexConstants.REGEX_MOBILE_EXACT, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testIsMobileExact() throws Exception { assertThat(isMobileExact("11111111111")).isFalse(); assertThat(isMobileExact("13888880000")).isTrue(); } |
### Question:
RegexUtils { public static boolean isTel(CharSequence input) { return isMatch(RegexConstants.REGEX_TEL, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testIsTel() throws Exception { assertThat(isTel("033-88888888")).isTrue(); assertThat(isTel("033-7777777")).isTrue(); assertThat(isTel("0444-88888888")).isTrue(); assertThat(isTel("0444-7777777")).isTrue(); assertThat(isTel("033 88888888")).isTrue(); assertThat(isTel("033 7777777")).isTrue(); assertThat(isTel("0444 88888888")).isTrue(); assertThat(isTel("0444 7777777")).isTrue(); assertThat(isTel("03388888888")).isTrue(); assertThat(isTel("0337777777")).isTrue(); assertThat(isTel("044488888888")).isTrue(); assertThat(isTel("04447777777")).isTrue(); assertThat(isTel("133-88888888")).isFalse(); assertThat(isTel("033-666666")).isFalse(); assertThat(isTel("0444-999999999")).isFalse(); } |
### Question:
StringUtils { public static int length(CharSequence s) { return s == null ? 0 : s.length(); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testLength() throws Exception { assertThat(length(null)).isEqualTo(0); assertThat(length("")).isEqualTo(0); assertThat(length("blankj")).isEqualTo(6); } |
### Question:
RegexUtils { public static boolean isIDCard18(CharSequence input) { return isMatch(RegexConstants.REGEX_ID_CARD18, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testIsIDCard() throws Exception { assertThat(isIDCard18("33698418400112523x")).isTrue(); assertThat(isIDCard18("336984184001125233")).isTrue(); assertThat(isIDCard18("336984184021125233")).isFalse(); } |
### Question:
RegexUtils { public static boolean isEmail(CharSequence input) { return isMatch(RegexConstants.REGEX_EMAIL, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testIsEmail() throws Exception { assertThat(isEmail("[email protected]")).isTrue(); assertThat(isEmail("blankj@qq")).isFalse(); } |
### Question:
RegexUtils { public static boolean isURL(CharSequence input) { return isMatch(RegexConstants.REGEX_URL, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testIsURL() throws Exception { assertThat(isURL("http: assertThat(isURL("https:blank")).isFalse(); } |
### Question:
RegexUtils { public static boolean isZh(CharSequence input) { return isMatch(RegexConstants.REGEX_ZH, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testIsChz() throws Exception { assertThat(isZh("我")).isTrue(); assertThat(isZh("wo")).isFalse(); } |
### Question:
RegexUtils { public static boolean isUsername(CharSequence input) { return isMatch(RegexConstants.REGEX_USERNAME, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testIsUsername() throws Exception { assertThat(isUsername("小明233333")).isTrue(); assertThat(isUsername("小明")).isFalse(); assertThat(isUsername("小明233333_")).isFalse(); } |
### Question:
RegexUtils { public static boolean isDate(CharSequence input) { return isMatch(RegexConstants.REGEX_DATE, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testIsDate() throws Exception { assertThat(isDate("2016-08-16")).isTrue(); assertThat(isDate("2016-02-29")).isTrue(); assertThat(isDate("2015-02-29")).isFalse(); assertThat(isDate("2016-8-16")).isFalse(); } |
### Question:
RegexUtils { public static boolean isIP(CharSequence input) { return isMatch(RegexConstants.REGEX_IP, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testIsIP() throws Exception { assertThat(isIP("255.255.255.0")).isTrue(); assertThat(isIP("256.255.255.0")).isFalse(); } |
### Question:
RegexUtils { public static boolean isMatch(String regex, CharSequence input) { return input != null && input.length() > 0 && Pattern.matches(regex, input); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testIsMatch() throws Exception { assertThat(isMatch("\\d?", "1")).isTrue(); assertThat(isMatch("\\d?", "a")).isFalse(); } |
### Question:
RegexUtils { public static List<String> getMatches(String regex, CharSequence input) { if (input == null) return null; List<String> matches = new ArrayList<>(); Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(input); while (matcher.find()) { matches.add(matcher.group()); } return matches; } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testGetMatches() throws Exception { System.out.println(getMatches("b.*j", "blankj blankj")); System.out.println(getMatches("b.*?j", "blankj blankj")); } |
### Question:
RegexUtils { public static String[] getSplits(String input, String regex) { if (input == null) return null; return input.split(regex); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testGetSplits() throws Exception { System.out.println(Arrays.asList(getSplits("1 2 3", " "))); } |
### Question:
StringUtils { public static String upperFirstLetter(String s) { if (isEmpty(s) || !Character.isLowerCase(s.charAt(0))) return s; return String.valueOf((char) (s.charAt(0) - 32)) + s.substring(1); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testUpperFirstLetter() throws Exception { assertThat(upperFirstLetter("blankj")).isEqualTo("Blankj"); assertThat(upperFirstLetter("Blankj")).isEqualTo("Blankj"); assertThat(upperFirstLetter("1Blankj")).isEqualTo("1Blankj"); } |
### Question:
RegexUtils { public static String getReplaceFirst(String input, String regex, String replacement) { if (input == null) return null; return Pattern.compile(regex).matcher(input).replaceFirst(replacement); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testGetReplace() throws Exception { System.out.println(getReplaceFirst("1 2 3", " ", ", ")); } |
### Question:
RegexUtils { public static String getReplaceAll(String input, String regex, String replacement) { if (input == null) return null; return Pattern.compile(regex).matcher(input).replaceAll(replacement); } private RegexUtils(); static boolean isMobileSimple(CharSequence input); static boolean isMobileExact(CharSequence input); static boolean isTel(CharSequence input); static boolean isIDCard15(CharSequence input); static boolean isIDCard18(CharSequence input); static boolean isEmail(CharSequence input); static boolean isURL(CharSequence input); static boolean isZh(CharSequence input); static boolean isUsername(CharSequence input); static boolean isDate(CharSequence input); static boolean isIP(CharSequence input); static boolean isMatch(String regex, CharSequence input); static List<String> getMatches(String regex, CharSequence input); static String[] getSplits(String input, String regex); static String getReplaceFirst(String input, String regex, String replacement); static String getReplaceAll(String input, String regex, String replacement); }### Answer:
@Test public void testGetReplaceAll() throws Exception { System.out.println(getReplaceAll("1 2 3", " ", ", ")); } |
### Question:
SPUtils { public String getString(String key) { return getString(key, null); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }### Answer:
@Test public void testGetString() throws Exception { assertThat(spUtils.getString("stringKey")).isEqualTo("stringVal"); assertThat(spUtils.getString("stringKey1", "stringVal1")).isEqualTo("stringVal1"); assertThat(spUtils.getString("stringKey1")).isNull(); } |
### Question:
SPUtils { public int getInt(String key) { return getInt(key, -1); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }### Answer:
@Test public void testGetInt() throws Exception { assertThat(spUtils.getInt("intKey")).isEqualTo(1); assertThat(spUtils.getInt("intKey1", 10086)).isEqualTo(10086); assertThat(spUtils.getInt("intKey1")).isEqualTo(-1); } |
### Question:
SPUtils { public long getLong(String key) { return getLong(key, -1L); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }### Answer:
@Test public void testGetLong() throws Exception { assertThat(spUtils.getLong("longKey")).isEqualTo(1L); assertThat(spUtils.getLong("longKey1", 10086L)).isEqualTo(10086L); assertThat(spUtils.getLong("longKey1")).isEqualTo(-1L); } |
### Question:
SPUtils { public float getFloat(String key) { return getFloat(key, -1f); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }### Answer:
@Test public void testGetFloat() throws Exception { assertThat(spUtils.getFloat("floatKey") - 1.f).isWithin(0.f); assertThat(spUtils.getFloat("floatKey1", 10086f) - 10086f).isWithin(0.f); assertThat(spUtils.getFloat("floatKey1") + 1.f).isWithin(0.f); } |
### Question:
SPUtils { public boolean getBoolean(String key) { return getBoolean(key, false); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }### Answer:
@Test public void testGetBoolean() throws Exception { assertThat(spUtils.getBoolean("booleanKey")).isTrue(); assertThat(spUtils.getBoolean("booleanKey1", true)).isTrue(); assertThat(spUtils.getBoolean("booleanKey1")).isFalse(); } |
### Question:
SPUtils { public Map<String, ?> getAll() { return sp.getAll(); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }### Answer:
@Test public void testGetAll() throws Exception { Map<String, ?> map = spUtils.getAll(); for (Map.Entry<String, ?> entry : map.entrySet()) { System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); } } |
### Question:
SPUtils { public void remove(String key) { editor.remove(key).apply(); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }### Answer:
@Test public void testRemove() throws Exception { spUtils.remove("stringKey"); testGetAll(); } |
### Question:
SPUtils { public boolean contains(String key) { return sp.contains(key); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }### Answer:
@Test public void testContains() throws Exception { assertThat(spUtils.contains("stringKey")).isTrue(); assertThat(spUtils.contains("string")).isFalse(); } |
### Question:
StringUtils { public static String lowerFirstLetter(String s) { if (isEmpty(s) || !Character.isUpperCase(s.charAt(0))) return s; return String.valueOf((char) (s.charAt(0) + 32)) + s.substring(1); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testLowerFirstLetter() throws Exception { assertThat(lowerFirstLetter("blankj")).isEqualTo("blankj"); assertThat(lowerFirstLetter("Blankj")).isEqualTo("blankj"); assertThat(lowerFirstLetter("1blankj")).isEqualTo("1blankj"); } |
### Question:
SPUtils { public void clear() { editor.clear().apply(); } SPUtils(String spName); void put(String key, @Nullable String value); String getString(String key); String getString(String key, String defaultValue); void put(String key, int value); int getInt(String key); int getInt(String key, int defaultValue); void put(String key, long value); long getLong(String key); long getLong(String key, long defaultValue); void put(String key, float value); float getFloat(String key); float getFloat(String key, float defaultValue); void put(String key, boolean value); boolean getBoolean(String key); boolean getBoolean(String key, boolean defaultValue); void put(String key, @Nullable Set<String> values); Set<String> getStringSet(String key); Set<String> getStringSet(String key, @Nullable Set<String> defaultValue); Map<String, ?> getAll(); void remove(String key); boolean contains(String key); void clear(); }### Answer:
@Test public void testClear() throws Exception { spUtils.clear(); testGetAll(); } |
### Question:
SDCardUtils { public static boolean isSDCardEnable() { return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()); } private SDCardUtils(); static boolean isSDCardEnable(); static String getSDCardPath(); static String getDataPath(); @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2) static String getFreeSpace(); @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2) static String getSDCardInfo(); }### Answer:
@Test public void testIsSDCardEnable() throws Exception { System.out.println(SDCardUtils.isSDCardEnable()); } |
### Question:
SDCardUtils { public static String getSDCardPath() { if (!isSDCardEnable()) return null; String cmd = "cat /proc/mounts"; Runtime run = Runtime.getRuntime(); BufferedReader bufferedReader = null; try { Process p = run.exec(cmd); bufferedReader = new BufferedReader(new InputStreamReader(new BufferedInputStream(p.getInputStream()))); String lineStr; while ((lineStr = bufferedReader.readLine()) != null) { if (lineStr.contains("sdcard") && lineStr.contains(".android_secure")) { String[] strArray = lineStr.split(" "); if (strArray.length >= 5) { return strArray[1].replace("/.android_secure", "") + File.separator; } } if (p.waitFor() != 0 && p.exitValue() == 1) { break; } } } catch (Exception e) { e.printStackTrace(); } finally { CloseUtils.closeIO(bufferedReader); } return Environment.getExternalStorageDirectory().getPath() + File.separator; } private SDCardUtils(); static boolean isSDCardEnable(); static String getSDCardPath(); static String getDataPath(); @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2) static String getFreeSpace(); @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2) static String getSDCardInfo(); }### Answer:
@Test public void testGetSDCardPath() throws Exception { System.out.println(SDCardUtils.getSDCardPath()); } |
### Question:
FileIOUtils { public static boolean writeFileFromIS(String filePath, final InputStream is) { return writeFileFromIS(FileUtils.getFileByPath(filePath), is, false); } private FileIOUtils(); static boolean writeFileFromIS(String filePath, final InputStream is); static boolean writeFileFromIS(String filePath, final InputStream is, boolean append); static boolean writeFileFromIS(File file, final InputStream is); static boolean writeFileFromIS(File file, final InputStream is, boolean append); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes, boolean append); static boolean writeFileFromBytesByStream(File file, final byte[] bytes); static boolean writeFileFromBytesByStream(File file, final byte[] bytes, boolean append); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromString(String filePath, String content); static boolean writeFileFromString(String filePath, String content, boolean append); static boolean writeFileFromString(File file, String content); static boolean writeFileFromString(File file, String content, boolean append); static List<String> readFile2List(String filePath); static List<String> readFile2List(String filePath, String charsetName); static List<String> readFile2List(File file); static List<String> readFile2List(File file, String charsetName); static List<String> readFile2List(String filePath, int st, int end); static List<String> readFile2List(String filePath, int st, int end, String charsetName); static List<String> readFile2List(File file, int st, int end); static List<String> readFile2List(File file, int st, int end, String charsetName); static String readFile2String(String filePath); static String readFile2String(String filePath, String charsetName); static String readFile2String(File file); static String readFile2String(File file, String charsetName); static byte[] readFile2BytesByStream(String filePath); static byte[] readFile2BytesByStream(File file); static byte[] readFile2BytesByChannel(String filePath); static byte[] readFile2BytesByChannel(File file); static byte[] readFile2BytesByMap(String filePath); static byte[] readFile2BytesByMap(File file); }### Answer:
@Test public void writeFileFromIS() throws Exception { } |
### Question:
FileIOUtils { public static boolean writeFileFromString(String filePath, String content) { return writeFileFromString(FileUtils.getFileByPath(filePath), content, false); } private FileIOUtils(); static boolean writeFileFromIS(String filePath, final InputStream is); static boolean writeFileFromIS(String filePath, final InputStream is, boolean append); static boolean writeFileFromIS(File file, final InputStream is); static boolean writeFileFromIS(File file, final InputStream is, boolean append); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes, boolean append); static boolean writeFileFromBytesByStream(File file, final byte[] bytes); static boolean writeFileFromBytesByStream(File file, final byte[] bytes, boolean append); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromString(String filePath, String content); static boolean writeFileFromString(String filePath, String content, boolean append); static boolean writeFileFromString(File file, String content); static boolean writeFileFromString(File file, String content, boolean append); static List<String> readFile2List(String filePath); static List<String> readFile2List(String filePath, String charsetName); static List<String> readFile2List(File file); static List<String> readFile2List(File file, String charsetName); static List<String> readFile2List(String filePath, int st, int end); static List<String> readFile2List(String filePath, int st, int end, String charsetName); static List<String> readFile2List(File file, int st, int end); static List<String> readFile2List(File file, int st, int end, String charsetName); static String readFile2String(String filePath); static String readFile2String(String filePath, String charsetName); static String readFile2String(File file); static String readFile2String(File file, String charsetName); static byte[] readFile2BytesByStream(String filePath); static byte[] readFile2BytesByStream(File file); static byte[] readFile2BytesByChannel(String filePath); static byte[] readFile2BytesByChannel(File file); static byte[] readFile2BytesByMap(String filePath); static byte[] readFile2BytesByMap(File file); }### Answer:
@Test public void writeFileFromString() throws Exception { } |
### Question:
FileIOUtils { public static List<String> readFile2List(String filePath) { return readFile2List(FileUtils.getFileByPath(filePath), null); } private FileIOUtils(); static boolean writeFileFromIS(String filePath, final InputStream is); static boolean writeFileFromIS(String filePath, final InputStream is, boolean append); static boolean writeFileFromIS(File file, final InputStream is); static boolean writeFileFromIS(File file, final InputStream is, boolean append); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes, boolean append); static boolean writeFileFromBytesByStream(File file, final byte[] bytes); static boolean writeFileFromBytesByStream(File file, final byte[] bytes, boolean append); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromString(String filePath, String content); static boolean writeFileFromString(String filePath, String content, boolean append); static boolean writeFileFromString(File file, String content); static boolean writeFileFromString(File file, String content, boolean append); static List<String> readFile2List(String filePath); static List<String> readFile2List(String filePath, String charsetName); static List<String> readFile2List(File file); static List<String> readFile2List(File file, String charsetName); static List<String> readFile2List(String filePath, int st, int end); static List<String> readFile2List(String filePath, int st, int end, String charsetName); static List<String> readFile2List(File file, int st, int end); static List<String> readFile2List(File file, int st, int end, String charsetName); static String readFile2String(String filePath); static String readFile2String(String filePath, String charsetName); static String readFile2String(File file); static String readFile2String(File file, String charsetName); static byte[] readFile2BytesByStream(String filePath); static byte[] readFile2BytesByStream(File file); static byte[] readFile2BytesByChannel(String filePath); static byte[] readFile2BytesByChannel(File file); static byte[] readFile2BytesByMap(String filePath); static byte[] readFile2BytesByMap(File file); }### Answer:
@Test public void readFile2List() throws Exception { } |
### Question:
FileIOUtils { public static String readFile2String(String filePath) { return readFile2String(FileUtils.getFileByPath(filePath), null); } private FileIOUtils(); static boolean writeFileFromIS(String filePath, final InputStream is); static boolean writeFileFromIS(String filePath, final InputStream is, boolean append); static boolean writeFileFromIS(File file, final InputStream is); static boolean writeFileFromIS(File file, final InputStream is, boolean append); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes); static boolean writeFileFromBytesByStream(String filePath, final byte[] bytes, boolean append); static boolean writeFileFromBytesByStream(File file, final byte[] bytes); static boolean writeFileFromBytesByStream(File file, final byte[] bytes, boolean append); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByChannel(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(String filePath, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean isForce); static boolean writeFileFromBytesByMap(File file, final byte[] bytes, boolean append, boolean isForce); static boolean writeFileFromString(String filePath, String content); static boolean writeFileFromString(String filePath, String content, boolean append); static boolean writeFileFromString(File file, String content); static boolean writeFileFromString(File file, String content, boolean append); static List<String> readFile2List(String filePath); static List<String> readFile2List(String filePath, String charsetName); static List<String> readFile2List(File file); static List<String> readFile2List(File file, String charsetName); static List<String> readFile2List(String filePath, int st, int end); static List<String> readFile2List(String filePath, int st, int end, String charsetName); static List<String> readFile2List(File file, int st, int end); static List<String> readFile2List(File file, int st, int end, String charsetName); static String readFile2String(String filePath); static String readFile2String(String filePath, String charsetName); static String readFile2String(File file); static String readFile2String(File file, String charsetName); static byte[] readFile2BytesByStream(String filePath); static byte[] readFile2BytesByStream(File file); static byte[] readFile2BytesByChannel(String filePath); static byte[] readFile2BytesByChannel(File file); static byte[] readFile2BytesByMap(String filePath); static byte[] readFile2BytesByMap(File file); }### Answer:
@Test public void readFile2String() throws Exception { } |
### Question:
StringUtils { public static String reverse(String s) { int len = length(s); if (len <= 1) return s; int mid = len >> 1; char[] chars = s.toCharArray(); char c; for (int i = 0; i < mid; ++i) { c = chars[i]; chars[i] = chars[len - i - 1]; chars[len - i - 1] = c; } return new String(chars); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testReverse() throws Exception { assertThat(reverse("blankj")).isEqualTo("jknalb"); assertThat(reverse("blank")).isEqualTo("knalb"); assertThat(reverse("测试中文")).isEqualTo("文中试测"); assertThat(reverse(null)).isNull(); } |
### Question:
StringUtils { public static String toDBC(String s) { if (isEmpty(s)) return s; char[] chars = s.toCharArray(); for (int i = 0, len = chars.length; i < len; i++) { if (chars[i] == 12288) { chars[i] = ' '; } else if (65281 <= chars[i] && chars[i] <= 65374) { chars[i] = (char) (chars[i] - 65248); } else { chars[i] = chars[i]; } } return new String(chars); } private StringUtils(); static boolean isEmpty(CharSequence s); static boolean isTrimEmpty(String s); static boolean isSpace(String s); static boolean equals(CharSequence a, CharSequence b); static boolean equalsIgnoreCase(String a, String b); static String null2Length0(String s); static int length(CharSequence s); static String upperFirstLetter(String s); static String lowerFirstLetter(String s); static String reverse(String s); static String toDBC(String s); static String toSBC(String s); }### Answer:
@Test public void testToDBC() throws Exception { assertThat(toDBC(" ，．＆")).isEqualTo(" ,.&"); } |
### Question:
HistoricUserMetricServiceImpl implements HistoricUserMetricService { @Override public void addToCurrentPeriod(final Iterable<UserMetric> saved) { saved.forEach(s -> { addToTendency(s, ChronoUnit.MINUTES); addToTendency(s, ChronoUnit.HOURS); addToTendency(s, ChronoUnit.DAYS); }); } @Autowired HistoricUserMetricServiceImpl(
final UserMetricsRepository userMetricsRepository,
final HistoricUserMetricRepository historicUserMetricRepository
); @Override void addToCurrentPeriod(final Iterable<UserMetric> saved); @Override List<UserMetricDTO> getHistoricMetrics(final List<String> views); }### Answer:
@Test public void testAddingToExistingHistoricUserMetric() { service.addToCurrentPeriod(userMetrics); service.addToCurrentPeriod(userMetrics); final HistoricUserMetric result = repository.findById( HistoricUserMetricMapper.generateId( "AWSRequestNumber", ChronoUnit.DAYS, LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.DAYS) ) ); assertEquals("AWSRequestNumber", result.getIdentifier()); assertEquals((long) result.getTimestamp(), LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.DAYS)); assertEquals(48, result.getValue(), 0.0); assertEquals(result.getHistoricType(), ChronoUnit.DAYS); }
@Test public void testAddingToUnExistingHistoricUserMetric() { service.addToCurrentPeriod(userMetrics); final HistoricUserMetric result = repository.findById( HistoricUserMetricMapper.generateId( "AWSRequestNumber", ChronoUnit.DAYS, LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.DAYS) ) ); assertEquals("AWSRequestNumber", result.getIdentifier()); assertEquals((long) result.getTimestamp(), LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.DAYS)); assertEquals(24, result.getValue(), 0.0); assertEquals(result.getHistoricType(), ChronoUnit.DAYS); }
@Test public void testAddWithSampleSize() { service.addToCurrentPeriod(userMetrics); final HistoricUserMetric result = repository.findById( HistoricUserMetricMapper.generateId( "AWSResponseTime", ChronoUnit.DAYS, LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.DAYS) ) ); assertEquals("AWSResponseTime", result.getIdentifier()); assertEquals((long) result.getTimestamp(), LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.DAYS)); assertEquals(250d, result.getSampleSize(), 0.0); assertEquals(3000d, result.getValue(), 0.0); assertEquals(result.getHistoricType(), ChronoUnit.DAYS); }
@Test public void testAvailabilityRate() { service.addToCurrentPeriod(userMetrics); final HistoricUserMetric result = repository.findById( HistoricUserMetricMapper.generateId( "AWSAvailabilityRate", ChronoUnit.HOURS, LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.HOURS) ) ); assertEquals("AWSAvailabilityRate", result.getIdentifier()); assertEquals((long) result.getTimestamp(), LocalDateTimeHelper.getTimestampPeriod(TODAY, ChronoUnit.HOURS)); assertEquals(2, (long) result.getSampleSize()); assertEquals(175, result.getValue(), 0.0); assertEquals(result.getHistoricType(), ChronoUnit.HOURS); } |
### Question:
IssueEventHandler implements EventHandler { @Override public void processEvents(final List<Event> eventList, final Set<String> dashboardIds) { final List<String> idList = eventList.stream() .map(Event::getCollectionId) .map(String.class::cast) .collect(Collectors.toList()); if (idList.contains(null)) { connectionHandler.sendEventUpdateMessageToAll(EventType.ISSUE); } else { final Iterable<Issue> issues = issueService.getIssuesById(idList); final Predicate<Dashboard> filterDashboards = dashboard -> StreamSupport.stream(issues.spliterator(), false) .anyMatch(issue -> CollectionUtils.containsAny(issue.getKeywords(), dashboard.getBoards())); eventsHelper.processEvents(dashboardIds, filterDashboards, EventType.ISSUE); } } @Autowired IssueEventHandler(
final ConnectionHandler connectionHandler,
final IssueService issueService,
final ProcessEventsHelper eventsHelper
); @Override void processEvents(final List<Event> eventList, final Set<String> dashboardIds); }### Answer:
@Test public void testDeletedEvents() { when(dashboardService.getDashboardWithNames(anyList())).thenReturn(Collections.emptyList()); eventHandler.processEvents(Collections.singletonList(new Event()), Collections.emptySet()); verify(connectionHandler, times(1)).sendEventUpdateMessageToAll(EventType.ISSUE); } |
### Question:
DashboardRepositoryImpl implements DashboardRepositoryCustom { @Override public List<Dashboard> getActiveDashboards() { return getDashboardsNotInStatus(DELETED, TRANSIENT); } @Override List<Dashboard> getActiveAndTransientDashboards(); @Override List<Dashboard> getActiveDashboards(); @Override void saveFile(final InputStream image, final String name); @Override InputStreamResource readFile(final String name); }### Answer:
@Ignore @Test public void transientAndDeletedDashboardsAreNotReturnedTest() { final List<Dashboard> activeDashboards = dashboardRepository.getActiveDashboards(); final List<String> dashboardNames = activeDashboards .stream() .map(Dashboard::getName) .collect(Collectors.toList()); assertTrue(dashboardNames.contains("regularDashboard")); assertTrue(dashboardNames.contains("nullStatusDashboard")); assertEquals(activeDashboards.size(), 2); } |
### Question:
UserMetricsRepositoryImpl implements UserMetricsRepositoryCustom { @Override public List<UserMetric> findAllStartingWithViewId(final List<String> viewIds) { final Aggregation agg = newAggregation( match(getCriteriaExpressionsForUserMetrics(viewIds)) ); final AggregationResults<UserMetric> aggregationResult = mongoTemplate.aggregate(agg, UserMetric.class, UserMetric.class); return aggregationResult.getMappedResults(); } @Override List<UserMetric> findAllStartingWithViewId(final List<String> viewIds); }### Answer:
@Test public void findUserMetricsByViewIdsWithoutResultsTest() { final List<String> viewIds = Collections.singletonList("aaa"); final List<UserMetric> userMetrics = userMetricsRepository.findAllStartingWithViewId(viewIds); assertEquals(Collections.emptyList(), userMetrics); }
@Test public void findUserMetricsByViewIdsTest() { final List<String> viewIds1 = Collections.singletonList("AWS/123456789012"); final List<String> viewIds2 = Collections.singletonList("AWS/123456789012/alb"); final List<String> viewIds3 = Collections.singletonList("AWS/123456789012/apigateway/restapi"); final List<UserMetric> userMetrics1 = userMetricsRepository.findAllStartingWithViewId(viewIds1); final List<UserMetric> userMetrics2 = userMetricsRepository.findAllStartingWithViewId(viewIds2); final List<UserMetric> userMetrics3 = userMetricsRepository.findAllStartingWithViewId(viewIds3); assertEquals(3, userMetrics1.size()); assertEquals(2, userMetrics2.size()); assertEquals(1, userMetrics3.size()); assertTrue(userMetrics1.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/123456789012/alb/alb1")); assertTrue(userMetrics1.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/123456789012/alb/alb2")); assertTrue(userMetrics1.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/123456789012/apigateway/restapi")); assertTrue(userMetrics2.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/123456789012/alb/alb1")); assertTrue(userMetrics2.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/123456789012/alb/alb2")); assertTrue(userMetrics3.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/123456789012/apigateway/restapi")); }
@Test public void findUserMetricsByMultipleViewIdsTest() { final List<String> viewIds = Arrays.asList("AWS/111111111111", "GCP/222222222222"); final List<UserMetric> userMetrics = userMetricsRepository.findAllStartingWithViewId(viewIds); assertEquals(2, userMetrics.size()); assertTrue(userMetrics.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("AWS/111111111111/elb/elb1")); assertTrue(userMetrics.stream().map(UserMetric::getViewId).collect(Collectors.toList()) .contains("GCP/222222222222/elb/elb1")); } |
### Question:
IssueRepositoryImpl implements IssueRepositoryCustom { @Override public List<String> programIncrementBoardFeatures( final List<String> boards, final List<String> programIncrementFeatures ) { final Aggregation agg = newAggregation( match(Criteria .where("parentsKeys").in(programIncrementFeatures) .and("keywords").in(boards) ), unwind("parentsKeys"), group() .addToSet("parentsKeys") .as("features"), project("features") .andExclude("_id") ); final AggregationResults<ProgramIncrementBoardFeatures> aggregationResult = mongoTemplate.aggregate(agg, "issue", ProgramIncrementBoardFeatures.class); return aggregationResult.getUniqueMappedResult() != null ? aggregationResult.getUniqueMappedResult().features : new ArrayList<>(); } @Override double getBacklogEstimateByKeywords(final List<String> boards); @Override SprintStats getSprintStatsByKeywords(final List<String> boards); @Override List<String> programIncrementBoardFeatures(
final List<String> boards,
final List<String> programIncrementFeatures
); @Override ProgramIncrementNamesAggregationResult getProductIncrementFromPiPattern(final Pattern pi); }### Answer:
@Test public void testFeatureAndPIComeFromTeam() { final List<String> boardPIFeatures = issueRepository.programIncrementBoardFeatures( Collections.singletonList("mirrorgate"), Arrays.asList("issue1", "issue2") ); assertEquals(2, boardPIFeatures.size()); } |
### Question:
IssueRepositoryImpl implements IssueRepositoryCustom { @Override public ProgramIncrementNamesAggregationResult getProductIncrementFromPiPattern(final Pattern pi) { final Aggregation agg = newAggregation( match(Criteria .where("type").is(IssueType.FEATURE.getName()) ), project("piNames").andExclude("_id"), unwind("piNames"), match(Criteria .where("piNames").is(pi) ), group().addToSet("piNames").as("piNames") ); final AggregationResults<ProgramIncrementNamesAggregationResult> aggregationResult = mongoTemplate.aggregate(agg, "issue", ProgramIncrementNamesAggregationResult.class); return aggregationResult.getUniqueMappedResult(); } @Override double getBacklogEstimateByKeywords(final List<String> boards); @Override SprintStats getSprintStatsByKeywords(final List<String> boards); @Override List<String> programIncrementBoardFeatures(
final List<String> boards,
final List<String> programIncrementFeatures
); @Override ProgramIncrementNamesAggregationResult getProductIncrementFromPiPattern(final Pattern pi); }### Answer:
@Test public void testAggregationWithResults() { final ProgramIncrementNamesAggregationResult piNames = issueRepository.getProductIncrementFromPiPattern( Pattern.compile("^PI.*$") ); assertEquals(piNames.getPiNames().size(), 5); assertTrue(piNames.getPiNames().contains("PI1")); assertTrue(piNames.getPiNames().contains("PI2")); assertTrue(piNames.getPiNames().contains("PI3")); assertTrue(piNames.getPiNames().contains("PI4")); assertTrue(piNames.getPiNames().contains("PI5")); }
@Test public void testAggregationWithoutResults() { final ProgramIncrementNamesAggregationResult piNames = issueRepository.getProductIncrementFromPiPattern( Pattern.compile("aaa") ); assertNull(piNames); } |
### Question:
TokenCreator { public static MirrorgateAuthenticationToken createHeaderBasedToken(final String headerValue) { GrantedAuthority authority; if (StringUtils.isEmpty(headerValue) || headerValue.contains("COLLECTOR")) { authority = new SimpleGrantedAuthority(SecurityAuthoritiesEnum.COLLECTOR.toString()); } else { if (headerValue.contains("ANONYMOUS")) { authority = new SimpleGrantedAuthority(SecurityAuthoritiesEnum.SCREEN.toString()); } else { authority = new SimpleGrantedAuthority(SecurityAuthoritiesEnum.REGULAR.toString()); } } LOG.info("Role assigned: " + authority.getAuthority()); return new MirrorgateAuthenticationToken(headerValue, Collections.singletonList(authority)); } private TokenCreator(); static MirrorgateAuthenticationToken createHeaderBasedToken(final String headerValue); }### Answer:
@Test public void testScreenUser() { final MirrorgateAuthenticationToken token = TokenCreator.createHeaderBasedToken("[email protected]"); final SimpleGrantedAuthority expectedAuthority = new SimpleGrantedAuthority( SecurityAuthoritiesEnum.REGULAR.toString() ); assertTrue(token.getCredentials().contains(expectedAuthority)); }
@Test public void testEmptyHeader() { final MirrorgateAuthenticationToken token = TokenCreator.createHeaderBasedToken(""); final SimpleGrantedAuthority expectedAuthority = new SimpleGrantedAuthority( SecurityAuthoritiesEnum.COLLECTOR.toString() ); assertTrue(token.getCredentials().contains(expectedAuthority)); }
@Test public void testNullHeader() { final MirrorgateAuthenticationToken token = TokenCreator.createHeaderBasedToken(null); final SimpleGrantedAuthority expectedAuthority = new SimpleGrantedAuthority( SecurityAuthoritiesEnum.COLLECTOR.toString() ); assertTrue(token.getCredentials().contains(expectedAuthority)); }
@Test public void testRegularUser() { final MirrorgateAuthenticationToken token = TokenCreator.createHeaderBasedToken("ANONYMOUS"); final SimpleGrantedAuthority expectedAuthority = new SimpleGrantedAuthority( SecurityAuthoritiesEnum.SCREEN.toString() ); assertTrue(token.getCredentials().contains(expectedAuthority)); }
@Test public void testCollectorUser() { final MirrorgateAuthenticationToken token = TokenCreator.createHeaderBasedToken("COLLECTOR"); final SimpleGrantedAuthority expectedAuthority = new SimpleGrantedAuthority( SecurityAuthoritiesEnum.COLLECTOR.toString() ); assertTrue(token.getCredentials().contains(expectedAuthority)); } |
### Question:
EventScheduler { @Scheduled(fixedDelayString = "${events.scheduler.delay.millis}") void checkEventUpdates() { LOG.debug("Processing events for timestamp {}", schedulerTimestamp); final Set<String> dashboardIds = handler.getDashboardsWithSession(); if (dashboardIds != null) { LOG.debug("Active dashboards {}", dashboardIds.size()); } if (! Objects.requireNonNull(dashboardIds).isEmpty()) { final List<Event> unprocessedEvents = eventService.getEventsSinceTimestamp(schedulerTimestamp); if (! unprocessedEvents.isEmpty()) { unprocessedEvents.stream() .collect(Collectors.groupingBy(Event::getEventType)) .forEach((key, value) -> beanFactory.getBean(key.getValue(), EventHandler.class) .processEvents(value, dashboardIds)); schedulerTimestamp = unprocessedEvents.get(unprocessedEvents.size() - 1).getTimestamp(); LOG.debug("Modified timestamp: {}", schedulerTimestamp); } } } @Autowired EventScheduler(
final EventService eventService,
final ConnectionHandler handler,
final BeanFactory beanFactory
); @PostConstruct void initSchedulerTimestamp(); }### Answer:
@Test public void testSchedulerTimestampIsModified() { when(eventService.getEventsSinceTimestamp(anyLong())) .thenReturn(Arrays.asList(createBuildEvent(), createIssueEvent())); when(eventService.getLastEvent()).thenReturn(null); when(eventsHandler.getDashboardsWithSession()).thenReturn(new HashSet<>(Collections.singletonList("123"))); eventScheduler.checkEventUpdates(); assertTrue(outputCapture.toString().contains("1234567")); } |
### Question:
DataServiceBase implements TableDataService { @Override public List<Map<String, String>> getPageEntries(PaginationCriteria paginationCriteria) throws TableDataException { List<T> data = getData(paginationCriteria); log.debug("Table data retrieved..."); List<Map<String, String>> records = new ArrayList<>(data.size()); try { data.forEach(i -> { Map<String, Object> m = objectMapper.convertValue(i, Map.class); records.add(m.entrySet().stream() .collect(Collectors.toMap(k -> k.getKey(), v -> v.getValue().toString()))); }); log.debug("Data map generated..."); } catch (Exception e) { log.error("Error fetching page entries.", e); throw new TableDataException("", e); } return records; } @Override List<Map<String, String>> getPageEntries(PaginationCriteria paginationCriteria); }### Answer:
@Test void getPageEntries() throws TableDataException { List<Map<String, String>> data = dataService.getPageEntries(null); assertEquals(5, data.size()); assertEquals("Lisa", data.get(0).get("name")); assertEquals("2", data.get(1).get("id")); assertEquals("38", data.get(2).get("age")); } |
### Question:
PingResponseWriter { public void write(PrintWriter writer) { writer.write("pong"); } void write(PrintWriter writer); }### Answer:
@Test public void writeResponse() throws Exception { underTest.write(printWriter); verify(printWriter).write("pong"); } |
### Question:
JmsMessagePropertyExtractor implements MessagePropertyExtractor { @Override public Map<String, Object> extractProperties(Message message) { if (message == null) { throw new IllegalArgumentException("Message cannot be null"); } Map<String, Object> properties = new HashMap<>(); try { for (Enumeration propertyNames = message.getPropertyNames(); propertyNames.hasMoreElements(); ) { extractPropertyFromMessage((String) propertyNames.nextElement(), message, properties); } } catch (JMSException e) { LOGGER.error("Could not read propertyNames from message '%s'", message, e); } return properties; } @Override Map<String, Object> extractProperties(Message message); }### Answer:
@Test public void cannotReadPropertyNamesFromMessage() throws JMSException { when(message.getPropertyNames()).thenThrow(JMSException.class); assertThat(underTest.extractProperties(message), is(emptyMap())); }
@Test public void cannotReadOnePropertyFromMessage() throws JMSException { Vector<String> propertyNames = new Vector<>(Arrays.asList("foo", "one")); when(message.getObjectProperty("foo")).thenThrow(JMSException.class); when(message.getObjectProperty("one")).thenReturn(1); when(message.getPropertyNames()).thenReturn(propertyNames.elements()); Map<String, Object> actual = underTest.extractProperties(message); assertThat(actual, hasEntry("one", 1)); }
@Test public void exceptionIsThrownIfMessageIsNull() { expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage("Message cannot be null"); underTest.extractProperties(null); }
@Test public void messageWithNoProperties() throws JMSException { when(message.getPropertyNames()).thenReturn(emptyEnumeration()); Map<String, Object> properties = underTest.extractProperties(message); assertThat(properties, equalTo(emptyMap())); }
@Test public void messageWithProperties() throws Exception { Enumeration<String> messageProperties = messageProperties(Pair.of("foo", "bar"), Pair.of("one", 1)); when(message.getPropertyNames()).thenReturn(messageProperties); Map<String, Object> actual = underTest.extractProperties(message); assertThat(actual, hasEntry("foo", "bar")); assertThat(actual, hasEntry("one", 1)); } |
### Question:
JmsTemplateBeanDefinitionFactory { public AbstractBeanDefinition create(String connectionFactoryBeanName) { return genericBeanDefinition(JmsTemplate.class) .addConstructorArgReference(connectionFactoryBeanName) .getBeanDefinition(); } AbstractBeanDefinition create(String connectionFactoryBeanName); String createBeanName(String brokerName); static final String JMS_TEMPLATE_BEAN_NAME_PREFIX; }### Answer:
@Test public void createJmsTemplateBeanDefinition() { final AbstractBeanDefinition abstractBeanDefinition = underTest.create("internal-jmsConnectionFactory"); Assert.assertThat(abstractBeanDefinition.getBeanClass(), typeCompatibleWith(JmsTemplate.class)); Assert.assertThat(abstractBeanDefinition.getConstructorArgumentValues().getIndexedArgumentValues().size(), is(1)); Assert.assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(0, ConnectionFactory.class).getValue(), is(equalTo(new RuntimeBeanReference("internal-jmsConnectionFactory")))); } |
### Question:
JmsTemplateBeanDefinitionFactory { public String createBeanName(String brokerName) { return JMS_TEMPLATE_BEAN_NAME_PREFIX + brokerName; } AbstractBeanDefinition create(String connectionFactoryBeanName); String createBeanName(String brokerName); static final String JMS_TEMPLATE_BEAN_NAME_PREFIX; }### Answer:
@Test public void createJmsTemplateBeanName() { assertThat(underTest.createBeanName("internal"), Matchers.is("jmsTemplate-internal")); } |
### Question:
SpringMessageSender implements MessageSender { @Override public void send(FailedMessage failedMessage) { LOGGER.debug("Resending FailedMessage: {}", failedMessage.getFailedMessageId()); jmsTemplate.send( failedMessage .getDestination() .getName() .orElseThrow(destinationMissingFor(failedMessage.getFailedMessageId())), failedMessageCreatorFactory.create(failedMessage) ); } @SuppressWarnings("unused") SpringMessageSender(JmsTemplate jmsTemplate); SpringMessageSender(FailedMessageCreatorFactory failedMessageCreatorFactory,
JmsTemplate jmsTemplate); @Override void send(FailedMessage failedMessage); }### Answer:
@Test public void successfullySendMessage() throws Exception { when(failedMessage.getDestination()).thenReturn(aDestination("some-destination")); underTest.send(failedMessage); verify(jmsTemplate).send("some-destination", failedMessageCreator); }
@Test(expected = DestinationException.class) public void destinationIsMissing() { when(failedMessage.getDestination()).thenReturn(aDestination(null)); underTest.send(failedMessage); } |
### Question:
FailedMessageCreator implements MessageCreator { @Override public Message createMessage(Session session) throws JMSException { TextMessage textMessage = session.createTextMessage(); for (JmsMessageTransformer<TextMessage, FailedMessage> jmsMessageTransformer : jmsMessageTransformers) { jmsMessageTransformer.transform(textMessage, failedMessage); } return textMessage; } FailedMessageCreator(FailedMessage failedMessage); FailedMessageCreator(FailedMessage failedMessage, List<JmsMessageTransformer<TextMessage, FailedMessage>> jmsMessageTransformers); @Override Message createMessage(Session session); }### Answer:
@Test public void createJmsMessage() throws Exception { when(session.createTextMessage()).thenReturn(textMessage); FailedMessageCreator underTest = new FailedMessageCreator(newFailedMessage() .withContent("Hello") .withProperty("foo", "bar") .build() ); assertThat(underTest.createMessage(session), Matchers.is(textMessage)); verify(textMessage).setText("Hello"); verify(textMessage).setObjectProperty("foo", "bar"); } |
### Question:
PropertyMatchesPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return pattern .matcher(getPropertyAsString(failedMessage)) .matches(); } PropertyMatchesPredicate(@JsonProperty("name") String name,
@JsonProperty("regex") String regex); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }### Answer:
@Test public void propertyMatchesPattern() { when(failedMessage.getProperty("foo")).thenReturn("some.property.value"); underTest = new PropertyMatchesPredicate("foo", "^some\\.property.*"); assertThat(underTest.test(failedMessage), is(true)); }
@Test public void propertyDoesNotMatchPattern() { when(failedMessage.getProperty("foo")).thenReturn("some.property.value"); underTest = new PropertyMatchesPredicate("foo", "^some\\.property"); assertThat(underTest.test(failedMessage), is(false)); }
@Test public void propertyValueIsNull() { when(failedMessage.getProperty("foo")).thenReturn(null); underTest = new PropertyMatchesPredicate("foo", "^some\\.property"); assertThat(underTest.test(failedMessage), is(false)); }
@Test public void propertyIsABoolean() { when(failedMessage.getProperty("aBoolean")).thenReturn(true); underTest = new PropertyMatchesPredicate("aBoolean", "true"); assertThat(underTest.test(failedMessage), is(true)); }
@Test public void propertyIsANumber() { when(failedMessage.getProperty("aNumber")).thenReturn(12345); underTest = new PropertyMatchesPredicate("aNumber", "^12345$"); assertThat(underTest.test(failedMessage), is(true)); } |
### Question:
FailedMessageConverter implements DocumentWithIdConverter<FailedMessage, FailedMessageId> { @Override public FailedMessage convertToObject(Document document) { if (document == null) { return null; } return newFailedMessage() .withFailedMessageId(getFailedMessageId(document)) .withJmsMessageId(getJmsMessageId(document)) .withDestination(getDestination(document)) .withSentDateTime(getSentDateTime(document)) .withFailedDateTime(getFailedDateTime(document)) .withContent(getContent(document)) .withStatusHistoryEvent(getStatusHistoryEvent(document)) .withProperties(propertiesMongoMapper.convertToObject(document.getString(PROPERTIES))) .withLabels(getLabels(document)) .build(); } FailedMessageConverter(DocumentConverter<Destination> destinationDocumentConverter,
DocumentConverter<StatusHistoryEvent> statusHistoryEventDocumentConverter,
ObjectConverter<Map<String, Object>, String> propertiesMongoMapper); @Override FailedMessage convertToObject(Document document); StatusHistoryEvent getStatusHistoryEvent(Document document); FailedMessageId getFailedMessageId(Document document); Destination getDestination(Document document); String getContent(Document document); Instant getFailedDateTime(Document document); Instant getSentDateTime(Document document); @Override Document convertFromObject(FailedMessage item); Document convertForUpdate(FailedMessage item); @Override Document createId(FailedMessageId failedMessageId); static final String DESTINATION; static final String SENT_DATE_TIME; static final String FAILED_DATE_TIME; static final String CONTENT; static final String PROPERTIES; static final String STATUS_HISTORY; static final String LABELS; static final String JMS_MESSAGE_ID; }### Answer:
@Test public void mapNullDocumentToFailedMessage() { assertThat(underTest.convertToObject(null), is(nullValue())); } |
### Question:
AndPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return predicates .stream() .allMatch(p -> p.test(failedMessage)); } AndPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description describe(Description description); AndPredicate and(FailedMessagePredicate failedMessagePredicate); @Override String toString(); static AndPredicate and(FailedMessagePredicate lhs, FailedMessagePredicate rhs); }### Answer:
@Test public void resultIsFalseWhen1stPredicateIsTrue2ndPredicteIsFalse() { when(failedMessagePredicate1.test(failedMessage)).thenReturn(true); when(failedMessagePredicate2.test(failedMessage)).thenReturn(false); assertThat(underTest.test(failedMessage), is(false)); verify(failedMessagePredicate1).test(failedMessage); verify(failedMessagePredicate2).test(failedMessage); }
@Test public void resultIsAlwaysFalseWhen1stPredicateIsFalse() { when(failedMessagePredicate1.test(failedMessage)).thenReturn(false); when(failedMessagePredicate2.test(failedMessage)).thenReturn(true); assertThat(underTest.test(failedMessage), is(false)); verify(failedMessagePredicate1).test(failedMessage); verifyZeroInteractions(failedMessagePredicate2); }
@Test public void resultIsTrueWhenAllPredicatesReturnTrue() { when(failedMessagePredicate1.test(failedMessage)).thenReturn(true); when(failedMessagePredicate2.test(failedMessage)).thenReturn(true); assertThat(underTest.test(failedMessage), is(true)); verify(failedMessagePredicate1).test(failedMessage); verify(failedMessagePredicate2).test(failedMessage); } |
### Question:
AndPredicate implements FailedMessagePredicate { public List<FailedMessagePredicate> getPredicates() { return new ArrayList<>(predicates); } AndPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description describe(Description description); AndPredicate and(FailedMessagePredicate failedMessagePredicate); @Override String toString(); static AndPredicate and(FailedMessagePredicate lhs, FailedMessagePredicate rhs); }### Answer:
@Test public void canSerialiseAndDeserialisePredicate() throws IOException { ObjectMapper objectMapper = new JacksonConfiguration().objectMapper(new InjectableValues.Std()); objectMapper.registerSubtypes(BooleanPredicate.class); final AndPredicate underTest = objectMapper.readValue( objectMapper.writeValueAsString(new AndPredicate(singletonList(alwaysTruePredicate))), AndPredicate.class ); assertThat(underTest.getPredicates(), contains(alwaysTruePredicate)); } |
### Question:
AndPredicate implements FailedMessagePredicate { @Override public Description describe(Description description) { Description finalDescription = description.append("( "); final Iterator<FailedMessagePredicate> iterator = predicates.iterator(); while (iterator.hasNext()) { finalDescription = iterator.next().describe(finalDescription); if (iterator.hasNext()) { finalDescription = finalDescription.append(" AND "); } } return finalDescription.append(" )"); } AndPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description describe(Description description); AndPredicate and(FailedMessagePredicate failedMessagePredicate); @Override String toString(); static AndPredicate and(FailedMessagePredicate lhs, FailedMessagePredicate rhs); }### Answer:
@Test public void describeTest() { when(failedMessagePredicate1.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate1")); when(failedMessagePredicate2.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate2")); assertThat(underTest.describe(new StringDescription()).getOutput(), is("( predicate1 AND predicate2 )")); } |
### Question:
AndPredicate implements FailedMessagePredicate { @Override public String toString() { return describe(new StringDescription()).toString(); } AndPredicate(@JsonProperty("predicates") List<FailedMessagePredicate> predicates); @Override boolean test(FailedMessage failedMessage); List<FailedMessagePredicate> getPredicates(); @Override Description describe(Description description); AndPredicate and(FailedMessagePredicate failedMessagePredicate); @Override String toString(); static AndPredicate and(FailedMessagePredicate lhs, FailedMessagePredicate rhs); }### Answer:
@Test public void toStringTest() { when(failedMessagePredicate1.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate1")); when(failedMessagePredicate2.describe(any(StringDescription.class))).thenAnswer(withDescription("predicate2")); assertThat(underTest.toString(), is("( predicate1 AND predicate2 )")); } |
### Question:
PropertyEqualToPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return this.value.equals(failedMessage.getProperty(name)); } PropertyEqualToPredicate(@JsonProperty("name") String name,
@JsonProperty("value") Object value); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }### Answer:
@Test public void propertiesMatch() { when(failedMessage.getProperty("foo")).thenReturn("bar"); assertThat(underTest.test(failedMessage), is(true)); }
@Test public void propertiesDoNotMatch() { when(failedMessage.getProperty("foo")).thenReturn("rab"); assertThat(underTest.test(failedMessage), is(false)); }
@Test public void propertyDoesNotExist() { when(failedMessage.getProperty("foo")).thenReturn(null); assertThat(underTest.test(failedMessage), is(false)); } |
### Question:
MongoStatusHistoryQueryBuilder { public Document currentStatusEqualTo(Status status) { return new Document(STATUS_HISTORY + ".0." + STATUS, status.name()); } Document currentStatusEqualTo(Status status); Document currentStatusNotEqualTo(Status status); Document currentStatusIn(Set<Status> statuses); Document currentStatusIn(Document query, Set<Status> statuses); }### Answer:
@Test public void currentStatusEqualToGivenStatus() { assertThat(underTest.currentStatusEqualTo(FAILED), hasField(STATUS_HISTORY + ".0." + STATUS, equalTo(FAILED.name()))); } |
### Question:
DestinationEqualsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return destination.equals(failedMessage.getDestination().getName()); } DestinationEqualsPredicate(@JsonProperty("destination") Optional<String> destination); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }### Answer:
@Test public void nameOfDestinationMatches() { when(destination.getName()).thenReturn(Optional.of("some-destination")); assertThat(underTest.test(failedMessage), Matchers.is(true)); }
@Test public void nameOfDestinationIsEmpty() { when(destination.getName()).thenReturn(Optional.empty()); assertThat(underTest.test(failedMessage), Matchers.is(false)); }
@Test public void nameOfDestinationIDoesNotMatch() { when(destination.getName()).thenReturn(Optional.of("another-destination")); assertThat(underTest.test(failedMessage), Matchers.is(false)); } |
### Question:
DestinationEqualsPredicate implements FailedMessagePredicate { @Override public Description describe(Description description) { return description.append("destination ").append(destination.map(d -> "= '" + d + "'").orElse("is empty")); } DestinationEqualsPredicate(@JsonProperty("destination") Optional<String> destination); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }### Answer:
@Test public void describeWithAnEmptyDestination() { underTest = new DestinationEqualsPredicate(Optional.empty()); final Description<String> description = underTest.describe(new StringDescription()); assertThat(description.getOutput(), is("destination is empty")); } |
### Question:
PropertyExistsPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return failedMessage.getProperties().containsKey(propertyName); } PropertyExistsPredicate(@JsonProperty("propertyName") String propertyName); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }### Answer:
@Test public void propertyExists() { when(failedMessage.getProperties()).thenReturn(Collections.singletonMap("foo", "bar")); assertThat(underTest.test(failedMessage), is(true)); }
@Test public void propertyDoesNotExist() { when(failedMessage.getProperties()).thenReturn(Collections.emptyMap()); assertThat(underTest.test(failedMessage), is(false)); } |
### Question:
ContentEqualToPredicate implements FailedMessagePredicate { @Override public boolean test(FailedMessage failedMessage) { return content.equals(failedMessage.getContent()); } ContentEqualToPredicate(@JsonProperty("content") String content); @Override boolean test(FailedMessage failedMessage); @Override Description describe(Description description); @Override String toString(); }### Answer:
@Test public void contentInMessageIsNull() { when(failedMessage.getContent()).thenReturn(null); assertThat(underTest.test(failedMessage), is(false)); }
@Test public void contentDoesNotMatch() { when(failedMessage.getContent()).thenReturn("bar"); assertThat(underTest.test(failedMessage), is(false)); }
@Test public void contentMatches() { when(failedMessage.getContent()).thenReturn("foo"); assertThat(underTest.test(failedMessage), is(true)); } |
### Question:
MongoStatusHistoryQueryBuilder { public Document currentStatusIn(Set<Status> statuses) { return currentStatusIn(new Document(), statuses); } Document currentStatusEqualTo(Status status); Document currentStatusNotEqualTo(Status status); Document currentStatusIn(Set<Status> statuses); Document currentStatusIn(Document query, Set<Status> statuses); }### Answer:
@Test public void currentStatusIsOneOfTheGivenStatuses() { assertThat(underTest.currentStatusIn(immutableEnumSet(FAILED, CLASSIFIED)), hasField(STATUS_HISTORY + ".0." + STATUS, hasField(IN, contains(FAILED.name(), CLASSIFIED.name())))); }
@Test public void currentStatusIsOneOfTheGivenStatusesWhenDocumentPassedIn() { Document document = new Document(); DocumentMatcher expectedDocument = hasField(STATUS_HISTORY + ".0." + STATUS, hasField(IN, contains(FAILED.name(), CLASSIFIED.name()))); Document actualDocument = underTest.currentStatusIn(document, immutableEnumSet(FAILED, CLASSIFIED)); assertThat(actualDocument, expectedDocument); assertThat(actualDocument, is(document)); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.