method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
HistoryProvider implements IHistoryProvider { @Override public ArrayList<IRainbowMessage> getModelEventRange(Date startTime, Date endTime) { ArrayList<IRainbowMessage> model; model = (ArrayList<IRainbowMessage>) databaseconn.getModelEventRange( startTime, endTime); return model; } HistoryProvider(IDatabaseConnector databaseCon); HistoryProvider(ISystemViewProvider acmeSystemViewProvider,
ISystemConfiguration systemConfig); @Override IModelInstance<?> getModelState(Date time); @Override ArrayList<IRainbowMessage> getEventRange(Date startTime, Date endTime); @Override ArrayList<IRainbowMessage> getEventRangeByType(String channel,
Date startTime, Date endTime); @Override ArrayList<IRainbowMessage> getModelEventRange(Date startTime,
Date endTime); @Override IRainbowMessage getEvent(Date time); @Override void setSession(String name); @Override ArrayList<String> getSessionList(); String getReadSession(); @Override Date getStartDate(); @Override boolean currentSessionIsWriteSession(); @Override Date getMaxDate(); @Override List<IRainbowMessage> getNumberOfEventsBefore(Date endTime,
int numEvents); @Override void closeDatabaseConnection(); }### Answer:
@Test public void testgetModelEventRange() { List<IRainbowMessage> events = null; Calendar cal1 = Calendar.getInstance(); Date date1 = cal1.getTime(); Calendar cal2 = Calendar.getInstance(); Date date2 = cal2.getTime(); events = hp.getModelEventRange(date1, date2); assertNotNull(events); } |
### Question:
HistoryProvider implements IHistoryProvider { @Override public IRainbowMessage getEvent(Date time) { IRainbowMessage event; event = databaseconn.getEvent(time); return event; } HistoryProvider(IDatabaseConnector databaseCon); HistoryProvider(ISystemViewProvider acmeSystemViewProvider,
ISystemConfiguration systemConfig); @Override IModelInstance<?> getModelState(Date time); @Override ArrayList<IRainbowMessage> getEventRange(Date startTime, Date endTime); @Override ArrayList<IRainbowMessage> getEventRangeByType(String channel,
Date startTime, Date endTime); @Override ArrayList<IRainbowMessage> getModelEventRange(Date startTime,
Date endTime); @Override IRainbowMessage getEvent(Date time); @Override void setSession(String name); @Override ArrayList<String> getSessionList(); String getReadSession(); @Override Date getStartDate(); @Override boolean currentSessionIsWriteSession(); @Override Date getMaxDate(); @Override List<IRainbowMessage> getNumberOfEventsBefore(Date endTime,
int numEvents); @Override void closeDatabaseConnection(); }### Answer:
@Test public void testgetEvent() { IRainbowMessage event = null; Calendar cal = Calendar.getInstance(); Date date = cal.getTime(); event = hp.getEvent(date); assertNotNull(event); } |
### Question:
AcmeModelSerializer { public String serialize(IModelInstance<IAcmeSystem> instance) { String serial = null; try { DataValue value = converter.from_java(instance, null); ByteArrayOutputStream baos = new ByteArrayOutputStream(); encoding.encode(value, new DataOutputStream(baos)); serial = baos.toString(); } catch (ValueConversionException | IOException ex) { Logger.getLogger(AcmeModelSerializer.class.getName()).log(Level.SEVERE, null, ex); } return serial; } AcmeModelSerializer(); String serialize(IModelInstance<IAcmeSystem> instance); IModelInstance<IAcmeSystem> deserialize(String serial); }### Answer:
@Test public void testSerialize() throws IOException, ParsingFailureException { System.out.println("serialize"); StandaloneResource resource = StandaloneResourceProvider.instance().acmeResourceForString( "ZNewsSys.acme"); AcmeSystem sys = resource.getModel().getSystems().iterator().next(); IModelInstance<IAcmeSystem> instance = new AcmeInternalModelInstance(sys, "Acme"); AcmeModelSerializer serializer = new AcmeModelSerializer(); String result = serializer.serialize(instance); IModelInstance<IAcmeSystem> instanceResult = serializer.deserialize(result); assertEquals(instance.getModelName(), instanceResult.getModelName()); assertEquals(instance.getModelType(), instanceResult.getModelType()); assertEquals(instance.getOriginalSource(), instanceResult.getOriginalSource()); String result2 = serializer.serialize(instance); assertEquals(result, result2); } |
### Question:
Optionality { public static boolean is_optional(DataType dt) { Ensure.not_null(dt); return (dt instanceof OptionalDataType); } private Optionality(); static boolean is_optional(DataType dt); static boolean is_optional(DataValue dv); static DataType unoptionalize(DataType dt); static DataType deep_unoptionalize(DataType dt); static DataValue unoptionalize(DataValue dv); static DataValue deep_unoptionalize(DataValue dv); static DataValue optionalize(DataValue v, DataType dt); static boolean is_optional_of(DataType opt, DataType inner); static boolean is_deep_optional_of(DataType opt, DataType inner); }### Answer:
@Test public void detects_optional_data_type() throws Exception { assertTrue(Optionality.is_optional(m_odt)); }
@Test public void detects_non_optional_data_type() throws Exception { assertFalse(Optionality.is_optional(m_dt)); }
@Test public void detects_optional_data_value() throws Exception { assertTrue(Optionality.is_optional(m_odv)); }
@Test public void detects_non_optional_data_value() throws Exception { assertFalse(Optionality.is_optional(m_dv)); } |
### Question:
Optionality { public static DataType unoptionalize(DataType dt) { Ensure.not_null(dt); if (is_optional(dt)) { return ((OptionalDataType) dt).inner_type(); } return dt; } private Optionality(); static boolean is_optional(DataType dt); static boolean is_optional(DataValue dv); static DataType unoptionalize(DataType dt); static DataType deep_unoptionalize(DataType dt); static DataValue unoptionalize(DataValue dv); static DataValue deep_unoptionalize(DataValue dv); static DataValue optionalize(DataValue v, DataType dt); static boolean is_optional_of(DataType opt, DataType inner); static boolean is_deep_optional_of(DataType opt, DataType inner); }### Answer:
@Test public void unoptionalize_optional_data_type() throws Exception { assertEquals(m_dt, Optionality.unoptionalize(m_odt)); }
@Test public void unoptionalize_non_optional_data_type() throws Exception { assertEquals(m_dt, Optionality.unoptionalize(m_dt)); }
@Test public void unoptionalize_deep_optional_data_type() throws Exception { assertEquals(m_odt, Optionality.unoptionalize(m_oodt)); }
@Test public void unoptionalize_non_null_optional_data_value() throws Exception { assertEquals(m_dv, Optionality.unoptionalize(m_odv)); }
@Test public void unoptionalize_non_optional_data_value() throws Exception { assertEquals(m_dv, Optionality.unoptionalize(m_dv)); }
@Test public void unoptionalize_non_null_deep_optional_data_value() throws Exception { assertEquals(m_odv, Optionality.unoptionalize(m_oodv)); assertEquals(m_odvn, Optionality.unoptionalize(m_oodvin)); }
@Test public void unoptionalize_null_optional_data_value() throws Exception { assertNull(Optionality.unoptionalize(m_odvn)); }
@Test public void unoptionalize_null_deep_optional_data_value() throws Exception { assertNull(Optionality.unoptionalize(m_oodvn)); } |
### Question:
Scaffolder { public void scaffold() throws IOException, ScaffoldingException { try { Map<String, Template> mapping = loadMapping(); for (Map.Entry<String, Template> entry : mapping.entrySet()) { String s = entry.getKey(); Template template = entry.getValue(); Path path = baseDirectory.resolve(s); Path parentDirectory = path.getParent(); Files.createDirectories(parentDirectory); writeFile(path, template); } } catch (TemplateException e) { throw new ScaffoldingException("error processing template", e); } } Scaffolder(TemplateSet templateSet, Map<String, Object> configuration); TemplateSet getTemplateSet(); void setTemplateSet(TemplateSet templateSet); Map<String, Object> getConfiguration(); void setConfiguration(Map<String, Object> configuration); void scaffold(); Path getBaseDirectory(); void setBaseDirectory(Path baseDirectory); String getMappingTemplatePath(); void setMappingTemplatePath(String mappingTemplatePath); }### Answer:
@Test public void scaffold() throws Exception { final String DEFAULT_MAPPING_TEMPLATE_PATH = "mapping.yml.ftl"; Map<String, Template> templates = new HashMap<>(); templates.put("example.txt.ftl", configuration.getTemplate("example.txt.ftl")); templates.put(DEFAULT_MAPPING_TEMPLATE_PATH, configuration.getTemplate(DEFAULT_MAPPING_TEMPLATE_PATH)); List<Variable> variables = Collections.singletonList(new Variable("name")); TemplateSet templateSet = new TemplateSet(templates, variables); Map<String, Object> configuration = Collections.singletonMap("name", "world"); Scaffolder scaffolder = new Scaffolder(templateSet, configuration); assertSame(templateSet, scaffolder.getTemplateSet()); assertSame(configuration, scaffolder.getConfiguration()); scaffolder.setTemplateSet(templateSet); scaffolder.setConfiguration(configuration); assertSame(templateSet, scaffolder.getTemplateSet()); assertSame(configuration, scaffolder.getConfiguration()); scaffolder.setBaseDirectory(baseDirectory); assertEquals(baseDirectory, scaffolder.getBaseDirectory()); scaffolder.setMappingTemplatePath(DEFAULT_MAPPING_TEMPLATE_PATH); assertEquals(DEFAULT_MAPPING_TEMPLATE_PATH, scaffolder.getMappingTemplatePath()); scaffolder.scaffold(); assertEquals("Hello, world!\n", new String(Files.readAllBytes(baseDirectory.resolve("hello.world.txt")))); } |
### Question:
Optionality { public static DataType deep_unoptionalize(DataType dt) { Ensure.not_null(dt); if (is_optional(dt)) { return deep_unoptionalize(((OptionalDataType) dt).inner_type()); } return dt; } private Optionality(); static boolean is_optional(DataType dt); static boolean is_optional(DataValue dv); static DataType unoptionalize(DataType dt); static DataType deep_unoptionalize(DataType dt); static DataValue unoptionalize(DataValue dv); static DataValue deep_unoptionalize(DataValue dv); static DataValue optionalize(DataValue v, DataType dt); static boolean is_optional_of(DataType opt, DataType inner); static boolean is_deep_optional_of(DataType opt, DataType inner); }### Answer:
@Test public void deep_unoptionalize_optional_data_type() throws Exception { assertEquals(m_dt, Optionality.deep_unoptionalize(m_odt)); }
@Test public void deep_unoptionalize_non_optional_data_type() throws Exception { assertEquals(m_dt, Optionality.deep_unoptionalize(m_dt)); }
@Test public void deep_unoptionalize_deep_optional_data_type() throws Exception { assertEquals(m_dt, Optionality.deep_unoptionalize(m_oodt)); }
@Test public void deep_unoptionalize_non_null_optional_data_value() throws Exception { assertEquals(m_dv, Optionality.deep_unoptionalize(m_odv)); }
@Test public void deep_unoptionalize_non_optional_data_value() throws Exception { assertEquals(m_dv, Optionality.deep_unoptionalize(m_dv)); }
@Test public void deep_unoptionalize_non_null_deep_optional_data_value() throws Exception { assertEquals(m_dv, Optionality.deep_unoptionalize(m_oodv)); }
@Test public void deep_unoptionalize_null_optional_data_value() throws Exception { assertNull(Optionality.deep_unoptionalize(m_odvn)); }
@Test public void deep_unoptionalize_null_deep_optional_data_value() throws Exception { assertNull(Optionality.deep_unoptionalize(m_oodvn)); assertNull(Optionality.deep_unoptionalize(m_oodvin)); } |
### Question:
OptionParser { public Path handleTemplateOption(CommandLine cmd) { Path templatePath = Paths.get(cmd.getOptionValue("t")); if (!templatePath.toFile().isDirectory()) { throw new IllegalArgumentException("the input template path does not point to a local directory."); } System.out.print("Valid template path: "); System.out.println(cmd.getOptionValue("t")); return templatePath; } OptionParser(); Options getOptions(); Path handleTemplateOption(CommandLine cmd); Path handleConfigOption(CommandLine cmd); }### Answer:
@Test public void handleTemplate() { OptionParser optionParser = new OptionParser(); Path dir = optionParser.handleTemplateOption(cmd); assertEquals(templateDir.toString(), dir.toString()); } |
### Question:
Optionality { public static DataValue optionalize(DataValue v, DataType dt) { Ensure.not_null(dt); if (!(dt instanceof OptionalDataType)) { Ensure.not_null(v); return v; } if (v != null) { v = unoptionalize(v); } OptionalDataType odt = (OptionalDataType) dt; DataType inner_type = odt.inner_type(); if (v != null && inner_type instanceof OptionalDataType) { v = optionalize(v, inner_type); } return odt.make(v); } private Optionality(); static boolean is_optional(DataType dt); static boolean is_optional(DataValue dv); static DataType unoptionalize(DataType dt); static DataType deep_unoptionalize(DataType dt); static DataValue unoptionalize(DataValue dv); static DataValue deep_unoptionalize(DataValue dv); static DataValue optionalize(DataValue v, DataType dt); static boolean is_optional_of(DataType opt, DataType inner); static boolean is_deep_optional_of(DataType opt, DataType inner); }### Answer:
@Test public void optionalize_non_null_to_normal_data_type() throws Exception { assertEquals(m_dv, Optionality.optionalize(m_dv, m_dt)); }
@Test public void optionalize_non_null_to_optional_data_type() throws Exception { assertEquals(m_odv, Optionality.optionalize(m_dv, m_odt)); }
@Test public void optionalize_non_null_to_deep_optional_data_type() throws Exception { assertEquals(m_oodv, Optionality.optionalize(m_dv, m_oodt)); }
@Test public void optionalize_null_to_optional_data_type() throws Exception { assertEquals(m_odvn, Optionality.optionalize(null, m_odt)); }
@Test public void optionalize_null_to_deep_optional_data_type() throws Exception { assertEquals(m_oodvn, Optionality.optionalize(null, m_oodt)); }
@Test public void optionalize_optional_non_null_value_to_optional_data_type() throws Exception { assertEquals(m_odv, Optionality.optionalize(m_odv, m_odt)); }
@Test public void optionalize_optional_non_null_value_to_deep_optional_data_type() throws Exception { assertEquals(m_oodv, Optionality.optionalize(m_odv, m_oodt)); }
@Test public void optionalize_optional_null_value_to_optional_data_type() throws Exception { assertEquals(m_odvn, Optionality.optionalize(m_odvn, m_odt)); }
@Test public void optionalize_optional_null_value_to_deep_optional_data_type() throws Exception { assertEquals(m_oodvn, Optionality.optionalize(m_odvn, m_oodt)); }
@Test public void optionalize_deep_optional_non_null_value_to_deep_optional() throws Exception { assertEquals(m_oodv, Optionality.optionalize(m_oodv, m_oodt)); }
@Test public void optionalize_deep_optional_null_value_to_deep_optional() throws Exception { assertEquals(m_oodvn, Optionality.optionalize(m_oodvn, m_oodt)); } |
### Question:
OptionParser { public Path handleConfigOption(CommandLine cmd) { Path configPath = Paths.get(cmd.getOptionValue("c")); if (!configPath.toFile().isFile()) { throw new IllegalArgumentException("the input configuration path does not point to a local file."); } System.out.print("Valid config path: "); System.out.println(cmd.getOptionValue("c")); return configPath; } OptionParser(); Options getOptions(); Path handleTemplateOption(CommandLine cmd); Path handleConfigOption(CommandLine cmd); }### Answer:
@Test public void handleConfig() { OptionParser optionParser = new OptionParser(); Path file = optionParser.handleConfigOption(cmd); assertEquals(configFile.toString(), file.toString()); } |
### Question:
FileTemplateSetLoader extends TemplateSetLoader { @Override protected Template loadTemplate(String path) throws IOException { return configuration.getTemplate(path); } FileTemplateSetLoader(File root); @Override TemplateSet load(); File getRoot(); }### Answer:
@Test public void loadTemplate() throws Exception { TemplateSetLoader loader = new FileTemplateSetLoader(tempPath.toFile()); Template template = loader.loadTemplate("simple/simple.txt.ftl"); StringWriter writer = new StringWriter(); template.process(Collections.singletonMap("name", "world"), writer); writer.close(); assertEquals("Hello, world!" + System.lineSeparator(), writer.toString()); } |
### Question:
ManagedBasicDataSource extends BasicDataSource { public String getMBeanName() { return mBeanName; } ManagedBasicDataSource(); ManagedBasicDataSource(String mBeanName); ManagedBasicDataSource(MBeanServer mBeanServer, String mBeanName); String getMBeanName(); @Managed(description = "The current number of active connections that have been allocated from this data source.") synchronized int getNumActive(); @Managed(description = "The current number of idle connections that are waiting to be allocated from this data source.") synchronized int getNumIdle(); @Managed(description = "The maximum number of active connections that can be allocated at the same time.") synchronized int getMaxActive(); @Managed(description = "Set the maximum number of active connections that can be allocated at the same time. Use a negative value for no limit.") synchronized void setMaxActive(int maxActive); @Managed(description = "The maximum number of connections that can remain idle in the pool.") synchronized int getMaxIdle(); @Managed(description = "Set the maximum number of connections that can remain idle in the pool.") synchronized void setMaxIdle(int maxIdle); @Managed(description = "The minimum number of idle connections in the pool.") synchronized int getMinIdle(); @Managed(description = "The minimum number of idle connections in the pool.") synchronized void setMinIdle(int minIdle); @Managed(description = "The maximum number of milliseconds that the pool will wait for a connection to be returned before throwing an exception.") synchronized long getMaxWait(); @Managed(description = "Set the maxWait property. Use -1 to make the pool wait indefinitely.") synchronized void setMaxWait(long maxWait); @Managed synchronized String getUrl(); @Managed String getUsername(); static final String DEFAULT_MBEAN_NAME; }### Answer:
@Test public void testMBeanRegistered() throws Exception { final ManagedBasicDataSource testDataSource = new ManagedBasicDataSource(); assertTrue(getMBeanServerConnection().isRegistered(new ObjectName(testDataSource.getMBeanName()))); }
@Test public void testMBeanRegisteredThroughFactory() throws Exception { final ManagedBasicDataSource testDataSource = (ManagedBasicDataSource) ManagedBasicDataSourceFactory.createDataSource(new Properties()); assertTrue(getMBeanServerConnection().isRegistered(new ObjectName(testDataSource.getMBeanName()))); }
@Test(dataProvider = "testAttributeExistsProvider") public void testAttributeExists(String attributeName) throws Exception { final ManagedBasicDataSource testDataSource = (ManagedBasicDataSource) ManagedBasicDataSourceFactory.createDataSource(new Properties()); getMBeanServerConnection().getAttribute(new ObjectName(testDataSource.getMBeanName()), attributeName); }
@Test(dataProvider = "testConfigurableAttributeProvider") public void testConfigurableAttribute(String attributeProperty, Object attributePropertyValue, String attributeName, String attributeGetterName) throws Exception { final Properties testDataSourceProperties = new Properties(); testDataSourceProperties.put(attributeProperty, String.valueOf(attributePropertyValue)); final ManagedBasicDataSource testDataSource = (ManagedBasicDataSource) ManagedBasicDataSourceFactory.createDataSource(testDataSourceProperties); final Object attributeValue = getMBeanServerConnection().getAttribute(new ObjectName(testDataSource.getMBeanName()), attributeName); assertTrue((ManagedBasicDataSource.class.getMethod(attributeGetterName).invoke(testDataSource)).equals(attributeValue)); } |
### Question:
ManagedBasicDataSource extends BasicDataSource { public String getMBeanName() { return mBeanName; } ManagedBasicDataSource(); ManagedBasicDataSource(String mBeanName); ManagedBasicDataSource(MBeanServer mBeanServer, String mBeanName); String getMBeanName(); @Override boolean isWrapperFor(Class<?> iface); @Override T unwrap(Class<T> iface); @Managed(description = "The current number of active connections that have been allocated from this data source.") synchronized int getNumActive(); @Managed(description = "The current number of idle connections that are waiting to be allocated from this data source.") synchronized int getNumIdle(); @Managed(description = "The maximum number of active connections that can be allocated at the same time.") synchronized int getMaxActive(); @Managed(description = "Set the maximum number of active connections that can be allocated at the same time. Use a negative value for no limit.") synchronized void setMaxActive(int maxActive); @Managed(description = "The maximum number of connections that can remain idle in the pool.") synchronized int getMaxIdle(); @Managed(description = "Set the maximum number of connections that can remain idle in the pool.") synchronized void setMaxIdle(int maxIdle); @Managed(description = "The minimum number of idle connections in the pool.") synchronized int getMinIdle(); @Managed(description = "The minimum number of idle connections in the pool.") synchronized void setMinIdle(int minIdle); @Managed(description = "The maximum number of milliseconds that the pool will wait for a connection to be returned before throwing an exception.") synchronized long getMaxWait(); @Managed(description = "Set the maxWait property. Use -1 to make the pool wait indefinitely.") synchronized void setMaxWait(long maxWait); @Managed synchronized String getUrl(); @Managed String getUsername(); static final String DEFAULT_MBEAN_NAME; }### Answer:
@Test public void testMBeanRegistered() throws Exception { final ManagedBasicDataSource testDataSource = new ManagedBasicDataSource(); assertTrue(getMBeanServerConnection().isRegistered(new ObjectName(testDataSource.getMBeanName()))); }
@Test public void testMBeanRegisteredThroughFactory() throws Exception { final ManagedBasicDataSource testDataSource = (ManagedBasicDataSource) ManagedBasicDataSourceFactory.createDataSource(new Properties()); assertTrue(getMBeanServerConnection().isRegistered(new ObjectName(testDataSource.getMBeanName()))); }
@Test(dataProvider = "testAttributeExistsProvider") public void testAttributeExists(String attributeName) throws Exception { final ManagedBasicDataSource testDataSource = (ManagedBasicDataSource) ManagedBasicDataSourceFactory.createDataSource(new Properties()); getMBeanServerConnection().getAttribute(new ObjectName(testDataSource.getMBeanName()), attributeName); }
@Test(dataProvider = "testConfigurableAttributeProvider") public void testConfigurableAttribute(String attributeProperty, Object attributePropertyValue, String attributeName, String attributeGetterName) throws Exception { final Properties testDataSourceProperties = new Properties(); testDataSourceProperties.put(attributeProperty, String.valueOf(attributePropertyValue)); final ManagedBasicDataSource testDataSource = (ManagedBasicDataSource) ManagedBasicDataSourceFactory.createDataSource(testDataSourceProperties); final Object attributeValue = getMBeanServerConnection().getAttribute(new ObjectName(testDataSource.getMBeanName()), attributeName); assertTrue((ManagedBasicDataSource.class.getMethod(attributeGetterName).invoke(testDataSource)).equals(attributeValue)); } |
### Question:
RequestReader { public Request read(InputStream in) throws IOException { String header = null; String body = null; byte[] headerBytes = new byte[headerLength]; int n = in.read(headerBytes); if (n > 0) { header = new String(headerBytes, encoding); log.debug("header: #{}# ", header); int length = Integer.parseInt(header.substring(headerBodyLengthBeginIndex, headerBodyLengthEndIndex)); log.debug("length: {}", length); byte[] bodyBytes = new byte[length]; in.read(bodyBytes); body = new String(bodyBytes, encoding); log.debug("body: #{}#", body); } log.info("request: #{}#", header + body); return new Request(header, body); } Request read(InputStream in); }### Answer:
@Test public void testRead() throws Exception { String body = "123ABC"; String header = rightPad("", headerBodyLengthBeginIndex) + leftPad(String.valueOf(body.length()), headerBodyLengthEndIndex - headerBodyLengthBeginIndex, "0") + rightPad("", headerLength - headerBodyLengthEndIndex); byte[] buffer = new byte[header.length() + body.length()]; System.arraycopy(header.getBytes(encoding), 0, buffer, 0, headerLength); System.arraycopy(body.getBytes(encoding), 0, buffer, headerLength, body.length()); ByteArrayInputStream in = new ByteArrayInputStream(buffer); RequestReader.Request request = requestReader.read(in); assertEquals(header, request.getHeader()); assertEquals(body, request.getBody()); } |
### Question:
SimulatorAdapter { public Object service(String declaringClassCanonicalName, String methodName, Object[] arguments, String rootPath, boolean useRootRelativePath) throws Exception { log.debug("declaringClassCanonicalName: {}, methodName: {}, arguments: {}, rootPath: {}, useRootRelativePath: {}", new Object[]{declaringClassCanonicalName, methodName, arguments, rootPath, useRootRelativePath}); String rootRelativePath = useRootRelativePath ? getRootRelativePath(declaringClassCanonicalName, methodName) : ""; String simulatorRequest = createRequest(arguments); Optional<SimulatorResponse> simulatorResponseOptional = simulator.service(rootPath, rootRelativePath, simulatorRequest, CONTENT_TYPE); SimulatorResponse simulatorResponse = simulatorResponseOptional.get(); Object response = createResponse(simulatorResponse.getResponse()); if (response instanceof Throwable) { throw (Exception) response; } return response; } Object service(String declaringClassCanonicalName, String methodName, Object[] arguments, String rootPath, boolean useRootRelativePath); }### Answer:
@Test public void testService() throws URISyntaxException { String declaringClassCanonicalName = Foo.class.getCanonicalName(); String methodName = "sayHello"; Object[] arguments = new String[] {"Hello from " + getClass().getName()}; String rootPath = Paths.get(getClass().getResource("/").toURI()).toString() + File.separator; boolean useRootRelativePath = true; try { String msg = (String) simulatorAdapter.service(declaringClassCanonicalName, methodName, arguments, rootPath, useRootRelativePath); assertEquals("Hello " + getClass().getName() + " from SimulatorAdapter", msg); } catch (Exception e) { fail(e.getMessage()); } } |
### Question:
JsonHandler extends AbstractHandler { private void escape(StringBuilder sb, JsonNode node, String name) { if (node.isArray()) { sb.append("\\["); Iterator<JsonNode> iterator = node.iterator(); int n = 0; while (iterator.hasNext()) { if (n > 0) { sb.append(","); } n++; escape(sb, iterator.next(), null); } sb.append("\\]"); } else if (node.isObject()) { sb.append("\\{"); Iterator<Entry<String, JsonNode>> fields = node.getFields(); int n = 0; while (fields.hasNext()) { if (n > 0) { sb.append(","); } n++; Entry<String, JsonNode> field = fields.next(); sb.append("\"").append(field.getKey()).append("\":"); escape(sb, field.getValue(), field.getKey()); } sb.append("\\}"); } else { sb.append(node.toString()); } } JsonHandler(); String escape(String request, boolean isCandidate); }### Answer:
@Test public void testEscape() { String jsonRequest = "{\"firstName\": \"John\",\"lastName\": \"Smith\",\"isAlive\": true,\"age\": 27,\"address\": {\"streetAddress\": \"21 2nd Street\",\"city\": \"New York\",\"state\": \"NY\",\"postalCode\": \"10021-3100\"},\"phoneNumbers\": [ { \"type\": \"home\", \"number\": \"212 555-1234\" }, { \"type\": \"office\", \"number\": \"646 555-4567\" }, { \"type\": \"mobile\", \"number\": \"123 456-7890\" } ],\"children\": [],\"spouse\": null}"; assertEquals("hello", jsonHandler.escape("hello", true)); assertEquals("\\{\"responseControl\":\\{\"profile\":\\{\"profileType\":\"ANONYMOUS_USER\"\\}\\}\\}", jsonHandler.escape("{\"responseControl\":{\"profile\":{\"profileType\":\"ANONYMOUS_USER\"}}}", true)); assertEquals("\\[\"Ford\",\"BMW\",\"Fiat\"\\]", jsonHandler.escape("[ \"Ford\", \"BMW\", \"Fiat\" ]", true)); assertEquals("\\[\\{\"id\":\".*\",\"name\":\"Privatkon[a-z]{2}\",\"balance\":34251.15766987801\\}\\]", jsonHandler.escape("[{\"id\":\".*\",\"name\":\"Privatkon[a-z]{2}\",\"balance\":34251.15766987801}]", true)); assertEquals("\\{\"firstName\":\"John\",\"lastName\":\"Smith\",\"isAlive\":true,\"age\":27,\"address\":\\{\"streetAddress\":\"21 2nd Street\",\"city\":\"New York\",\"state\":\"NY\",\"postalCode\":\"10021-3100\"\\},\"phoneNumbers\":\\[\\{\"type\":\"home\",\"number\":\"212 555-1234\"\\},\\{\"type\":\"office\",\"number\":\"646 555-4567\"\\},\\{\"type\":\"mobile\",\"number\":\"123 456-7890\"\\}\\],\"children\":\\[\\],\"spouse\":null\\}", jsonHandler.escape(jsonRequest, true)); } |
### Question:
URIMapper { public String map(String uri) { for (Mapping mapping : mappings) { Matcher matcher = mapping.from.matcher(uri); if (matcher.matches()) { String result = mapping.to; log.debug("uri: {}, mapping to: {}", uri, result); for (int i = 1; i <= matcher.groupCount(); i++) { log.debug("group {}: {}", i, matcher.group(i)); result = result.replaceAll("\\$\\{" + i + "\\}", matcher.group(i)); } log.debug("result: {}", result); return result; } } return null; } @Inject URIMapper(@Named("uri-mappings") File mappingsFile); String map(String uri); }### Answer:
@Test public void testApi() { try { String expected = "http: String actual = null; actual = uriMapper.map("api/account"); Assert.assertEquals(expected, actual); } catch (Exception e) { fail(e.getMessage()); } }
@Test public void testDn() { try { String uri = "x/y/z"; String expected = "http: String actual = uriMapper.map(uri); Assert.assertEquals(expected, actual); } catch (Exception e) { fail(e.getMessage()); } } |
### Question:
Services { public static Services getDefault() { return INSTANCE; } Services(Require require, Global global, Worker worker); static Services getDefault(); void postInit(Algorithms newAlgorithms); BigInteger factorial(int value); }### Answer:
@Test public void testRubyFactorial() { String n = Services.getDefault().algorithms.ruby(3); assertEquals("Factorial of 3", "6", n); }
@Test public void testJavaScriptFactorial() { Number n = Services.getDefault().algorithms.js(3); assertEquals("Factorial of 3", 6, n.intValue()); }
@Test public void testRLanguageFactorial() { Number n = Services.getDefault().algorithms.r(3); assertEquals("Factorial of 3", 6, n.intValue()); } |
### Question:
RxGoldfingerImpl implements RxGoldfinger { @NonNull @Override public Observable<Goldfinger.Result> authenticate(@NonNull final Goldfinger.PromptParams params) { return Observable.create(new ObservableOnSubscribe<Goldfinger.Result>() { @Override public void subscribe(ObservableEmitter<Goldfinger.Result> observableEmitter) { callback = new RxGoldfingerCallback(observableEmitter); goldfinger.authenticate(params, callback); } }); } RxGoldfingerImpl(@NonNull Goldfinger goldfinger); @NonNull @Override Observable<Goldfinger.Result> authenticate(@NonNull final Goldfinger.PromptParams params); @Override boolean canAuthenticate(); @Override void cancel(); @Override Observable<Goldfinger.Result> decrypt(
@NonNull final Goldfinger.PromptParams params,
@NonNull final String key,
@NonNull final String value
); @Override Observable<Goldfinger.Result> encrypt(
@NonNull final Goldfinger.PromptParams params,
@NonNull final String key,
@NonNull final String value
); @Override boolean hasEnrolledFingerprint(); @Override boolean hasFingerprintHardware(); }### Answer:
@Test public void authenticate_delegatedOnSubscribe() { Goldfinger.PromptParams params = params(); rxGoldfinger.authenticate(params).subscribe(observer); verify(goldfinger).authenticate(eq(params), any(Goldfinger.Callback.class)); }
@Test public void authenticate_notDelegated() { Goldfinger.PromptParams params = params(); rxGoldfinger.authenticate(params); verify(goldfinger, never()).authenticate(eq(params), any(Goldfinger.Callback.class)); } |
### Question:
ValidateUtils { @NonNull static List<String> validatePromptParams(@NonNull Mode mode, @NonNull Goldfinger.PromptParams params) { List<String> errors = new ArrayList<>(); if (!(params.dialogOwner() instanceof Fragment) && !(params.dialogOwner() instanceof FragmentActivity)) { errors.add("DialogOwner must be of instance Fragment or FragmentActivity"); } if (StringUtils.isBlankOrNull(params.title())) { errors.add("Title is required!"); } if (!params.deviceCredentialsAllowed() && StringUtils.isBlankOrNull(params.negativeButtonText())) { errors.add("NegativeButtonText is required!"); } if (params.deviceCredentialsAllowed() && mode != Mode.AUTHENTICATION) { errors.add("DeviceCredentials are allowed only for Goldfinger#authenticate method."); } return errors; } private ValidateUtils(); }### Answer:
@Test public void auth_valid_missingOptionalParams() { Goldfinger.PromptParams params = new Goldfinger.PromptParams.Builder(activity) .title(TITLE) .negativeButtonText(NEGATIVE_BUTTON_TEXT) .build(); assertTrue(ValidateUtils.validatePromptParams(Mode.AUTHENTICATION, params).isEmpty()); }
@Test public void auth_valid_negativeTextIgnoredIfDeviceCredentialsTrue() { Goldfinger.PromptParams params = new Goldfinger.PromptParams.Builder(activity) .title(TITLE) .deviceCredentialsAllowed(true) .build(); assertTrue(ValidateUtils.validatePromptParams(Mode.AUTHENTICATION, params).isEmpty()); }
@Test public void decrypt_invalid_withDeviceCredentialsTrue() { Goldfinger.PromptParams params = new Goldfinger.PromptParams.Builder(activity) .title(TITLE) .deviceCredentialsAllowed(true) .build(); assertEquals(1, ValidateUtils.validatePromptParams(Mode.DECRYPTION, params).size()); }
@Test public void encrypt_invalid_withDeviceCredentialsTrue() { Goldfinger.PromptParams params = new Goldfinger.PromptParams.Builder(activity) .title(TITLE) .deviceCredentialsAllowed(true) .build(); assertEquals(1, ValidateUtils.validatePromptParams(Mode.ENCRYPTION, params).size()); }
@Test public void auth_invalid_emptyTitle() { Goldfinger.PromptParams params = new Goldfinger.PromptParams.Builder(activity) .negativeButtonText(NEGATIVE_BUTTON_TEXT) .description(DESCRIPTION) .subtitle(SUBTITLE) .deviceCredentialsAllowed(true) .confirmationRequired(true) .build(); assertEquals(1, ValidateUtils.validatePromptParams(Mode.AUTHENTICATION, params).size()); }
@Test public void auth_invalid_negativeTextRequired() { Goldfinger.PromptParams params = new Goldfinger.PromptParams.Builder(activity) .title(TITLE) .build(); assertEquals(1, ValidateUtils.validatePromptParams(Mode.AUTHENTICATION, params).size()); }
@Test public void auth_valid() { Goldfinger.PromptParams params = new Goldfinger.PromptParams.Builder(activity) .title(TITLE) .negativeButtonText(NEGATIVE_BUTTON_TEXT) .description(DESCRIPTION) .subtitle(SUBTITLE) .deviceCredentialsAllowed(true) .confirmationRequired(true) .build(); assertTrue(ValidateUtils.validatePromptParams(Mode.AUTHENTICATION, params).isEmpty()); } |
### Question:
ValidateUtils { @NonNull static List<String> validateCipherParams(@NonNull Mode mode, @Nullable String key, @Nullable String value) { List<String> errors = new ArrayList<>(); if (mode != Mode.AUTHENTICATION) { if (StringUtils.isBlankOrNull(key)) { errors.add("Key is required if encryption or decryption is used!"); } if (StringUtils.isBlankOrNull(value)) { errors.add("Value is required if encryption or decryption is used!"); } } return errors; } private ValidateUtils(); }### Answer:
@Test public void decrypt_invalid_emptyKey() { assertEquals(1, ValidateUtils.validateCipherParams(Mode.DECRYPTION, "", VALUE).size()); }
@Test public void decrypt_invalid_emptyValue() { assertEquals(1, ValidateUtils.validateCipherParams(Mode.DECRYPTION, KEY, "").size()); }
@Test public void decrypt_valid() { assertTrue(ValidateUtils.validateCipherParams(Mode.DECRYPTION, KEY, VALUE).isEmpty()); }
@Test public void encrypt_invalid_emptyKey() { assertEquals(1, ValidateUtils.validateCipherParams(Mode.ENCRYPTION, "", VALUE).size()); }
@Test public void encrypt_invalid_emptyValue() { assertEquals(1, ValidateUtils.validateCipherParams(Mode.ENCRYPTION, KEY, "").size()); }
@Test public void encrypt_valid() { assertTrue(ValidateUtils.validateCipherParams(Mode.ENCRYPTION, KEY, VALUE).isEmpty()); } |
### Question:
RxGoldfingerImpl implements RxGoldfinger { @Override public void cancel() { if (callback != null) { callback.cancel(); } goldfinger.cancel(); } RxGoldfingerImpl(@NonNull Goldfinger goldfinger); @NonNull @Override Observable<Goldfinger.Result> authenticate(@NonNull final Goldfinger.PromptParams params); @Override boolean canAuthenticate(); @Override void cancel(); @Override Observable<Goldfinger.Result> decrypt(
@NonNull final Goldfinger.PromptParams params,
@NonNull final String key,
@NonNull final String value
); @Override Observable<Goldfinger.Result> encrypt(
@NonNull final Goldfinger.PromptParams params,
@NonNull final String key,
@NonNull final String value
); @Override boolean hasEnrolledFingerprint(); @Override boolean hasFingerprintHardware(); }### Answer:
@Test public void cancel_delegated() { rxGoldfinger.cancel(); verify(goldfinger).cancel(); } |
### Question:
RxGoldfingerImpl implements RxGoldfinger { @Override public Observable<Goldfinger.Result> decrypt( @NonNull final Goldfinger.PromptParams params, @NonNull final String key, @NonNull final String value ) { return Observable.create(new ObservableOnSubscribe<Goldfinger.Result>() { @Override public void subscribe(ObservableEmitter<Goldfinger.Result> observableEmitter) { callback = new RxGoldfingerCallback(observableEmitter); goldfinger.decrypt(params, key, value, callback); } }); } RxGoldfingerImpl(@NonNull Goldfinger goldfinger); @NonNull @Override Observable<Goldfinger.Result> authenticate(@NonNull final Goldfinger.PromptParams params); @Override boolean canAuthenticate(); @Override void cancel(); @Override Observable<Goldfinger.Result> decrypt(
@NonNull final Goldfinger.PromptParams params,
@NonNull final String key,
@NonNull final String value
); @Override Observable<Goldfinger.Result> encrypt(
@NonNull final Goldfinger.PromptParams params,
@NonNull final String key,
@NonNull final String value
); @Override boolean hasEnrolledFingerprint(); @Override boolean hasFingerprintHardware(); }### Answer:
@Test public void decrypt_delegatedOnSubscribe() { Goldfinger.PromptParams params = params(); rxGoldfinger.decrypt(params, KEY, VALUE).subscribe(observer); verify(goldfinger).decrypt(eq(params), eq(KEY), eq(VALUE), any(Goldfinger.Callback.class)); }
@Test public void decrypt_notDelegated() { Goldfinger.PromptParams params = params(); rxGoldfinger.decrypt(params, KEY, VALUE); verify(goldfinger, never()).decrypt(eq(params), eq(KEY), eq(VALUE), any(Goldfinger.Callback.class)); } |
### Question:
RxGoldfingerImpl implements RxGoldfinger { @Override public Observable<Goldfinger.Result> encrypt( @NonNull final Goldfinger.PromptParams params, @NonNull final String key, @NonNull final String value ) { return Observable.create(new ObservableOnSubscribe<Goldfinger.Result>() { @Override public void subscribe(ObservableEmitter<Goldfinger.Result> observableEmitter) { callback = new RxGoldfingerCallback(observableEmitter); goldfinger.encrypt(params, key, value, callback); } }); } RxGoldfingerImpl(@NonNull Goldfinger goldfinger); @NonNull @Override Observable<Goldfinger.Result> authenticate(@NonNull final Goldfinger.PromptParams params); @Override boolean canAuthenticate(); @Override void cancel(); @Override Observable<Goldfinger.Result> decrypt(
@NonNull final Goldfinger.PromptParams params,
@NonNull final String key,
@NonNull final String value
); @Override Observable<Goldfinger.Result> encrypt(
@NonNull final Goldfinger.PromptParams params,
@NonNull final String key,
@NonNull final String value
); @Override boolean hasEnrolledFingerprint(); @Override boolean hasFingerprintHardware(); }### Answer:
@Test public void encrypt_delegatedOnSubscribe() { Goldfinger.PromptParams params = params(); rxGoldfinger.encrypt(params, KEY, VALUE).subscribe(observer); verify(goldfinger).encrypt(eq(params), eq(KEY), eq(VALUE), any(Goldfinger.Callback.class)); }
@Test public void encrypt_notDelegated() { Goldfinger.PromptParams params = params(); rxGoldfinger.encrypt(params, KEY, VALUE); verify(goldfinger, never()).encrypt(eq(params), eq(KEY), eq(VALUE), any(Goldfinger.Callback.class)); } |
### Question:
RedisUtil { public Set<String> getKeys(String pattern) { Map<String, JedisPool> clusterNodes = jedisCluster.getClusterNodes(); TreeSet<String> keys = new TreeSet<String>(); for (String k : clusterNodes.keySet()) { logger.debug("Getting keys from: {}", k); JedisPool jp = clusterNodes.get(k); Jedis connection = jp.getResource(); try { int cursor = 0; do { ScanResult<String> scanResult = connection.scan("" + cursor, new ScanParams().match(pattern)); if (scanResult.getResult().size() > 0) { for (String key : scanResult.getResult()) { keys.add(key); } } cursor = Integer.valueOf(new String(scanResult.getCursorAsBytes())); } while (cursor > 0); } catch (Exception e) { logger.error("Getting keys error: {}", e); } finally { logger.debug("Connection closed."); if (connection != null) { connection.close(); } } } logger.debug("------------->keys=" + keys.toString()); return keys; } Set<String> getKeys(String pattern); static Set<Long> convertStringSet2LongSet(Set<String> strSet); static int randomSuperTinyExpireSecs(); static int randomTinyExpireSecs(); static int randomSmallExpireSecs(); static int randomMediumExpireSecs(); static int randomLargeExpireSecs(); }### Answer:
@Test public void getKeys(){ System.out.print("---------------"+redisUtil); Set<String> set =redisUtil.getKeys("thoth:spirit:*"); System.out.print("---------------"); for (String str:set){ System.out.print("--------str:"+str); } } |
### Question:
PhotoRepository implements PhotoDataSource { @Override public void getPhotos(@NonNull LoadPhotosCallback callback) { if (!cachedPhotos.isEmpty() && !isCacheDirty) { callback.onPhotosLoaded(new ArrayList<>(cachedPhotos.values())); return; } if (isCacheDirty) { getPhotosFromRemoteDataSource(callback); } else { photoLocalDataSource.getPhotos(new LoadPhotosCallback() { @Override public void onPhotosLoaded(List<Photo> photos) { refreshCache(photos); callback.onPhotosLoaded(new ArrayList<>(cachedPhotos.values())); } @Override public void onPhotosNotAvailable() { getPhotosFromRemoteDataSource(callback); } }); } } PhotoRepository(@NonNull PhotoDataSource photoRemoteDataSource,
@NonNull PhotoDataSource photoLocalDataSource); @Override void getPhotos(@NonNull LoadPhotosCallback callback); @Override void getPhoto(int photoId, @NonNull LoadPhotoCallback callback); @Override void savePhoto(@NonNull Photo photo); @Override void deletePhoto(int photoId); @Override void deleteAllPhotos(); @Override void refreshPhotos(); }### Answer:
@Test public void getPhotos_shouldCacheAfterFirstRemoteCall() { repository.getPhotos(loadPhotosCallback); verify(localDataSource, times(1)).getPhotos(photosCallbackCaptor.capture()); photosCallbackCaptor.getValue().onPhotosNotAvailable(); verify(remoteDataSource, times(1)).getPhotos(photosCallbackCaptor.capture()); photosCallbackCaptor.getValue().onPhotosLoaded(PHOTOS); assertThat(repository.cachedPhotos.size(), is(3)); repository.getPhotos(loadPhotosCallback); verify(remoteDataSource, times(1)) .getPhotos(any(PhotoDataSource.LoadPhotosCallback.class)); }
@Test public void getPhotos_shouldCallLocalDataSource() { repository.getPhotos(loadPhotosCallback); verify(localDataSource, times(1)).getPhotos(any(PhotoDataSource.LoadPhotosCallback.class)); } |
### Question:
PhotoRepository implements PhotoDataSource { @Override public void getPhoto(int photoId, @NonNull LoadPhotoCallback callback) { Photo cachedPhoto = getPhotoFromCache(photoId); if (cachedPhoto != null) { callback.onPhotoLoaded(cachedPhoto); return; } photoLocalDataSource.getPhoto(photoId, new LoadPhotoCallback() { @Override public void onPhotoLoaded(Photo photo) { cachedPhotos.put(photo.getPhotoId(), photo); callback.onPhotoLoaded(photo); } @Override public void onPhotoNotAvailable() { photoRemoteDataSource.getPhoto(photoId, new LoadPhotoCallback() { @Override public void onPhotoLoaded(Photo photo) { cachedPhotos.put(photo.getPhotoId(), photo); callback.onPhotoLoaded(photo); } @Override public void onPhotoNotAvailable() { callback.onPhotoNotAvailable(); } }); } }); } PhotoRepository(@NonNull PhotoDataSource photoRemoteDataSource,
@NonNull PhotoDataSource photoLocalDataSource); @Override void getPhotos(@NonNull LoadPhotosCallback callback); @Override void getPhoto(int photoId, @NonNull LoadPhotoCallback callback); @Override void savePhoto(@NonNull Photo photo); @Override void deletePhoto(int photoId); @Override void deleteAllPhotos(); @Override void refreshPhotos(); }### Answer:
@Test public void getPhoto_shouldCacheAfterFirstRemoteCall() { final Photo photo = new Photo(10, 20, "abc"); repository.getPhoto(1, loadPhotoCallback); verify(localDataSource, times(1)).getPhoto(eq(1), photoCallbackCaptor.capture()); photoCallbackCaptor.getValue().onPhotoNotAvailable(); verify(remoteDataSource, times(1)).getPhoto(eq(1), photoCallbackCaptor.capture()); photoCallbackCaptor.getValue().onPhotoLoaded(photo); assertThat(repository.cachedPhotos.size(), is(1)); repository.getPhoto(1, loadPhotoCallback); verify(remoteDataSource, times(1)) .getPhoto(anyInt(), any(PhotoDataSource.LoadPhotoCallback.class)); }
@Test public void getPhoto_shouldLoadPhotoFromLocal() { repository.getPhoto(1, loadPhotoCallback); verify(localDataSource, times(1)).getPhoto(eq(1), any(PhotoDataSource.LoadPhotoCallback.class)); } |
### Question:
PhotoRepository implements PhotoDataSource { @Override public void savePhoto(@NonNull Photo photo) { photoLocalDataSource.savePhoto(photo); cachedPhotos.put(photo.getPhotoId(), photo); } PhotoRepository(@NonNull PhotoDataSource photoRemoteDataSource,
@NonNull PhotoDataSource photoLocalDataSource); @Override void getPhotos(@NonNull LoadPhotosCallback callback); @Override void getPhoto(int photoId, @NonNull LoadPhotoCallback callback); @Override void savePhoto(@NonNull Photo photo); @Override void deletePhoto(int photoId); @Override void deleteAllPhotos(); @Override void refreshPhotos(); }### Answer:
@Test public void savePhoto_shouldSavePhotoToCacheAndLocal() { final Photo photo = new Photo(1, 10, "a"); repository.savePhoto(photo); verify(remoteDataSource, never()).savePhoto(photo); verify(localDataSource, times(1)).savePhoto(photo); assertThat(repository.cachedPhotos.size(), is(1)); } |
### Question:
PhotoListPresenter implements PhotoListContract.Presenter { @Override public void loadPhotos() { view.setLoadingVisibility(true); photoRepository.getPhotos(new PhotoDataSource.LoadPhotosCallback() { @Override public void onPhotosLoaded(List<Photo> photos) { if (view != null && view.isActive()) { view.setLoadingVisibility(false); view.showPhotos(photos); } } @Override public void onPhotosNotAvailable() { if (view != null && view.isActive()) { view.setLoadingVisibility(false); view.showLoadingPhotosError(); } } }); } PhotoListPresenter(PhotoListContract.View view, PhotoRepository photoRepository); @Override void loadPhotos(); @Override void onPhotoSelected(Photo selectedPhoto); @Override void onRefresh(); @Override void dropView(); }### Answer:
@Test public void loadAllPhotosFromRepository_shouldDisplaySuccess() { presenter.loadPhotos(); verify(repository, times(1)).getPhotos(loadPhotosCallbackCaptor.capture()); loadPhotosCallbackCaptor.getValue().onPhotosLoaded(PHOTOS); final InOrder inOrder = Mockito.inOrder(view); inOrder.verify(view).setLoadingVisibility(true); inOrder.verify(view).setLoadingVisibility(false); verify(view, times(1)).showPhotos(photoListArgumentCaptor.capture()); final List<Photo> result = photoListArgumentCaptor.getValue(); assertThat(result, is(PHOTOS)); }
@Test public void loadAllPhotosFromRepository_shouldDisplayFail() { presenter.loadPhotos(); verify(repository, times(1)).getPhotos(loadPhotosCallbackCaptor.capture()); loadPhotosCallbackCaptor.getValue().onPhotosNotAvailable(); final InOrder inOrder = Mockito.inOrder(view); inOrder.verify(view).setLoadingVisibility(true); inOrder.verify(view).setLoadingVisibility(false); inOrder.verify(view).showLoadingPhotosError(); } |
### Question:
PhotoListPresenter implements PhotoListContract.Presenter { @Override public void onRefresh() { photoRepository.refreshPhotos(); loadPhotos(); } PhotoListPresenter(PhotoListContract.View view, PhotoRepository photoRepository); @Override void loadPhotos(); @Override void onPhotoSelected(Photo selectedPhoto); @Override void onRefresh(); @Override void dropView(); }### Answer:
@Test public void refresh_shouldDisplaySuccess() { presenter.onRefresh(); verify(repository, times(1)).refreshPhotos(); verify(repository, times(1)).getPhotos(loadPhotosCallbackCaptor.capture()); loadPhotosCallbackCaptor.getValue().onPhotosLoaded(PHOTOS); final InOrder inOrder = Mockito.inOrder(view); inOrder.verify(view).setLoadingVisibility(true); inOrder.verify(view).setLoadingVisibility(false); verify(view, times(1)).showPhotos(photoListArgumentCaptor.capture()); final List<Photo> result = photoListArgumentCaptor.getValue(); assertThat(result, is(PHOTOS)); } |
### Question:
PhotoDetailPresenter implements PhotoDetailContract.Presenter { @Override public void loadPhoto() { if (photoId == -1) { view.showMissingPhoto(); return; } photoRepository.getPhoto(photoId, new PhotoDataSource.LoadPhotoCallback() { @Override public void onPhotoLoaded(Photo photo) { if (view != null && view.isActive()) { view.showPhoto(photo); } } @Override public void onPhotoNotAvailable() { if (view != null && view.isActive()) { view.showErrorDisplayingPhoto(); } } }); } PhotoDetailPresenter(PhotoDetailContract.View view, PhotoRepository photoRepository); @Override void loadPhoto(); @Override void setPhotoId(int photoId); @Override void dropView(); }### Answer:
@Test public void loadPhoto_shouldDisplayMissingPhoto() { presenter.loadPhoto(); verify(view, times(1)).showMissingPhoto(); } |
### Question:
Connection { public List<AppDto> getApps(String name) throws DBException { return getApps(null, null, name, null, 100, 0); } Connection(String domain, String login, String password); Connection(String domain, String apiToken); void close(); boolean isTrustAllHosts(); void setTrustAllHosts(boolean trustAllHosts); void setBasicAuth(final String username, final String password); long getGuestSpaceId(); void setGuestSpaceId(long guestSpaceId); void addHeader(String name, String value); void setProxy(String host, int port); void setClientCert(String cert, String password); String request(String method, String api, String body); Properties getProperties(); String request(String method, String api, String body, File outFile); ResultSet select(long app, String query); ResultSet selectWithTotalCount(long app, String query); ResultSet select(long app, String query, String[] columns); ResultSet selectWithTotalCount(long app, String query, String[] columns); long insert(long app, Record record); void lazyUpload(Field field); List<Long> insert(long app, List<Record> records); void update(long app, long id, Record record); long updateRecord(long app, Record record); void update(long app, List<Long> ids, Record record); void updateRecords(long app, List<Record> records); void updateByQuery(long app, String query, Record record); long updateRecordByKey(long app, String key, Record record); void updateRecordsByKey(long app, String key, List<Record> records); long updateAssignees(long app, long id, List<String> codes, long revision); long updateAssignees(long app, long id, List<String> codes); long updateStatus(long app, long id, String action, String assignee, long revision); long updateStatus(long app, long id, String action, String assignee); void updateStatus(long app, List<Long> ids, List<String> actions, List<String> assignees, List<Long> revisions); void delete(long app, long id); void deleteRecord(long app, Record record); void deleteRecords(long app, List<Record> records); void delete(long app, List<Long> ids); void deleteByQuery(long app, String query); String uploadFile(File file, String contentType); String uploadFile(File file); String uploadFile(String contentType, InputStream file, String fileName); File downloadFile(String fileKey); void bulkRequest(BulkRequest bulk); AppDto getApp(long id); List<AppDto> getApps(String name); List<AppDto> getApps(List<Long> ids, List<String> codes,
String name, List<Long> spaceIds, long limit, long offset); long addComment(long app, long record, String text, List<MentionDto> mentions); void deleteComment(long app, long record, long id); CommentSet getComments(long app, long record, boolean descending, long limit, long offset); CommentSet getComments(long app, long record, boolean descending); static final String DEFAULT_CONTENT_TYPE; }### Answer:
@Test public void testGetApps() { Connection db = getConnection(); try { List<AppDto> apps = db.getApps("hoge"); for (AppDto app : apps) { System.out.println(app.getName()); } } catch (Exception e) { fail("db exception:" + e.getMessage()); } } |
### Question:
Connection { private String upload(File file, String contentType) throws DBException { InputStream isFile; try { isFile = new FileInputStream(file.getAbsolutePath()); } catch (FileNotFoundException e1) { throw new DBNotFoundException("cannot open file"); } try { return upload(isFile, file.getName(), contentType); } finally { try { isFile.close(); } catch (IOException e) { } } } Connection(String domain, String login, String password); Connection(String domain, String apiToken); void close(); boolean isTrustAllHosts(); void setTrustAllHosts(boolean trustAllHosts); void setBasicAuth(final String username, final String password); long getGuestSpaceId(); void setGuestSpaceId(long guestSpaceId); void addHeader(String name, String value); void setProxy(String host, int port); void setClientCert(String cert, String password); String request(String method, String api, String body); Properties getProperties(); String request(String method, String api, String body, File outFile); ResultSet select(long app, String query); ResultSet selectWithTotalCount(long app, String query); ResultSet select(long app, String query, String[] columns); ResultSet selectWithTotalCount(long app, String query, String[] columns); long insert(long app, Record record); void lazyUpload(Field field); List<Long> insert(long app, List<Record> records); void update(long app, long id, Record record); long updateRecord(long app, Record record); void update(long app, List<Long> ids, Record record); void updateRecords(long app, List<Record> records); void updateByQuery(long app, String query, Record record); long updateRecordByKey(long app, String key, Record record); void updateRecordsByKey(long app, String key, List<Record> records); long updateAssignees(long app, long id, List<String> codes, long revision); long updateAssignees(long app, long id, List<String> codes); long updateStatus(long app, long id, String action, String assignee, long revision); long updateStatus(long app, long id, String action, String assignee); void updateStatus(long app, List<Long> ids, List<String> actions, List<String> assignees, List<Long> revisions); void delete(long app, long id); void deleteRecord(long app, Record record); void deleteRecords(long app, List<Record> records); void delete(long app, List<Long> ids); void deleteByQuery(long app, String query); String uploadFile(File file, String contentType); String uploadFile(File file); String uploadFile(String contentType, InputStream file, String fileName); File downloadFile(String fileKey); void bulkRequest(BulkRequest bulk); AppDto getApp(long id); List<AppDto> getApps(String name); List<AppDto> getApps(List<Long> ids, List<String> codes,
String name, List<Long> spaceIds, long limit, long offset); long addComment(long app, long record, String text, List<MentionDto> mentions); void deleteComment(long app, long record, long id); CommentSet getComments(long app, long record, boolean descending, long limit, long offset); CommentSet getComments(long app, long record, boolean descending); static final String DEFAULT_CONTENT_TYPE; }### Answer:
@Test public void testUpload() { Connection db = getConnection(); long app = getAppId(); try { Record record; record = new Record(); File file = new File("/Users/ryo/tmp/test.jpg"); record.setFile("Attachment", file); db.insert(app, record); ResultSet rs = db.select(app, ""); if (rs.size() != 1) { fail("invalid count"); } rs.next(); List<FileDto> fileNames = rs.getFiles("Attachment"); assertEquals(fileNames.size(), 1); assertEquals(fileNames.get(0).getName(), "test.jpg"); assertTrue(fileNames.get(0).getSize() > 0); } catch (Exception e) { fail("db exception:" + e.getMessage()); } } |
### Question:
Connection { public void updateRecords(long app, List<Record> records) throws DBException { for (Record record: records) { Set<Map.Entry<String,Field>> set = record.getEntrySet(); for (Map.Entry<String,Field> entry: set) { Field field = entry.getValue(); lazyUpload(field); } } JsonParser parser = new JsonParser(); String json; try { json = parser.recordsToJsonForUpdate(app, records); } catch (IOException e) { throw new ParseException("failed to encode to json"); } request("PUT", "records.json", json); } Connection(String domain, String login, String password); Connection(String domain, String apiToken); void close(); boolean isTrustAllHosts(); void setTrustAllHosts(boolean trustAllHosts); void setBasicAuth(final String username, final String password); long getGuestSpaceId(); void setGuestSpaceId(long guestSpaceId); void addHeader(String name, String value); void setProxy(String host, int port); void setClientCert(String cert, String password); String request(String method, String api, String body); Properties getProperties(); String request(String method, String api, String body, File outFile); ResultSet select(long app, String query); ResultSet selectWithTotalCount(long app, String query); ResultSet select(long app, String query, String[] columns); ResultSet selectWithTotalCount(long app, String query, String[] columns); long insert(long app, Record record); void lazyUpload(Field field); List<Long> insert(long app, List<Record> records); void update(long app, long id, Record record); long updateRecord(long app, Record record); void update(long app, List<Long> ids, Record record); void updateRecords(long app, List<Record> records); void updateByQuery(long app, String query, Record record); long updateRecordByKey(long app, String key, Record record); void updateRecordsByKey(long app, String key, List<Record> records); long updateAssignees(long app, long id, List<String> codes, long revision); long updateAssignees(long app, long id, List<String> codes); long updateStatus(long app, long id, String action, String assignee, long revision); long updateStatus(long app, long id, String action, String assignee); void updateStatus(long app, List<Long> ids, List<String> actions, List<String> assignees, List<Long> revisions); void delete(long app, long id); void deleteRecord(long app, Record record); void deleteRecords(long app, List<Record> records); void delete(long app, List<Long> ids); void deleteByQuery(long app, String query); String uploadFile(File file, String contentType); String uploadFile(File file); String uploadFile(String contentType, InputStream file, String fileName); File downloadFile(String fileKey); void bulkRequest(BulkRequest bulk); AppDto getApp(long id); List<AppDto> getApps(String name); List<AppDto> getApps(List<Long> ids, List<String> codes,
String name, List<Long> spaceIds, long limit, long offset); long addComment(long app, long record, String text, List<MentionDto> mentions); void deleteComment(long app, long record, long id); CommentSet getComments(long app, long record, boolean descending, long limit, long offset); CommentSet getComments(long app, long record, boolean descending); static final String DEFAULT_CONTENT_TYPE; }### Answer:
@Test public void testUpdateRecords() { Connection db = getConnection(); long app = getAppId(); try { Record record; List<Record> records = new ArrayList<Record>(); List<Long> ids = insertRecords(); ResultSet rs = db.select(app, ""); if (rs.size() != 3) { fail("invalid count"); } while (rs.next()) { record = new Record(); record.setId(rs.getId()); record.setRevision(rs.getRevision()); record.setString("Single_line_text", "hoge"); records.add(record); } db.updateRecords(app, records); rs = db.select(app, "Single_line_text = \"hoge\""); if (rs.size() != 3) { fail("failed to update"); } } catch (Exception e) { fail("db exception:" + e.getMessage()); } } |
### Question:
Connection { public void updateByQuery(long app, String query, Record record) throws DBException { String[] fields = {}; ResultSet rs = select(app, query, fields); List<Long> ids = new ArrayList<Long>(); if (rs.size() == 0) return; while (rs.next()) { ids.add(rs.getId()); } update(app, ids, record); } Connection(String domain, String login, String password); Connection(String domain, String apiToken); void close(); boolean isTrustAllHosts(); void setTrustAllHosts(boolean trustAllHosts); void setBasicAuth(final String username, final String password); long getGuestSpaceId(); void setGuestSpaceId(long guestSpaceId); void addHeader(String name, String value); void setProxy(String host, int port); void setClientCert(String cert, String password); String request(String method, String api, String body); Properties getProperties(); String request(String method, String api, String body, File outFile); ResultSet select(long app, String query); ResultSet selectWithTotalCount(long app, String query); ResultSet select(long app, String query, String[] columns); ResultSet selectWithTotalCount(long app, String query, String[] columns); long insert(long app, Record record); void lazyUpload(Field field); List<Long> insert(long app, List<Record> records); void update(long app, long id, Record record); long updateRecord(long app, Record record); void update(long app, List<Long> ids, Record record); void updateRecords(long app, List<Record> records); void updateByQuery(long app, String query, Record record); long updateRecordByKey(long app, String key, Record record); void updateRecordsByKey(long app, String key, List<Record> records); long updateAssignees(long app, long id, List<String> codes, long revision); long updateAssignees(long app, long id, List<String> codes); long updateStatus(long app, long id, String action, String assignee, long revision); long updateStatus(long app, long id, String action, String assignee); void updateStatus(long app, List<Long> ids, List<String> actions, List<String> assignees, List<Long> revisions); void delete(long app, long id); void deleteRecord(long app, Record record); void deleteRecords(long app, List<Record> records); void delete(long app, List<Long> ids); void deleteByQuery(long app, String query); String uploadFile(File file, String contentType); String uploadFile(File file); String uploadFile(String contentType, InputStream file, String fileName); File downloadFile(String fileKey); void bulkRequest(BulkRequest bulk); AppDto getApp(long id); List<AppDto> getApps(String name); List<AppDto> getApps(List<Long> ids, List<String> codes,
String name, List<Long> spaceIds, long limit, long offset); long addComment(long app, long record, String text, List<MentionDto> mentions); void deleteComment(long app, long record, long id); CommentSet getComments(long app, long record, boolean descending, long limit, long offset); CommentSet getComments(long app, long record, boolean descending); static final String DEFAULT_CONTENT_TYPE; }### Answer:
@Test public void testUpdateByQuery() { Connection db = getConnection(); long app = getAppId(); try { Record record; record = new Record(); record.setString("Single_line_text", "hoge"); List<Long> ids = insertRecords(); db.updateByQuery(app, "Single_line_text = \"foo\"", record); ResultSet rs = db.select(app, "Single_line_text = \"hoge\""); if (rs.size() != 1) { fail("failed to update"); } } catch (Exception e) { fail("db exception:" + e.getMessage()); } } |
### Question:
Connection { public void deleteByQuery(long app, String query) throws DBException { ResultSet rs = select(app, query); List<Record> records = new ArrayList<Record>(); if (rs.size() == 0) return; while (rs.next()) { Record record = new Record(); record.setId(rs.getId()); records.add(record); } deleteRecords(app, records); } Connection(String domain, String login, String password); Connection(String domain, String apiToken); void close(); boolean isTrustAllHosts(); void setTrustAllHosts(boolean trustAllHosts); void setBasicAuth(final String username, final String password); long getGuestSpaceId(); void setGuestSpaceId(long guestSpaceId); void addHeader(String name, String value); void setProxy(String host, int port); void setClientCert(String cert, String password); String request(String method, String api, String body); Properties getProperties(); String request(String method, String api, String body, File outFile); ResultSet select(long app, String query); ResultSet selectWithTotalCount(long app, String query); ResultSet select(long app, String query, String[] columns); ResultSet selectWithTotalCount(long app, String query, String[] columns); long insert(long app, Record record); void lazyUpload(Field field); List<Long> insert(long app, List<Record> records); void update(long app, long id, Record record); long updateRecord(long app, Record record); void update(long app, List<Long> ids, Record record); void updateRecords(long app, List<Record> records); void updateByQuery(long app, String query, Record record); long updateRecordByKey(long app, String key, Record record); void updateRecordsByKey(long app, String key, List<Record> records); long updateAssignees(long app, long id, List<String> codes, long revision); long updateAssignees(long app, long id, List<String> codes); long updateStatus(long app, long id, String action, String assignee, long revision); long updateStatus(long app, long id, String action, String assignee); void updateStatus(long app, List<Long> ids, List<String> actions, List<String> assignees, List<Long> revisions); void delete(long app, long id); void deleteRecord(long app, Record record); void deleteRecords(long app, List<Record> records); void delete(long app, List<Long> ids); void deleteByQuery(long app, String query); String uploadFile(File file, String contentType); String uploadFile(File file); String uploadFile(String contentType, InputStream file, String fileName); File downloadFile(String fileKey); void bulkRequest(BulkRequest bulk); AppDto getApp(long id); List<AppDto> getApps(String name); List<AppDto> getApps(List<Long> ids, List<String> codes,
String name, List<Long> spaceIds, long limit, long offset); long addComment(long app, long record, String text, List<MentionDto> mentions); void deleteComment(long app, long record, long id); CommentSet getComments(long app, long record, boolean descending, long limit, long offset); CommentSet getComments(long app, long record, boolean descending); static final String DEFAULT_CONTENT_TYPE; }### Answer:
@Test public void testDeleteByQuery() { Connection db = getConnection(); long app = getAppId(); try { List<Long> ids = insertRecords(); db.deleteByQuery(app, "Single_line_text = \"foo\""); ResultSet rs = db.select(app, ""); if (rs.size() != 2) { fail("failed to delete"); } } catch (Exception e) { fail("db exception"); } } |
### Question:
Connection { public AppDto getApp(long id) throws DBException { StringBuilder sb = new StringBuilder(); sb.append("id="); sb.append(id); String query = new String(sb); String response = request("GET", "app.json?" + query, null); JsonParser parser = new JsonParser(); AppDto app = null; try { app = parser.jsonToApp(response); } catch (IOException e) { throw new ParseException("failed to parse json to app"); } return app; } Connection(String domain, String login, String password); Connection(String domain, String apiToken); void close(); boolean isTrustAllHosts(); void setTrustAllHosts(boolean trustAllHosts); void setBasicAuth(final String username, final String password); long getGuestSpaceId(); void setGuestSpaceId(long guestSpaceId); void addHeader(String name, String value); void setProxy(String host, int port); void setClientCert(String cert, String password); String request(String method, String api, String body); Properties getProperties(); String request(String method, String api, String body, File outFile); ResultSet select(long app, String query); ResultSet selectWithTotalCount(long app, String query); ResultSet select(long app, String query, String[] columns); ResultSet selectWithTotalCount(long app, String query, String[] columns); long insert(long app, Record record); void lazyUpload(Field field); List<Long> insert(long app, List<Record> records); void update(long app, long id, Record record); long updateRecord(long app, Record record); void update(long app, List<Long> ids, Record record); void updateRecords(long app, List<Record> records); void updateByQuery(long app, String query, Record record); long updateRecordByKey(long app, String key, Record record); void updateRecordsByKey(long app, String key, List<Record> records); long updateAssignees(long app, long id, List<String> codes, long revision); long updateAssignees(long app, long id, List<String> codes); long updateStatus(long app, long id, String action, String assignee, long revision); long updateStatus(long app, long id, String action, String assignee); void updateStatus(long app, List<Long> ids, List<String> actions, List<String> assignees, List<Long> revisions); void delete(long app, long id); void deleteRecord(long app, Record record); void deleteRecords(long app, List<Record> records); void delete(long app, List<Long> ids); void deleteByQuery(long app, String query); String uploadFile(File file, String contentType); String uploadFile(File file); String uploadFile(String contentType, InputStream file, String fileName); File downloadFile(String fileKey); void bulkRequest(BulkRequest bulk); AppDto getApp(long id); List<AppDto> getApps(String name); List<AppDto> getApps(List<Long> ids, List<String> codes,
String name, List<Long> spaceIds, long limit, long offset); long addComment(long app, long record, String text, List<MentionDto> mentions); void deleteComment(long app, long record, long id); CommentSet getComments(long app, long record, boolean descending, long limit, long offset); CommentSet getComments(long app, long record, boolean descending); static final String DEFAULT_CONTENT_TYPE; }### Answer:
@Test public void testGetApp() { Connection db = getConnection(); try { AppDto app = db.getApp(getAppId()); System.out.println(app.getAppId()); System.out.println(app.getCode()); System.out.println(app.getName()); System.out.println(app.getDescription()); } catch (Exception e) { fail("db exception:" + e.getMessage()); } } |
### Question:
ItemsContainer extends GameObject implements InventoryHolder { @Override public boolean placeItem(Item item) { if (items.size() < containerCapacity) { items.add(item); return true; } else { return false; } } ItemsContainer(int containerCapacity); ItemsContainer(Document document); @Override char getMapInfo(); @Override boolean placeItem(Item item); @Override void takeItem(int itemId); @Override boolean canTakeItem(int itemId); @Override JSONObject jsonSerialise(); @Override Document mongoSerialise(); }### Answer:
@Test public void shouldPlaceItemWhenCapacityAllowsIt() { ItemsContainer itemsContainer = new ItemsContainer(1); boolean result = itemsContainer.placeItem(new ItemCopper()); Assert.assertEquals(true, result); }
@Test public void shouldNotPlaceItemWhenThereIsNoCapacityLeft() { ItemsContainer itemsContainer = new ItemsContainer(1); itemsContainer.placeItem(new ItemCopper()); boolean result = itemsContainer.placeItem(new ItemCopper()); Assert.assertEquals(false, result); } |
### Question:
Memory implements Target, MongoSerializable { public boolean write(int offset, char[] src, int srcOffset, int count) { if (offset + count > this.words.length || srcOffset >= src.length || count < 0 || offset < 0) { return false; } System.arraycopy(src, srcOffset, this.words, offset, count); return true; } Memory(int size); Memory(Document document); @Override int get(int address); boolean write(int offset, char[] src, int srcOffset, int count); @Override void set(int address, int value); void corrupt(int blockSize); void clear(); byte[] getBytes(); @Override Document mongoSerialise(); void setBytes(byte[] bytes); char[] getWords(); }### Answer:
@Test public void write() { int memorySize = ConfigHelper.getConfig().getInt("memory_size"); Memory memory = new Memory(memorySize); assertTrue(memory.write(0, new char[memorySize], 0, memorySize)); assertFalse(memory.write(0, new char[memorySize], 0, memorySize + 1)); assertFalse(memory.write(0, new char[memorySize], 0, -1)); assertFalse(memory.write(-1, new char[memorySize], 0, 10)); assertFalse(memory.write(memorySize, new char[15], 0, 1)); assertFalse(memory.write((memorySize) - 5, new char[11], 0, 6)); assertTrue(memory.write((memorySize) - 5, new char[11], 0, 5)); } |
### Question:
RegisterSet implements Target, MongoSerializable { int getIndex(String name) { name = name.toUpperCase(); for (Integer i : registers.keySet()) { if (registers.get(i).getName().equals(name)) { return i; } } return -1; } RegisterSet(); Register getRegister(int index); Register getRegister(String name); @Override int get(int address); @Override void set(int address, int value); void put(int index, Register register); void clear(); @Override Document mongoSerialise(); static RegisterSet deserialize(Document obj); static RegisterSet deserialize(JSONObject json); @Override String toString(); }### Answer:
@Test public void getIndex() { RegisterSet registerSet = new RegisterSet(); Register r1 = new Register("R1"); Register r2 = new Register("R2"); registerSet.put(1, r1); registerSet.put(2, r2); assertEquals(1, registerSet.getIndex("R1")); assertEquals(2, registerSet.getIndex("R2")); assertEquals(-1, registerSet.getIndex("Unknown register name")); } |
### Question:
RegisterSet implements Target, MongoSerializable { public Register getRegister(int index) { return registers.get(index); } RegisterSet(); Register getRegister(int index); Register getRegister(String name); @Override int get(int address); @Override void set(int address, int value); void put(int index, Register register); void clear(); @Override Document mongoSerialise(); static RegisterSet deserialize(Document obj); static RegisterSet deserialize(JSONObject json); @Override String toString(); }### Answer:
@Test public void getRegister() { RegisterSet registerSet = new RegisterSet(); Register r1 = new Register("R1"); Register r2 = new Register("R2"); registerSet.put(1, r1); registerSet.put(2, r2); assertEquals(r1, registerSet.getRegister("R1")); assertEquals(r1, registerSet.getRegister(1)); assertEquals(r2, registerSet.getRegister("R2")); assertEquals(r2, registerSet.getRegister(2)); assertEquals(null, registerSet.getRegister("Unknown")); assertEquals(null, registerSet.getRegister(3)); } |
### Question:
RegisterSet implements Target, MongoSerializable { @Override public int get(int address) { Register register = registers.get(address); if (register != null) { return register.getValue(); } else { return 0; } } RegisterSet(); Register getRegister(int index); Register getRegister(String name); @Override int get(int address); @Override void set(int address, int value); void put(int index, Register register); void clear(); @Override Document mongoSerialise(); static RegisterSet deserialize(Document obj); static RegisterSet deserialize(JSONObject json); @Override String toString(); }### Answer:
@Test public void get() { RegisterSet registerSet = new RegisterSet(); Register r1 = new Register("R1"); registerSet.put(1, r1); r1.setValue(10); assertEquals(10, registerSet.get(1)); assertEquals(0, registerSet.get(2)); } |
### Question:
RegisterSet implements Target, MongoSerializable { @Override public void set(int address, int value) { Register register = registers.get(address); if (register != null) { register.setValue(value); } else { LogManager.LOGGER.info("DEBUG: trying to set unknown reg index : " + address); } } RegisterSet(); Register getRegister(int index); Register getRegister(String name); @Override int get(int address); @Override void set(int address, int value); void put(int index, Register register); void clear(); @Override Document mongoSerialise(); static RegisterSet deserialize(Document obj); static RegisterSet deserialize(JSONObject json); @Override String toString(); }### Answer:
@Test public void set() { RegisterSet registerSet = new RegisterSet(); Register r1 = new Register("R1"); registerSet.put(1, r1); registerSet.set(1, 10); assertEquals(10, r1.getValue()); registerSet.set(3, 10); } |
### Question:
ItemsContainer extends GameObject implements InventoryHolder { @Override public boolean canTakeItem(int itemId) { return items.stream() .anyMatch(item -> item.getId() == itemId); } ItemsContainer(int containerCapacity); ItemsContainer(Document document); @Override char getMapInfo(); @Override boolean placeItem(Item item); @Override void takeItem(int itemId); @Override boolean canTakeItem(int itemId); @Override JSONObject jsonSerialise(); @Override Document mongoSerialise(); }### Answer:
@Test public void shouldNotBeAbleToTakeItemWhenItWasNotPlacedBefore() { ItemsContainer itemsContainer = new ItemsContainer(1); boolean result = itemsContainer.canTakeItem(1); Assert.assertEquals(false, result); } |
### Question:
BrkInstruction extends Instruction { @Override public Status execute(Status status) { status.setBreakFlag(true); return status; } BrkInstruction(); @Override Status execute(Status status); boolean noOperandsValid(); static final int OPCODE; }### Answer:
@Test public void execute() throws Exception { Status status = new Status(); status.clear(); BrkInstruction brkInstruction = new BrkInstruction(); brkInstruction.execute(status); assertTrue(status.isBreakFlag()); } |
### Question:
AndInstruction extends Instruction { @Override public Status execute(Target dst, int dstIndex, Target src, int srcIndex, Status status) { int a = (char) dst.get(dstIndex); int b = (char) src.get(srcIndex); int result = (a & b); status.setSignFlag(Util.checkSign16(result)); status.setZeroFlag((char) result == 0); status.setOverflowFlag(false); status.setCarryFlag(false); dst.set(dstIndex, result); return status; } AndInstruction(); @Override Status execute(Target dst, int dstIndex, Target src, int srcIndex, Status status); @Override Status execute(Target dst, int dstIndex, int src, Status status); static final int OPCODE; }### Answer:
@Test public void executeTargetTarget() { int memorySize = ConfigHelper.getConfig().getInt("memory_size"); Memory memory = new Memory(memorySize); memory.clear(); Status status = new Status(); status.clear(); AndInstruction andInstruction = new AndInstruction(); memory.clear(); memory.set(0, 0xF010); memory.set(1, 0xF111); andInstruction.execute(memory, 0, memory, 1, status); assertEquals(0xF010, memory.get(0)); assertEquals(true, status.isSignFlag()); assertEquals(false, status.isZeroFlag()); assertEquals(false, status.isOverflowFlag()); assertEquals(false, status.isCarryFlag()); memory.clear(); memory.set(0, 0x1010); memory.set(1, 0x0101); andInstruction.execute(memory, 0, memory, 1, status); assertEquals(0, memory.get(0)); assertEquals(false, status.isSignFlag()); assertEquals(true, status.isZeroFlag()); assertEquals(false, status.isOverflowFlag()); assertEquals(false, status.isCarryFlag()); }
@Test public void executeTargetImm() { int memorySize = ConfigHelper.getConfig().getInt("memory_size"); Memory memory = new Memory(memorySize); memory.clear(); Status status = new Status(); status.clear(); AndInstruction andInstruction = new AndInstruction(); memory.clear(); memory.set(0, 0x1010); andInstruction.execute(memory, 0, 0x0101, status); assertEquals(0, memory.get(0)); assertEquals(false, status.isSignFlag()); assertEquals(true, status.isZeroFlag()); assertEquals(false, status.isOverflowFlag()); assertEquals(false, status.isCarryFlag()); } |
### Question:
SetccInstruction extends Instruction { @Override public void encode(ByteArrayOutputStream out, Operand o1, int currentLine) throws AssemblyException { String mnemonic = getMnemonic().toLowerCase(); Character familyOpCode = mnemonicFamilyOpCodeMap.get(mnemonic); if (familyOpCode == null) { throw new InvalidMnemonicException(getMnemonic(), currentLine); } if (!operandValid(o1)) { throw new IllegalOperandException("Illegal operand combination: " + o1.getType() + " (none)", currentLine); } MachineCode code = new MachineCode(); code.writeOpcode(getOpCode()); code.writeSourceOperand(Operand.IMMEDIATE_VALUE); code.appendWord(familyOpCode); if (o1.getType() == OperandType.REGISTER16 || o1.getType() == OperandType.MEMORY_REG16) { code.writeDestinationOperand(o1.getValue()); } else { code.writeDestinationOperand(o1.getValue()); code.appendWord((char) o1.getData()); } for (byte b : code.bytes()) { out.write(b); } } SetccInstruction(); SetccInstruction(String alias); @Override Status execute(Target dst, int dstIndex, int familyOpCode, Status status); @Override boolean operandsValid(Operand o1, Operand o2); @Override boolean operandValid(Operand o1); @Override void encode(ByteArrayOutputStream out, Operand o1, int currentLine); static final int OPCODE; static final int SETA; static final int SETAE; static final int SETBE; static final int SETB; static final int SETE; static final int SETNE; static final int SETG; static final int SETGE; static final int SETLE; static final int SETL; static final int SETO; static final int SETNO; static final int SETS; static final int SETNS; }### Answer:
@Test public void throwsInvalidMnemonicException() { SetccInstruction instruction = new SetccInstruction(); boolean hasThrown = false; try { ByteArrayOutputStream stream = new ByteArrayOutputStream(); Operand operand = new Operand(OperandType.MEMORY_REG16, 1); instruction.encode(stream, operand, 0); } catch (AssemblyException exception) { if (exception instanceof InvalidMnemonicException) { hasThrown = true; } } assertTrue(hasThrown); } |
### Question:
WXModuleManager { static Object callModuleMethod(final String instanceId, String moduleStr, String methodStr, JSONArray args) { Log.e("haha", "moduleStr" + moduleStr); ModuleFactory factory = sModuleFactoryMap.get(moduleStr); if(factory == null){ WXLogUtils.e("[WXModuleManager] module factory not found."); return null; } final WXModule wxModule = findModule(instanceId, moduleStr,factory); if (wxModule == null) { return null; } WXSDKInstance instance = WXSDKManager.getInstance().getSDKInstance(instanceId); wxModule.mWXSDKInstance = instance; final Invoker invoker = factory.getMethodInvoker(methodStr); try { if(instance != null) { IWXUserTrackAdapter userTrackAdapter = WXSDKManager.getInstance().getIWXUserTrackAdapter(); if(userTrackAdapter != null) { HashMap<String, Serializable> data = new HashMap<String, Serializable>(); data.put(MONITOR_ERROR_CODE, "101"); data.put(MONITOR_ARG, moduleStr + "." + methodStr); data.put(MONITOR_ERROR_MSG, instance.getBundleUrl()); userTrackAdapter.commit(instance.getContext(), null, IWXUserTrackAdapter.INVOKE_MODULE, null, data); } return dispatchCallModuleMethod(instance,wxModule,args,invoker); } else { WXLogUtils.e("callModuleMethod >>> instance is null"); return null; } } catch (Exception e) { WXLogUtils.e("callModuleMethod >>> invoke module:" + moduleStr + ", method:" + methodStr + " failed. ", e); return null; } finally { if (wxModule instanceof WXDomModule || wxModule instanceof WXTimerModule) { wxModule.mWXSDKInstance = null; } } } static boolean registerModule(final String moduleName, final ModuleFactory factory, final boolean global); static void onActivityCreate(String instanceId); static void onActivityStart(String instanceId); static void onActivityPause(String instanceId); static void onActivityResume(String instanceId); static void onActivityStop(String instanceId); static void onActivityDestroy(String instanceId); static boolean onActivityBack(String instanceId); static void onActivityResult(String instanceId,int requestCode, int resultCode, Intent data); static boolean onCreateOptionsMenu(String instanceId,Menu menu); static void onRequestPermissionsResult(String instanceId ,int requestCode, String[] permissions, int[] grantResults); static void destroyInstanceModules(String instanceId); static void createDomModule(WXSDKInstance instance); static void destoryDomModule(String instanceID); static WXDomModule getDomModule(String instanceId); static void reload(); }### Answer:
@Test public void testCallModuleMethod() throws Exception { WXModuleManager.callModuleMethod(instance.getInstanceId(),"test1","testMethod",null); WXModuleManager.callModuleMethod(instance.getInstanceId(),"test2","testMethod",null); }
@Test public void testCallModuleMethod2() throws Exception { JSONArray args = new JSONArray(); args.add("testarg"); WXModuleManager.callModuleMethod(instance.getInstanceId(),"test1","testMethod",args); }
@Test public void testCallModuleMethod3() throws Exception { JSONArray args = new JSONArray(); args.add("testarg"); args.add(null); WXModuleManager.callModuleMethod(instance.getInstanceId(),"test1","testCallbackMethod",args); }
@Test public void testCallModuleMethod4() throws Exception { JSONArray args = new JSONArray(); args.add("testarg"); args.add("testcallbackId"); WXModuleManager.callModuleMethod(instance.getInstanceId(),"test1","testCallbackMethod",args); } |
### Question:
WXImage extends WXComponent<ImageView> { @Override protected ImageView initComponentHostView(@NonNull Context context) { WXImageView view = new WXImageView(context); view.setScaleType(ScaleType.FIT_XY); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) { view.setCropToPadding(true); } view.holdComponent(this); return view; } @Deprecated WXImage(WXSDKInstance instance, WXDomObject dom, WXVContainer parent, String instanceId, boolean isLazy); WXImage(WXSDKInstance instance, WXDomObject node,
WXVContainer parent); @Override void refreshData(WXComponent component); @WXComponentProp(name = Constants.Name.RESIZE_MODE) void setResizeMode(String resizeMode); @WXComponentProp(name = Constants.Name.RESIZE) void setResize(String resize); @WXComponentProp(name = Constants.Name.SRC) void setSrc(String src); @Override void recycled(); @Override void updateProperties(Map<String, Object> props); }### Answer:
@Test @PrepareForTest(WXImageView.class) public void testInitComponentHostView() throws Exception { ImageView imageView = mWXImage.initComponentHostView(Robolectric.setupActivity(TestActivity.class)); assertEquals(imageView.getClass(), WXImageView.class); }
@Test @PrepareForTest(WXImageView.class) public void testSetBackgroundColor() throws Exception { ImageView imageView = mWXImage.initComponentHostView(Robolectric.setupActivity(TestActivity.class)); mWXImage.mHost = imageView; mWXImage.setBackgroundColor("#FFFFFF"); Drawable drawable = mWXImage.getHostView().getBackground(); assertEquals(drawable instanceof BorderDrawable, true); }
@Test public void testSetImageBitmap(){ ImageView imageView = mWXImage.initComponentHostView(Robolectric.setupActivity(TestActivity.class)); imageView.setLayoutParams(new ViewGroup.LayoutParams( ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)); imageView.setImageBitmap(null); assertNull(imageView.getDrawable()); imageView.setImageBitmap(Bitmap.createBitmap(100, 100, Bitmap.Config.RGB_565)); assertNotNull(imageView.getDrawable()); } |
### Question:
WXImage extends WXComponent<ImageView> { @Override protected boolean setProperty(String key, Object param) { switch (key) { case Constants.Name.RESIZE_MODE: String resize_mode = WXUtils.getString(param, null); if (resize_mode != null) setResizeMode(resize_mode); return true; case Constants.Name.RESIZE: String resize = WXUtils.getString(param, null); if (resize != null) setResize(resize); return true; case Constants.Name.SRC: String src = WXUtils.getString(param, null); if (src != null) setSrc(src); return true; case Constants.Name.IMAGE_QUALITY: return true; case Constants.Name.FILTER: int blurRadius = 0; if(param != null && param instanceof String) { blurRadius = parseBlurRadius((String)param); } if(!TextUtils.isEmpty(this.mSrc)) { setBlurRadius(this.mSrc,blurRadius); } return true; } return super.setProperty(key, param); } @Deprecated WXImage(WXSDKInstance instance, WXDomObject dom, WXVContainer parent, String instanceId, boolean isLazy); WXImage(WXSDKInstance instance, WXDomObject node,
WXVContainer parent); @Override void refreshData(WXComponent component); @WXComponentProp(name = Constants.Name.RESIZE_MODE) void setResizeMode(String resizeMode); @WXComponentProp(name = Constants.Name.RESIZE) void setResize(String resize); @WXComponentProp(name = Constants.Name.SRC) void setSrc(String src); @Override void recycled(); @Override void updateProperties(Map<String, Object> props); }### Answer:
@Test public void testSetProperty() throws Exception { ImageView imageView = mWXImage.initComponentHostView(Robolectric.setupActivity(TestActivity.class)); mWXImage.mHost = imageView; mWXImage.setProperty(Constants.Name.RESIZE_MODE, "cover"); ImageView.ScaleType scaleType = mWXImage.getHostView().getScaleType(); assertEquals(scaleType, ImageView.ScaleType.CENTER_CROP); } |
### Question:
WXImage extends WXComponent<ImageView> { @WXComponentProp(name = Constants.Name.RESIZE_MODE) public void setResizeMode(String resizeMode) { (getHostView()).setScaleType(getResizeMode(resizeMode)); } @Deprecated WXImage(WXSDKInstance instance, WXDomObject dom, WXVContainer parent, String instanceId, boolean isLazy); WXImage(WXSDKInstance instance, WXDomObject node,
WXVContainer parent); @Override void refreshData(WXComponent component); @WXComponentProp(name = Constants.Name.RESIZE_MODE) void setResizeMode(String resizeMode); @WXComponentProp(name = Constants.Name.RESIZE) void setResize(String resize); @WXComponentProp(name = Constants.Name.SRC) void setSrc(String src); @Override void recycled(); @Override void updateProperties(Map<String, Object> props); }### Answer:
@Test public void testSetResizeMode() throws Exception { ImageView imageView = mWXImage.initComponentHostView(Robolectric.setupActivity(TestActivity.class)); mWXImage.mHost = imageView; mWXImage.setResizeMode("cover"); ImageView.ScaleType scaleType = mWXImage.getHostView().getScaleType(); assertEquals(scaleType, ImageView.ScaleType.CENTER_CROP); } |
### Question:
WXImage extends WXComponent<ImageView> { @WXComponentProp(name = Constants.Name.RESIZE) public void setResize(String resize) { (getHostView()).setScaleType(getResizeMode(resize)); } @Deprecated WXImage(WXSDKInstance instance, WXDomObject dom, WXVContainer parent, String instanceId, boolean isLazy); WXImage(WXSDKInstance instance, WXDomObject node,
WXVContainer parent); @Override void refreshData(WXComponent component); @WXComponentProp(name = Constants.Name.RESIZE_MODE) void setResizeMode(String resizeMode); @WXComponentProp(name = Constants.Name.RESIZE) void setResize(String resize); @WXComponentProp(name = Constants.Name.SRC) void setSrc(String src); @Override void recycled(); @Override void updateProperties(Map<String, Object> props); }### Answer:
@Test public void testSetResize() throws Exception { ImageView imageView = mWXImage.initComponentHostView(Robolectric.setupActivity(TestActivity.class)); mWXImage.mHost = imageView; mWXImage.setResize("cover"); ImageView.ScaleType scaleType = mWXImage.getHostView().getScaleType(); assertEquals(scaleType, ImageView.ScaleType.CENTER_CROP); } |
### Question:
WXImage extends WXComponent<ImageView> { @WXComponentProp(name = Constants.Name.SRC) public void setSrc(String src) { if (src == null) { return; } ImageView image = getHostView(); if("".equals(src) && image != null){ image.setImageDrawable(null); return; } this.mSrc = src; WXSDKInstance instance = getInstance(); Uri rewrited = instance.rewriteUri(Uri.parse(src), URIAdapter.IMAGE); if (Constants.Scheme.LOCAL.equals(rewrited.getScheme())) { setLocalSrc(rewrited); } else { int blur = 0; if(getDomObject() != null) { String blurStr = getDomObject().getStyles().getBlur(); blur = parseBlurRadius(blurStr); } setRemoteSrc(rewrited, blur); } } @Deprecated WXImage(WXSDKInstance instance, WXDomObject dom, WXVContainer parent, String instanceId, boolean isLazy); WXImage(WXSDKInstance instance, WXDomObject node,
WXVContainer parent); @Override void refreshData(WXComponent component); @WXComponentProp(name = Constants.Name.RESIZE_MODE) void setResizeMode(String resizeMode); @WXComponentProp(name = Constants.Name.RESIZE) void setResize(String resize); @WXComponentProp(name = Constants.Name.SRC) void setSrc(String src); @Override void recycled(); @Override void updateProperties(Map<String, Object> props); }### Answer:
@Test public void testSetSrc() throws Exception { TestDomObject.setAttribute((WXDomObject)mWXImage.getDomObject(),PowerMockito.mock(WXAttr.class)); PowerMockito.when(mWXImage.getDomObject().getAttrs().getImageSharpen()).thenReturn(WXImageSharpen.SHARPEN); mWXImage.setSrc(""); } |
### Question:
IdResource { @GET @Timed @Produces(MediaType.TEXT_PLAIN) @CacheControl(mustRevalidate = true, noCache = true, noStore = true) public String getIdAsString( @HeaderParam(HttpHeaders.USER_AGENT) final String agent) { return String.valueOf(getId(agent)); } IdResource(final IdWorker worker); long getId(final String agent); @GET @Timed @Produces(MediaType.TEXT_PLAIN) @CacheControl(mustRevalidate = true, noCache = true, noStore = true) String getIdAsString(
@HeaderParam(HttpHeaders.USER_AGENT) final String agent); @GET @Timed @JSONP(callback = "callback", queryParam = "callback") @Produces({ MediaType.APPLICATION_JSON, MediaTypeAdditional.APPLICATION_JAVASCRIPT }) @CacheControl(mustRevalidate = true, noCache = true, noStore = true) Id getIdAsJSON(
@HeaderParam(HttpHeaders.USER_AGENT) final String agent); @GET @Timed @Produces(ProtocolBufferMediaType.APPLICATION_PROTOBUF) @CacheControl(mustRevalidate = true, noCache = true, noStore = true) SnowizardResponse getIdAsProtobuf(
@HeaderParam(HttpHeaders.USER_AGENT) final String agent,
@QueryParam("count") final Optional<IntParam> count); }### Answer:
@Test public void testGetIdAsString() throws Exception { final long expected = 100L; when(worker.getId(AGENT)).thenReturn(expected); final Response response = resources.client().target("/") .request(MediaType.TEXT_PLAIN) .header(HttpHeaders.USER_AGENT, AGENT).get(); final String entity = response.readEntity(String.class); final long actual = Long.valueOf(entity); assertThat(response.getStatus()).isEqualTo(200); assertThat(actual).isEqualTo(expected); verify(worker).getId(AGENT); } |
### Question:
SnowizardApplication extends Application<SnowizardConfiguration> { @Override public void run(final SnowizardConfiguration config, final Environment environment) throws Exception { environment.jersey().register(new SnowizardExceptionMapper()); environment.jersey().register(new ProtocolBufferMessageBodyProvider()); if (config.isCORSEnabled()) { final FilterRegistration.Dynamic filter = environment.servlets() .addFilter("CrossOriginFilter", CrossOriginFilter.class); filter.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST), true, "/*"); filter.setInitParameter(CrossOriginFilter.ALLOWED_METHODS_PARAM, "GET"); } final IdWorker worker = new IdWorker(config.getWorkerId(), config.getDatacenterId(), 0L, config.validateUserAgent(), environment.metrics()); environment.metrics().register( MetricRegistry.name(SnowizardApplication.class, "worker_id"), new Gauge<Integer>() { @Override public Integer getValue() { return config.getWorkerId(); } }); environment.metrics() .register( MetricRegistry.name(SnowizardApplication.class, "datacenter_id"), new Gauge<Integer>() { @Override public Integer getValue() { return config.getDatacenterId(); } }); environment.healthChecks().register("empty", new EmptyHealthCheck()); environment.jersey().register(new IdResource(worker)); environment.jersey().register(new PingResource()); environment.jersey().register(new VersionResource()); } static void main(final String[] args); @Override String getName(); @Override void initialize(final Bootstrap<SnowizardConfiguration> bootstrap); @Override void run(final SnowizardConfiguration config,
final Environment environment); }### Answer:
@Test public void buildsAIdResource() throws Exception { application.run(config, environment); verify(jersey).register(isA(IdResource.class)); }
@Test public void buildsAPingResource() throws Exception { application.run(config, environment); verify(jersey).register(isA(PingResource.class)); }
@Test public void buildsAVersionResource() throws Exception { application.run(config, environment); verify(jersey).register(isA(VersionResource.class)); } |
### Question:
IdWorker { public long getTimestamp() { return System.currentTimeMillis(); } IdWorker(final int workerId, final int datacenterId); IdWorker(final int workerId, final int datacenterId,
final long startSequence); IdWorker(final int workerId, final int datacenterId,
final boolean validateUserAgent); IdWorker(final int workerId, final int datacenterId,
final long startSequence, final boolean validateUserAgent); IdWorker(final int workerId, final int datacenterId,
final long startSequence, final boolean validateUserAgent,
final MetricRegistry registry); long getId(final String agent); int getWorkerId(); int getDatacenterId(); long getTimestamp(); long getSequence(); void setSequence(final long value); synchronized long nextId(); boolean isValidUserAgent(final String agent); static final long TWEPOCH; }### Answer:
@Test public void testAccurateTimestamp() throws Exception { final IdWorker worker = new IdWorker(1, 1); final Long time = System.currentTimeMillis(); assertThat(worker.getTimestamp() - time).isLessThan(50L); } |
### Question:
IdWorker { public int getWorkerId() { return this.workerId; } IdWorker(final int workerId, final int datacenterId); IdWorker(final int workerId, final int datacenterId,
final long startSequence); IdWorker(final int workerId, final int datacenterId,
final boolean validateUserAgent); IdWorker(final int workerId, final int datacenterId,
final long startSequence, final boolean validateUserAgent); IdWorker(final int workerId, final int datacenterId,
final long startSequence, final boolean validateUserAgent,
final MetricRegistry registry); long getId(final String agent); int getWorkerId(); int getDatacenterId(); long getTimestamp(); long getSequence(); void setSequence(final long value); synchronized long nextId(); boolean isValidUserAgent(final String agent); static final long TWEPOCH; }### Answer:
@Test public void testWorkerId() throws Exception { final IdWorker worker = new IdWorker(1, 1); assertThat(worker.getWorkerId()).isEqualTo(1); } |
### Question:
IdWorker { public int getDatacenterId() { return this.datacenterId; } IdWorker(final int workerId, final int datacenterId); IdWorker(final int workerId, final int datacenterId,
final long startSequence); IdWorker(final int workerId, final int datacenterId,
final boolean validateUserAgent); IdWorker(final int workerId, final int datacenterId,
final long startSequence, final boolean validateUserAgent); IdWorker(final int workerId, final int datacenterId,
final long startSequence, final boolean validateUserAgent,
final MetricRegistry registry); long getId(final String agent); int getWorkerId(); int getDatacenterId(); long getTimestamp(); long getSequence(); void setSequence(final long value); synchronized long nextId(); boolean isValidUserAgent(final String agent); static final long TWEPOCH; }### Answer:
@Test public void testDatacenterId() throws Exception { final IdWorker worker = new IdWorker(1, 1); assertThat(worker.getDatacenterId()).isEqualTo(1); } |
### Question:
IdWorker { public boolean isValidUserAgent(final String agent) { if (!validateUserAgent) { return true; } final Matcher matcher = AGENT_PATTERN.matcher(agent); return matcher.matches(); } IdWorker(final int workerId, final int datacenterId); IdWorker(final int workerId, final int datacenterId,
final long startSequence); IdWorker(final int workerId, final int datacenterId,
final boolean validateUserAgent); IdWorker(final int workerId, final int datacenterId,
final long startSequence, final boolean validateUserAgent); IdWorker(final int workerId, final int datacenterId,
final long startSequence, final boolean validateUserAgent,
final MetricRegistry registry); long getId(final String agent); int getWorkerId(); int getDatacenterId(); long getTimestamp(); long getSequence(); void setSequence(final long value); synchronized long nextId(); boolean isValidUserAgent(final String agent); static final long TWEPOCH; }### Answer:
@Test public void testValidUserAgent() throws Exception { final IdWorker worker = new IdWorker(1, 1); assertTrue(worker.isValidUserAgent("infra-dm")); }
@Test public void testInvalidUserAgent() throws Exception { final IdWorker worker = new IdWorker(1, 1); assertFalse(worker.isValidUserAgent("1")); assertFalse(worker.isValidUserAgent("1asdf")); } |
### Question:
IdWorker { public long getId(final String agent) throws InvalidUserAgentError, InvalidSystemClock { if (!isValidUserAgent(agent)) { exceptionsCounter.inc(); throw new InvalidUserAgentError(); } final long id = nextId(); genCounter(agent); return id; } IdWorker(final int workerId, final int datacenterId); IdWorker(final int workerId, final int datacenterId,
final long startSequence); IdWorker(final int workerId, final int datacenterId,
final boolean validateUserAgent); IdWorker(final int workerId, final int datacenterId,
final long startSequence, final boolean validateUserAgent); IdWorker(final int workerId, final int datacenterId,
final long startSequence, final boolean validateUserAgent,
final MetricRegistry registry); long getId(final String agent); int getWorkerId(); int getDatacenterId(); long getTimestamp(); long getSequence(); void setSequence(final long value); synchronized long nextId(); boolean isValidUserAgent(final String agent); static final long TWEPOCH; }### Answer:
@Test public void testGetIdInvalidUserAgent() throws Exception { final IdWorker worker = new IdWorker(1, 1); try { worker.getId("1"); failBecauseExceptionWasNotThrown(InvalidUserAgentError.class); } catch (InvalidUserAgentError e) { } }
@Test public void testGetId() throws Exception { final IdWorker worker = new IdWorker(1, 1); final long id = worker.getId("infra-dm"); assertThat(id).isGreaterThan(0L); } |
### Question:
SnowizardError { @Override public boolean equals(final Object obj) { if (this == obj) { return true; } if ((obj == null) || (getClass() != obj.getClass())) { return false; } final SnowizardError other = (SnowizardError) obj; return Objects.equals(code, other.code) && Objects.equals(message, other.message); } @JsonCreator SnowizardError(@JsonProperty("code") final int code,
@JsonProperty("message") final String message); @JsonProperty int getCode(); @JsonProperty String getMessage(); @Override boolean equals(final Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() { final SnowizardError error2 = new SnowizardError(123, "this is bad"); assertThat(error2).isEqualTo(error); } |
### Question:
SnowizardError { @Override public String toString() { return MoreObjects.toStringHelper(this).add("code", code) .add("message", message).toString(); } @JsonCreator SnowizardError(@JsonProperty("code") final int code,
@JsonProperty("message") final String message); @JsonProperty int getCode(); @JsonProperty String getMessage(); @Override boolean equals(final Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testToString() { final String expected = "SnowizardError{code=123, message=this is bad}"; assertThat(error.toString()).isEqualTo(expected); } |
### Question:
SnowizardError { @Override public int hashCode() { return Objects.hash(code, message); } @JsonCreator SnowizardError(@JsonProperty("code") final int code,
@JsonProperty("message") final String message); @JsonProperty int getCode(); @JsonProperty String getMessage(); @Override boolean equals(final Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testHashCode() { assertThat(error.hashCode()).isEqualTo(-2046259593); } |
### Question:
Id { @Override public boolean equals(final Object obj) { if (this == obj) { return true; } if ((obj == null) || (getClass() != obj.getClass())) { return false; } final Id other = (Id) obj; return Objects.equals(id, other.id) && Objects.equals(idStr, other.idStr); } @JsonCreator Id(@JsonProperty("id") final long id,
@JsonProperty("id_str") final String idStr); Id(final long id); @JsonProperty long getId(); @JsonProperty("id_str") String getIdAsString(); @Override boolean equals(final Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() { final Id id2 = new Id(1234L); assertThat(id2).isEqualTo(id); } |
### Question:
Id { @Override public String toString() { return MoreObjects.toStringHelper(this).add("id", id) .add("idStr", idStr).toString(); } @JsonCreator Id(@JsonProperty("id") final long id,
@JsonProperty("id_str") final String idStr); Id(final long id); @JsonProperty long getId(); @JsonProperty("id_str") String getIdAsString(); @Override boolean equals(final Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testToString() { final String expected = "Id{id=1234, idStr=1234}"; assertThat(id.toString()).isEqualTo(expected); } |
### Question:
Id { @Override public int hashCode() { return Objects.hash(id, idStr); } @JsonCreator Id(@JsonProperty("id") final long id,
@JsonProperty("id_str") final String idStr); Id(final long id); @JsonProperty long getId(); @JsonProperty("id_str") String getIdAsString(); @Override boolean equals(final Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testHashCode() { assertThat(id.hashCode()).isEqualTo(1548657); } |
### Question:
IdResource { @GET @Timed @JSONP(callback = "callback", queryParam = "callback") @Produces({ MediaType.APPLICATION_JSON, MediaTypeAdditional.APPLICATION_JAVASCRIPT }) @CacheControl(mustRevalidate = true, noCache = true, noStore = true) public Id getIdAsJSON( @HeaderParam(HttpHeaders.USER_AGENT) final String agent) { return new Id(getId(agent)); } IdResource(final IdWorker worker); long getId(final String agent); @GET @Timed @Produces(MediaType.TEXT_PLAIN) @CacheControl(mustRevalidate = true, noCache = true, noStore = true) String getIdAsString(
@HeaderParam(HttpHeaders.USER_AGENT) final String agent); @GET @Timed @JSONP(callback = "callback", queryParam = "callback") @Produces({ MediaType.APPLICATION_JSON, MediaTypeAdditional.APPLICATION_JAVASCRIPT }) @CacheControl(mustRevalidate = true, noCache = true, noStore = true) Id getIdAsJSON(
@HeaderParam(HttpHeaders.USER_AGENT) final String agent); @GET @Timed @Produces(ProtocolBufferMediaType.APPLICATION_PROTOBUF) @CacheControl(mustRevalidate = true, noCache = true, noStore = true) SnowizardResponse getIdAsProtobuf(
@HeaderParam(HttpHeaders.USER_AGENT) final String agent,
@QueryParam("count") final Optional<IntParam> count); }### Answer:
@Test public void testGetIdAsJSON() throws Exception { final long id = 100L; when(worker.getId(AGENT)).thenReturn(id); final Id actual = resources.client().target("/") .request(MediaType.APPLICATION_JSON) .header(HttpHeaders.USER_AGENT, AGENT).get(Id.class); final Id expected = new Id(id); assertThat(actual).isEqualTo(expected); verify(worker).getId(AGENT); } |
### Question:
IdResource { @GET @Timed @Produces(ProtocolBufferMediaType.APPLICATION_PROTOBUF) @CacheControl(mustRevalidate = true, noCache = true, noStore = true) public SnowizardResponse getIdAsProtobuf( @HeaderParam(HttpHeaders.USER_AGENT) final String agent, @QueryParam("count") final Optional<IntParam> count) { final List<Long> ids = Lists.newArrayList(); if (count.isPresent()) { for (int i = 0; i < count.get().get(); i++) { ids.add(getId(agent)); } } else { ids.add(getId(agent)); } return SnowizardResponse.newBuilder().addAllId(ids).build(); } IdResource(final IdWorker worker); long getId(final String agent); @GET @Timed @Produces(MediaType.TEXT_PLAIN) @CacheControl(mustRevalidate = true, noCache = true, noStore = true) String getIdAsString(
@HeaderParam(HttpHeaders.USER_AGENT) final String agent); @GET @Timed @JSONP(callback = "callback", queryParam = "callback") @Produces({ MediaType.APPLICATION_JSON, MediaTypeAdditional.APPLICATION_JAVASCRIPT }) @CacheControl(mustRevalidate = true, noCache = true, noStore = true) Id getIdAsJSON(
@HeaderParam(HttpHeaders.USER_AGENT) final String agent); @GET @Timed @Produces(ProtocolBufferMediaType.APPLICATION_PROTOBUF) @CacheControl(mustRevalidate = true, noCache = true, noStore = true) SnowizardResponse getIdAsProtobuf(
@HeaderParam(HttpHeaders.USER_AGENT) final String agent,
@QueryParam("count") final Optional<IntParam> count); }### Answer:
@Test public void testGetIdAsProtobuf() throws Exception { final long id = 100L; when(worker.getId(AGENT)).thenReturn(id); final Response response = resources.client().target("/") .register(new ProtocolBufferMessageBodyProvider()) .request(ProtocolBufferMediaType.APPLICATION_PROTOBUF) .header(HttpHeaders.USER_AGENT, AGENT).get(); final SnowizardResponse actual = response .readEntity(SnowizardResponse.class); final SnowizardResponse expected = SnowizardResponse.newBuilder() .addId(id).build(); assertThat(response.getStatus()).isEqualTo(200); assertThat(actual).isEqualTo(expected); verify(worker).getId(AGENT); } |
### Question:
EntityFactory { public static <T extends Base> T createEntity(Class<T> clazz) throws UserInterfaceDalErrorException { Assert.notNull(clazz, "The class of the entity interface is null."); try { if (clazz.isInterface()) { clazz = EntityFactory.getEntityClass(clazz); } return clazz.newInstance(); } catch (ClassNotFoundException | IllegalAccessException | InstantiationException ex) { if (logger.isErrorEnabled()) { logger.error(String.format("Create entity[%s] fail.", clazz.getName()), ex); } throw new UserInterfaceDalErrorException(UserInterfaceDalErrorException.DalErrors.ENTITY_INSTANCE_FAIL); } } @SuppressWarnings("unchecked") static Class<T> getEntityClass(Class<T> clazz); static T createEntity(Class<T> clazz); }### Answer:
@Test public void testInterface () { User user = EntityFactory.createEntity(User.class); assertNotNull(user); assertNull(user.getCode()); user.setCode("john"); assertNotNull(user.getCode()); assertEquals("john", user.getCode()); }
@Test public void testEntity() { User user = EntityFactory.createEntity(UserEntity.class); assertNotNull(user); assertNull(user.getCode()); user.setCode("john"); assertNotNull(user.getCode()); assertEquals("john", user.getCode()); } |
### Question:
TypeUtils { public static float string2Float(String str, float defaultValue) { try { if (!StringUtils.isBlank(str)) { return Float.parseFloat(str); } } catch (NumberFormatException ex) { if (logger.isWarnEnabled()) { logger.warn(String.format("Parse %s to float fail, default: %f.", str, defaultValue)); } } return defaultValue; } private TypeUtils(); static int byteArray2Int(byte[] bytes); static long byteArray2Long(byte[] bytes); static byte[] int2ByteArray(int i); static byte[] long2ByteArray(long l); static String byteArray2Ipv4(byte[] bytes); static String byteArray2Ipv6(byte[] bytes); static String byteArray2Ip(byte[] bytes); static List<String> csv2List(String line); static byte[] Ip2byteArrayV4(String ipv4); static byte[] Ip2byteArrayV6(String ipv6); static byte[] Ip2byteArray(String ip); static String byteArray2HexString(byte[] byteArray); static String intArray2HexString(int[] intArray); static String longArray2HexString(int[] longArray); static String byteArray2Base64(byte[] value); static byte[] base642ByteArray(String base64Str); static String byte2HexString(byte b); static byte[] hexString2ByteArray(String input); static boolean string2Boolean(String str, boolean defaultValue); static int string2Int(String str, Radix radix, int defaultValue); static long string2Long(String str, Radix radix, long defaultValue); static float string2Float(String str, float defaultValue); static double string2Double(String str, double defaultValue); static long string2Size(String size, long defaultValue); static long string2TimePeriod(String timePeriod, long defaultValue); static boolean equals(T t1, T t2); static boolean maybeUpdate(T tar, T src); static final long KB; static final long MB; static final long GB; static final long TB; static final long PB; static final long SEC; static final long MIN; static final long HOUR; static final long DAY; static final long WEEK; static final long MON; static final long QUAR; static final long YEAR; }### Answer:
@Test public void testString2Float() { assertEquals(0, TypeUtils.string2Float(null, 0), 5); assertEquals(0, TypeUtils.string2Float("", 0), 5); assertEquals(0, TypeUtils.string2Float("0", 0), 5); assertEquals(0.1, TypeUtils.string2Float("0.1", 0), 5); assertEquals(1.1234, TypeUtils.string2Float("1.1234", 0), 5); assertEquals(1.12345, TypeUtils.string2Float("1.12345", 0), 5); assertEquals(1.12346, TypeUtils.string2Float("1.123456", 0), 5); assertEquals(1.12346, TypeUtils.string2Float("1.123456789", 0), 5); assertEquals(1234.12345, TypeUtils.string2Float("1234.12345", 0), 5); assertEquals(1234.12346, TypeUtils.string2Float("1234.1234567", 0), 5); assertEquals(1234.123451, TypeUtils.string2Float("1234.12345123", 0), 6); } |
### Question:
TypeUtils { public static double string2Double(String str, double defaultValue) { try { if (!StringUtils.isBlank(str)) { return Double.parseDouble(str); } } catch (NumberFormatException ex) { if (logger.isWarnEnabled()) { logger.warn(String.format("Parse %s to double fail, default: %f.", str, defaultValue)); } } return defaultValue; } private TypeUtils(); static int byteArray2Int(byte[] bytes); static long byteArray2Long(byte[] bytes); static byte[] int2ByteArray(int i); static byte[] long2ByteArray(long l); static String byteArray2Ipv4(byte[] bytes); static String byteArray2Ipv6(byte[] bytes); static String byteArray2Ip(byte[] bytes); static List<String> csv2List(String line); static byte[] Ip2byteArrayV4(String ipv4); static byte[] Ip2byteArrayV6(String ipv6); static byte[] Ip2byteArray(String ip); static String byteArray2HexString(byte[] byteArray); static String intArray2HexString(int[] intArray); static String longArray2HexString(int[] longArray); static String byteArray2Base64(byte[] value); static byte[] base642ByteArray(String base64Str); static String byte2HexString(byte b); static byte[] hexString2ByteArray(String input); static boolean string2Boolean(String str, boolean defaultValue); static int string2Int(String str, Radix radix, int defaultValue); static long string2Long(String str, Radix radix, long defaultValue); static float string2Float(String str, float defaultValue); static double string2Double(String str, double defaultValue); static long string2Size(String size, long defaultValue); static long string2TimePeriod(String timePeriod, long defaultValue); static boolean equals(T t1, T t2); static boolean maybeUpdate(T tar, T src); static final long KB; static final long MB; static final long GB; static final long TB; static final long PB; static final long SEC; static final long MIN; static final long HOUR; static final long DAY; static final long WEEK; static final long MON; static final long QUAR; static final long YEAR; }### Answer:
@Test public void testString2Double() { assertEquals(0, TypeUtils.string2Double(null, 0), 5); assertEquals(0, TypeUtils.string2Double("", 0), 5); assertEquals(0, TypeUtils.string2Double("0", 0), 5); assertEquals(0.1, TypeUtils.string2Double("0.1", 0), 5); assertEquals(1.1234, TypeUtils.string2Double("1.1234", 0), 5); assertEquals(1.12345, TypeUtils.string2Double("1.12345", 0), 5); assertEquals(1.12346, TypeUtils.string2Double("1.123456", 0), 5); assertEquals(1.12346, TypeUtils.string2Double("1.123456789", 0), 5); assertEquals(1234.12345, TypeUtils.string2Double("1234.12345", 0), 5); assertEquals(1234.12346, TypeUtils.string2Double("1234.1234567", 0), 5); assertEquals(1234.123451, TypeUtils.string2Double("1234.12345123", 0), 6); } |
### Question:
DigestUtils { public static String md5(String src) { return md5(src, BASE64); } private DigestUtils(); static String uuid(); static long crc32(byte[] bytes); static String toBase64(byte[] input); static byte[] fromBase64(String base64); static void importCert2Keystore(String keystorePath, String password, String host, int port); static String md5(String src); static String md5(String src, EncodeType encodeType); static String sha1(String src); static String sha1(String src, EncodeType encodeType); static String sha256(String src); static String sha256(String src, EncodeType encodeType); }### Answer:
@Test public void testBase64() { assertEquals("5PWKgFpuH9D2vvWMhvnOsw==", DigestUtils.md5("I love you")); } |
### Question:
DigestUtils { public static long crc32(byte[] bytes) { CRC32 crc32 = new CRC32(); if (bytes != null) { crc32.update(bytes); } return crc32.getValue(); } private DigestUtils(); static String uuid(); static long crc32(byte[] bytes); static String toBase64(byte[] input); static byte[] fromBase64(String base64); static void importCert2Keystore(String keystorePath, String password, String host, int port); static String md5(String src); static String md5(String src, EncodeType encodeType); static String sha1(String src); static String sha1(String src, EncodeType encodeType); static String sha256(String src); static String sha256(String src, EncodeType encodeType); }### Answer:
@Test public void testCrc32() { assertEquals(getCrc32(null), DigestUtils.crc32(null)); String testStr = "{\"log\":{\"content\":\"2\",\"time\":\"2016-01-05 10:17:24\",\"type\":1001,\"version\":\"[5.0.8.12]\"},\"pcInfo\":{\"ip\":\"192.168.118.57\",\"mac\":\"94-DE-80-A8-E6-EC\",\"onlyId\":\"7CE81DDBF7D05F6AD89CD7D79FAA5905\"},\"user\":{\"name\":\"CFM\"}}"; assertEquals(getCrc32(testStr.getBytes()), DigestUtils.crc32(testStr.getBytes())); assertEquals(getCrc32(TypeUtils.long2ByteArray(123456L)), DigestUtils.crc32(TypeUtils.long2ByteArray(123456L))); } |
### Question:
PasswordUtils { public static PasswordStrengthen checkStrengthen(String password) { if (StringUtils.isBlank(password)) { return PasswordStrengthen.LOW; } int length = password.length(); int containTypes = 0; if (length > 6) { if (password.matches(".*[\\d]+.*")) { containTypes++; } if (password.matches(".*[a-z]+.*")) { containTypes++; } if (password.matches(".*[A-Z]+.*")) { containTypes++; } if (password.matches(".*[`~!@#$%^&()\\-=_+,./<>?'|{}\\[\\]\\\\]+.*")) { containTypes++; } } switch (containTypes) { case 4: return PasswordStrengthen.HIGHER; case 3: return PasswordStrengthen.HIGH; case 2: return PasswordStrengthen.MEDIUM; default: return PasswordStrengthen.LOW; } } private PasswordUtils(); static PasswordStrengthen checkStrengthen(String password); static final int PASSWORD_DIGITAL; }### Answer:
@Test public void testPasswordStrengthen() { assertEquals(PasswordStrengthen.LOW, PasswordUtils.checkStrengthen(null)); assertEquals(PasswordStrengthen.LOW, PasswordUtils.checkStrengthen("")); assertEquals(PasswordStrengthen.LOW, PasswordUtils.checkStrengthen(" ")); assertEquals(PasswordStrengthen.LOW, PasswordUtils.checkStrengthen("abcd")); assertEquals(PasswordStrengthen.LOW, PasswordUtils.checkStrengthen("abcdefghij")); assertEquals(PasswordStrengthen.LOW, PasswordUtils.checkStrengthen("ABCD")); assertEquals(PasswordStrengthen.LOW, PasswordUtils.checkStrengthen("123456")); assertEquals(PasswordStrengthen.LOW, PasswordUtils.checkStrengthen("!@#$")); assertEquals(PasswordStrengthen.MEDIUM, PasswordUtils.checkStrengthen("abcdefgAB")); assertEquals(PasswordStrengthen.MEDIUM, PasswordUtils.checkStrengthen("124asdfas")); assertEquals(PasswordStrengthen.MEDIUM, PasswordUtils.checkStrengthen("SDSDKJ345234")); assertEquals(PasswordStrengthen.MEDIUM, PasswordUtils.checkStrengthen("345345@#$")); assertEquals(PasswordStrengthen.MEDIUM, PasswordUtils.checkStrengthen("sdasd&^%%")); assertEquals(PasswordStrengthen.MEDIUM, PasswordUtils.checkStrengthen("JHJD&^%$")); assertEquals(PasswordStrengthen.HIGH, PasswordUtils.checkStrengthen("asdlkj2342JHD")); assertEquals(PasswordStrengthen.HIGH, PasswordUtils.checkStrengthen("askdjfDJFD&^#@")); assertEquals(PasswordStrengthen.HIGH, PasswordUtils.checkStrengthen("23423DJHF!@#")); assertEquals(PasswordStrengthen.HIGH, PasswordUtils.checkStrengthen("skdjfsk345345$#%^")); assertEquals(PasswordStrengthen.HIGHER, PasswordUtils.checkStrengthen("asdkfj234627JDFJ@$#$")); } |
### Question:
ClassUtils { public static List<String> scanPackage(String packageName) { return scanPackage(packageName, true, true); } private ClassUtils(); static List<String> scanPackage(String packageName); static void scanPackage(String packageName, Consumer<String> action); static List<String> scanPackage(String packageName, boolean recurse, boolean ignoreInlineClass); static void scanPackage(String packageName, final boolean recurse, final boolean ignoreInlineClass,
final Consumer<String> action); }### Answer:
@Test public void test() { List<String> list1 = ClassUtils.scanPackage("org.mx"); List<String> list2 = ClassUtils.scanPackage("org.mx", true, true); assertEquals(list1, list2); assertTrue(list1.contains("org.mx.ClassUtils")); assertTrue(list1.contains("org.mx.FileUtils")); assertTrue(list1.contains("org.mx.TypeUtils")); assertTrue(list1.contains("org.mx.RandomUtils")); assertTrue(list1.contains("org.mx.config.SystemConfig")); assertTrue(list1.contains("org.mx.error.UserInterfaceError")); List<String> list3 = ClassUtils.scanPackage("org.mx", true, false); assertTrue(list3.contains("org.mx.ClassUtils")); assertTrue(list3.contains("org.mx.FileUtils")); assertTrue(list3.contains("org.mx.TypeUtils$Radix")); assertTrue(list3.contains("org.mx.RandomUtils")); assertTrue(list3.contains("org.mx.config.SystemConfig")); assertTrue(list3.contains("org.mx.rate.GeneralTopNRate$ValueType")); assertTrue(list3.contains("org.mx.rate.FloatTopNRate")); assertTrue(list3.contains("org.mx.error.UserInterfaceError")); List<String> list4 = ClassUtils.scanPackage("org.mx", false, true); assertTrue(list4.contains("org.mx.ClassUtils")); assertTrue(list4.contains("org.mx.FileUtils")); assertTrue(list4.contains("org.mx.TypeUtils")); assertTrue(list4.contains("org.mx.RandomUtils")); assertFalse(list4.contains("org.mx.config.SystemConfig")); assertFalse(list4.contains("org.mx.error.UserInterfaceError")); } |
### Question:
StringUtils { public static boolean isBlank(String str) { if (str == null) { return true; } else { str = str.trim(); if (str.length() <= 0) { return true; } else if ("null".equalsIgnoreCase(str) || "undefined".equalsIgnoreCase(str)) { return true; } else { return false; } } } private StringUtils(); static String byte2Base64String(byte[] value); static byte[] Base64String2Byte(String base64Str); static String byte2HexString(byte b); static byte[] hexString2Byte(String input); static String byte2HexString(byte[] bs); static boolean isBlank(String str); static boolean isChinese(String str); static boolean isChinese(char c); static String merge(Collection<?> coll); static String merge(Collection<?> coll, char separate); static String merge(Collection<?> coll, String separate); static String merge(String[] str); static String merge(String[] str, char separate); static String merge(String[] str, String separate); static String merge(String str, int length); static String merge(String str, int length, String separate); static String merge(String str, int length, char separate); static String repeat(int length, String str); static String[] split(String s); static String[] split(String s, boolean trimTokens, boolean ignoreEmptyTokens); static String[] split(String s, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens); static boolean string2Boolean(String str, boolean defaultValue); static int string2Int(String str, TypeUtils.Radix radix, int defaultValue); static long string2Long(String str, TypeUtils.Radix radix, long defaultValue); static float string2Float(String str, float defaultValue); static double string2Double(String str, double defaultValue); static long string2Size(String size, long defaultValue); static long stirng2TimePeriod(String timePeriod, long defaultValue); static String truncate(String src, int length); static String xmlEscape(String str); static String xmlUnescape(String str); static final char DEFAULT_SEPARATOR; static final String DELIMITERS; }### Answer:
@Test public void testIsBlank() { String[] blanks = {null , "", " ", "null", "Null", "NULL", "undefined", "UNDEFINED", "Undefined"}; String[] notBlanks = {"a", "1", " a", " a ", " 1 ", "a13 ", " a13 "}; for (String str : blanks) { assertTrue(StringUtils.isBlank(str)); } for (String str : notBlanks) { assertFalse(StringUtils.isBlank(str)); } } |
### Question:
StringUtils { public static String truncate(String src, int length) { if (src == null || src.length() <= length) { return src; } return String.format("%s...", src.substring(0, length)); } private StringUtils(); static String byte2Base64String(byte[] value); static byte[] Base64String2Byte(String base64Str); static String byte2HexString(byte b); static byte[] hexString2Byte(String input); static String byte2HexString(byte[] bs); static boolean isBlank(String str); static boolean isChinese(String str); static boolean isChinese(char c); static String merge(Collection<?> coll); static String merge(Collection<?> coll, char separate); static String merge(Collection<?> coll, String separate); static String merge(String[] str); static String merge(String[] str, char separate); static String merge(String[] str, String separate); static String merge(String str, int length); static String merge(String str, int length, String separate); static String merge(String str, int length, char separate); static String repeat(int length, String str); static String[] split(String s); static String[] split(String s, boolean trimTokens, boolean ignoreEmptyTokens); static String[] split(String s, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens); static boolean string2Boolean(String str, boolean defaultValue); static int string2Int(String str, TypeUtils.Radix radix, int defaultValue); static long string2Long(String str, TypeUtils.Radix radix, long defaultValue); static float string2Float(String str, float defaultValue); static double string2Double(String str, double defaultValue); static long string2Size(String size, long defaultValue); static long stirng2TimePeriod(String timePeriod, long defaultValue); static String truncate(String src, int length); static String xmlEscape(String str); static String xmlUnescape(String str); static final char DEFAULT_SEPARATOR; static final String DELIMITERS; }### Answer:
@Test public void testTruncate() { String[] src = { null, "", "123", "abc", "ABC", "中华人", "12345", "abcde", "ABCDE", "中华人民共", "1234567890", "abcdefghij", "ABCDEFGHIJK", "中华人民共和国万岁！" }; String[] tar = { null, "", "123", "abc", "ABC", "中华人", "12345", "abcde", "ABCDE", "中华人民共", "12345...", "abcde...", "ABCDE...", "中华人民共..." }; for (int index =0; index < src.length; index ++) { assertEquals(tar[index], StringUtils.truncate(src[index], 5)); } } |
### Question:
StringUtils { public static String repeat(int length, String str) { if (length <= 0) { return ""; } if (isBlank(str)) { str = " "; } StringBuffer sb = new StringBuffer(length + str.length()); for (int index = 0; index < length / str.length() + 1; index ++) { sb.append(str); } return sb.substring(0, length); } private StringUtils(); static String byte2Base64String(byte[] value); static byte[] Base64String2Byte(String base64Str); static String byte2HexString(byte b); static byte[] hexString2Byte(String input); static String byte2HexString(byte[] bs); static boolean isBlank(String str); static boolean isChinese(String str); static boolean isChinese(char c); static String merge(Collection<?> coll); static String merge(Collection<?> coll, char separate); static String merge(Collection<?> coll, String separate); static String merge(String[] str); static String merge(String[] str, char separate); static String merge(String[] str, String separate); static String merge(String str, int length); static String merge(String str, int length, String separate); static String merge(String str, int length, char separate); static String repeat(int length, String str); static String[] split(String s); static String[] split(String s, boolean trimTokens, boolean ignoreEmptyTokens); static String[] split(String s, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens); static boolean string2Boolean(String str, boolean defaultValue); static int string2Int(String str, TypeUtils.Radix radix, int defaultValue); static long string2Long(String str, TypeUtils.Radix radix, long defaultValue); static float string2Float(String str, float defaultValue); static double string2Double(String str, double defaultValue); static long string2Size(String size, long defaultValue); static long stirng2TimePeriod(String timePeriod, long defaultValue); static String truncate(String src, int length); static String xmlEscape(String str); static String xmlUnescape(String str); static final char DEFAULT_SEPARATOR; static final String DELIMITERS; }### Answer:
@Test public void testRepeat() { assertEquals("", StringUtils.repeat(0, null)); assertEquals(" ", StringUtils.repeat(1, null)); assertEquals(" ", StringUtils.repeat(1, " ")); assertEquals(",", StringUtils.repeat(1, ",1a")); assertEquals(" ", StringUtils.repeat(2, null)); assertEquals(" ", StringUtils.repeat(2, " ")); assertEquals(",1", StringUtils.repeat(2, ",1a")); assertEquals(" ", StringUtils.repeat(3, null)); assertEquals(" ", StringUtils.repeat(3, " ")); assertEquals(",1a", StringUtils.repeat(3, ",1a")); assertEquals(" ", StringUtils.repeat(7, null)); assertEquals(" ", StringUtils.repeat(7, " ")); assertEquals(",1a,1a,", StringUtils.repeat(7, ",1a")); } |
### Question:
TypeUtils { public static <T> boolean equals(T t1, T t2) { if (t1 == null && t2 == null) { return true; } else if (t1 != null && t2 != null) { return t1.toString().equals(t2.toString()); } else { return false; } } private TypeUtils(); static int byteArray2Int(byte[] bytes); static long byteArray2Long(byte[] bytes); static byte[] int2ByteArray(int i); static byte[] long2ByteArray(long l); static String byteArray2Ipv4(byte[] bytes); static String byteArray2Ipv6(byte[] bytes); static String byteArray2Ip(byte[] bytes); static List<String> csv2List(String line); static byte[] Ip2byteArrayV4(String ipv4); static byte[] Ip2byteArrayV6(String ipv6); static byte[] Ip2byteArray(String ip); static String byteArray2HexString(byte[] byteArray); static String intArray2HexString(int[] intArray); static String longArray2HexString(int[] longArray); static String byteArray2Base64(byte[] value); static byte[] base642ByteArray(String base64Str); static String byte2HexString(byte b); static byte[] hexString2ByteArray(String input); static boolean string2Boolean(String str, boolean defaultValue); static int string2Int(String str, Radix radix, int defaultValue); static long string2Long(String str, Radix radix, long defaultValue); static float string2Float(String str, float defaultValue); static double string2Double(String str, double defaultValue); static long string2Size(String size, long defaultValue); static long string2TimePeriod(String timePeriod, long defaultValue); static boolean equals(T t1, T t2); static boolean maybeUpdate(T tar, T src); static final long KB; static final long MB; static final long GB; static final long TB; static final long PB; static final long SEC; static final long MIN; static final long HOUR; static final long DAY; static final long WEEK; static final long MON; static final long QUAR; static final long YEAR; }### Answer:
@Test public void testEquals() { String str1 = "12"; int i1 = 12; Integer I1 = 12; long l1 = 12; Long L1 = 12L; float f1 = 12.12F; Float F1 = 12.12F; double d1 = 12.12; Double D1 = 12.12; assertTrue(TypeUtils.equals(null, null)); assertFalse(TypeUtils.equals(null, str1)); assertFalse(TypeUtils.equals(null, i1)); assertFalse(TypeUtils.equals(null, I1)); assertFalse(TypeUtils.equals(null, l1)); assertFalse(TypeUtils.equals(null, L1)); assertFalse(TypeUtils.equals(null, f1)); assertFalse(TypeUtils.equals(null, F1)); assertFalse(TypeUtils.equals(null, d1)); assertFalse(TypeUtils.equals(null, D1)); assertTrue(TypeUtils.equals(str1, i1)); assertTrue(TypeUtils.equals(str1, I1)); assertTrue(TypeUtils.equals(str1, L1)); assertTrue(TypeUtils.equals(i1, I1)); assertTrue(TypeUtils.equals(i1, l1)); assertTrue(TypeUtils.equals(i1, L1)); assertTrue(TypeUtils.equals(l1, I1)); assertTrue(TypeUtils.equals(f1, F1)); assertTrue(TypeUtils.equals(d1, D1)); assertTrue(TypeUtils.equals(f1, D1)); } |
### Question:
TypeUtils { public static boolean string2Boolean(String str, boolean defaultValue) { if ("true".equalsIgnoreCase(str)) { return true; } else if ("false".equalsIgnoreCase(str)) { return false; } else { return defaultValue; } } private TypeUtils(); static int byteArray2Int(byte[] bytes); static long byteArray2Long(byte[] bytes); static byte[] int2ByteArray(int i); static byte[] long2ByteArray(long l); static String byteArray2Ipv4(byte[] bytes); static String byteArray2Ipv6(byte[] bytes); static String byteArray2Ip(byte[] bytes); static List<String> csv2List(String line); static byte[] Ip2byteArrayV4(String ipv4); static byte[] Ip2byteArrayV6(String ipv6); static byte[] Ip2byteArray(String ip); static String byteArray2HexString(byte[] byteArray); static String intArray2HexString(int[] intArray); static String longArray2HexString(int[] longArray); static String byteArray2Base64(byte[] value); static byte[] base642ByteArray(String base64Str); static String byte2HexString(byte b); static byte[] hexString2ByteArray(String input); static boolean string2Boolean(String str, boolean defaultValue); static int string2Int(String str, Radix radix, int defaultValue); static long string2Long(String str, Radix radix, long defaultValue); static float string2Float(String str, float defaultValue); static double string2Double(String str, double defaultValue); static long string2Size(String size, long defaultValue); static long string2TimePeriod(String timePeriod, long defaultValue); static boolean equals(T t1, T t2); static boolean maybeUpdate(T tar, T src); static final long KB; static final long MB; static final long GB; static final long TB; static final long PB; static final long SEC; static final long MIN; static final long HOUR; static final long DAY; static final long WEEK; static final long MON; static final long QUAR; static final long YEAR; }### Answer:
@Test public void testString2Boolean() { assertFalse(TypeUtils.string2Boolean(null, false)); assertFalse(TypeUtils.string2Boolean("", false)); assertFalse(TypeUtils.string2Boolean("abc", false)); assertFalse(TypeUtils.string2Boolean("truea", false)); assertFalse(TypeUtils.string2Boolean("falsea", false)); assertFalse(TypeUtils.string2Boolean("Truead", false)); assertTrue(TypeUtils.string2Boolean("Truead", true)); assertTrue(TypeUtils.string2Boolean("true", false)); assertTrue(TypeUtils.string2Boolean("TRUE", false)); assertTrue(TypeUtils.string2Boolean("True", false)); assertTrue(TypeUtils.string2Boolean("TRUe", false)); assertTrue(TypeUtils.string2Boolean("trUE", false)); assertFalse(TypeUtils.string2Boolean("false", false)); assertFalse(TypeUtils.string2Boolean("false", true)); assertFalse(TypeUtils.string2Boolean("FALSE", true)); assertFalse(TypeUtils.string2Boolean("FALSe", true)); assertFalse(TypeUtils.string2Boolean("falsE", true)); assertFalse(TypeUtils.string2Boolean("faLSe", true)); } |
### Question:
UsergroupChangeUpdate extends Update { @Override public void applyUpdate(RepositorySet repositorySet) { UserGroup userGroupEntity = repositorySet.userGroupRepository .getGroup(usergroup.id); boolean newGroup = (userGroupEntity == null); if (newGroup) { userGroupEntity = new UserGroup(usergroup.id, usergroup.name); } else { userGroupEntity.setName(usergroup.name); } repositorySet.userGroupRepository .updateGroupMembers(usergroup.id, usergroup.members); Context ctx = TreffPunkt.getAppContext(); SharedPreferences pref = PreferenceManager .getDefaultSharedPreferences(ctx); int ownID = pref.getInt(ctx.getString(R.string.key_userId), -1); boolean kickedOut = true; for (int memberID : usergroup.members) if (memberID == ownID) kickedOut = false; if (kickedOut) repositorySet.userGroupRepository.removeGroup(userGroupEntity); else { if (newGroup) repositorySet.userGroupRepository.addGroup(userGroupEntity); else repositorySet.userGroupRepository.updateGroup(userGroupEntity); } } UsergroupChangeUpdate(@JsonProperty("time-created") Date timeCreated,
@JsonProperty("creator") int creator,
@JsonProperty("usergroup") CompleteUsergroup group); @Override void applyUpdate(RepositorySet repositorySet); }### Answer:
@Test public void applyUpdate() throws Exception { UsergroupChangeUpdate update = new UsergroupChangeUpdate(date, creator1, completeUsergroup); update.applyUpdate(mockRepos); verify(mockUserGroupRepository).getGroup(group1); verify(mockUsergroup).setName("Gruppe"); verify(mockUserGroupRepository).updateGroupMembers(group1, ids); verify(mockUserGroupRepository).removeGroup(mockUsergroup); }
@Test public void applUpdate2() { UsergroupChangeUpdate update2 = new UsergroupChangeUpdate(date, creator1, completeUsergroup2); update2.applyUpdate(mockRepos); verify(mockUserGroupRepository).getGroup(group1); verify(mockUsergroup).setName("Gruppe"); verify(mockUserGroupRepository).updateGroupMembers(group1, ids2); verify(mockUserGroupRepository).updateGroup(mockUsergroup); }
@Test public void applUpdate3() { UsergroupChangeUpdate update3 = new UsergroupChangeUpdate(date, creator1, completeUsergroup3); update3.applyUpdate(mockRepos); verify(mockUserGroupRepository).getGroup(group2); verify(mockUserGroupRepository).updateGroupMembers(group2, ids2); verify(mockUserGroupRepository).addGroup(mockUsergroup); } |
### Question:
ContactRequestUpdate extends Update { @Override public void applyUpdate(RepositorySet repositorySet) { User user = repositorySet.userRepository.getUser(creator); if (user != null) repositorySet.userRepository.setIsRequesting(creator, true); else { User.getPlaceholderAndScheduleQuery(creator, repositorySet.userRepository, u -> u.setRequesting(true)); } } ContactRequestUpdate(@JsonProperty("time-created") Date timeCreated,
@JsonProperty("creator") int creator); @Override void applyUpdate(RepositorySet repositorySet); }### Answer:
@Test public void applyUpdate() throws Exception { ContactRequestUpdate update = new ContactRequestUpdate(date, creator1); update.applyUpdate(mockRepos); verify(User.getPlaceholderAndScheduleQuery(creator1, mockUserRepository, u -> u.setRequesting(true))); }
@Test public void applyUpdate2() { ContactRequestUpdate update2 = new ContactRequestUpdate(date, creator2); update2.applyUpdate(mockRepos); verify(mockUserRepository).setIsRequesting(creator2, true); } |
### Question:
RemoveContactUpdate extends Update { @Override public void applyUpdate(RepositorySet repositorySet) { repositorySet.userRepository.setIsFriend(creator, false); } RemoveContactUpdate(@JsonProperty("time-created") Date timeCreated,
@JsonProperty("creator") int creator); @Override void applyUpdate(RepositorySet repositorySet); }### Answer:
@Test public void applyUpdate() throws Exception { RemoveContactUpdate update = new RemoveContactUpdate(date, creator1); update.applyUpdate(mockRepos); verify(mockUserRepository).setIsFriend(creator1, false); } |
### Question:
AbstractCommand { public abstract void onResponse(AbstractResponse response); protected AbstractCommand(
Class<? extends AbstractResponse> responseClass); abstract AbstractRequest getRequest(); abstract void onResponse(AbstractResponse response); Class<? extends AbstractResponse> getResponseClass(); }### Answer:
@Test public abstract void onResponseTest(); |
### Question:
AbstractCommand { public abstract AbstractRequest getRequest(); protected AbstractCommand(
Class<? extends AbstractResponse> responseClass); abstract AbstractRequest getRequest(); abstract void onResponse(AbstractResponse response); Class<? extends AbstractResponse> getResponseClass(); }### Answer:
@Test public abstract void getRequestTest(); |
### Question:
UserRepository { public User getUser(String username) { return userDao.getUserByName(username); } UserRepository(UserDao userDao, RequestEncoder encoder,
Handler backgroundHandler); LiveData<User> getUserLiveData(int userID); User getUser(String username); User getUser(int id); LiveData<PagedList<User>> getFriends(); LiveData<PagedList<User>> getFriendsAndPending(); LiveData<PagedList<User>> getAll(); LiveData<List<User>> getFriendsAsList(); LiveData<List<User>> getCurrentlySharing(); void updateSharing(); void setIsBlocked(int userId, boolean isBlocked); void setIsFriend(int userId, boolean isFriend); void setIsPending(int userId, boolean isPending); void setIsRequesting(int userId, boolean isRequesting); void setUserName(int userId, String username); void addUser(User user); void resetAllUsers(); void updateUser(User user); void requestAddUser(String username); void requestIsBlocked(int userId, boolean isBlocked); void requestAccept(int userId); void requestDecline(int userId); void requestCancel(int userId); void requestRefresh(); void deleteAllUsers(); }### Answer:
@Test public void getUserTest() { when(mockUserDao.getUserByName(mockUser.getUsername())).thenReturn (mockUser); assertEquals(testUserRepository.getUser(mockUser.getUsername()), mockUser); } |
### Question:
UserRepository { public void setIsBlocked(int userId, boolean isBlocked) { backgroundHandler.post(() -> { userDao.setBlocked(userId, isBlocked); }); } UserRepository(UserDao userDao, RequestEncoder encoder,
Handler backgroundHandler); LiveData<User> getUserLiveData(int userID); User getUser(String username); User getUser(int id); LiveData<PagedList<User>> getFriends(); LiveData<PagedList<User>> getFriendsAndPending(); LiveData<PagedList<User>> getAll(); LiveData<List<User>> getFriendsAsList(); LiveData<List<User>> getCurrentlySharing(); void updateSharing(); void setIsBlocked(int userId, boolean isBlocked); void setIsFriend(int userId, boolean isFriend); void setIsPending(int userId, boolean isPending); void setIsRequesting(int userId, boolean isRequesting); void setUserName(int userId, String username); void addUser(User user); void resetAllUsers(); void updateUser(User user); void requestAddUser(String username); void requestIsBlocked(int userId, boolean isBlocked); void requestAccept(int userId); void requestDecline(int userId); void requestCancel(int userId); void requestRefresh(); void deleteAllUsers(); }### Answer:
@Test public void blockUserTest() { testUserRepository.setIsBlocked(mockUser.getUserId(), true); testUserRepository.setIsBlocked(mockUser.getUserId(), false); verify(mockUserDao).setBlocked(mockUser.getUserId(), true); verify(mockUserDao).setBlocked(mockUser.getUserId(), false); } |
### Question:
UserRepository { public void setIsFriend(int userId, boolean isFriend) { backgroundHandler.post(() -> { userDao.setIsFriend(userId, isFriend); }); } UserRepository(UserDao userDao, RequestEncoder encoder,
Handler backgroundHandler); LiveData<User> getUserLiveData(int userID); User getUser(String username); User getUser(int id); LiveData<PagedList<User>> getFriends(); LiveData<PagedList<User>> getFriendsAndPending(); LiveData<PagedList<User>> getAll(); LiveData<List<User>> getFriendsAsList(); LiveData<List<User>> getCurrentlySharing(); void updateSharing(); void setIsBlocked(int userId, boolean isBlocked); void setIsFriend(int userId, boolean isFriend); void setIsPending(int userId, boolean isPending); void setIsRequesting(int userId, boolean isRequesting); void setUserName(int userId, String username); void addUser(User user); void resetAllUsers(); void updateUser(User user); void requestAddUser(String username); void requestIsBlocked(int userId, boolean isBlocked); void requestAccept(int userId); void requestDecline(int userId); void requestCancel(int userId); void requestRefresh(); void deleteAllUsers(); }### Answer:
@Test public void friendUserTest() { testUserRepository.setIsFriend(mockUser.getUserId(), true); testUserRepository.setIsFriend(mockUser.getUserId(), false); verify(mockUserDao).setIsFriend(mockUser.getUserId(), true); verify(mockUserDao).setIsFriend(mockUser.getUserId(), false); } |
### Question:
UserRepository { public void setIsPending(int userId, boolean isPending) { backgroundHandler.post(() -> { userDao.setIsPending(userId, isPending); }); } UserRepository(UserDao userDao, RequestEncoder encoder,
Handler backgroundHandler); LiveData<User> getUserLiveData(int userID); User getUser(String username); User getUser(int id); LiveData<PagedList<User>> getFriends(); LiveData<PagedList<User>> getFriendsAndPending(); LiveData<PagedList<User>> getAll(); LiveData<List<User>> getFriendsAsList(); LiveData<List<User>> getCurrentlySharing(); void updateSharing(); void setIsBlocked(int userId, boolean isBlocked); void setIsFriend(int userId, boolean isFriend); void setIsPending(int userId, boolean isPending); void setIsRequesting(int userId, boolean isRequesting); void setUserName(int userId, String username); void addUser(User user); void resetAllUsers(); void updateUser(User user); void requestAddUser(String username); void requestIsBlocked(int userId, boolean isBlocked); void requestAccept(int userId); void requestDecline(int userId); void requestCancel(int userId); void requestRefresh(); void deleteAllUsers(); }### Answer:
@Test public void pendingUserTest() { testUserRepository.setIsPending(mockUser.getUserId(), true); testUserRepository.setIsPending(mockUser.getUserId(), false); verify(mockUserDao).setIsPending(mockUser.getUserId(), true); verify(mockUserDao).setIsPending(mockUser.getUserId(), false); } |
### Question:
UserRepository { public void setIsRequesting(int userId, boolean isRequesting) { backgroundHandler.post(() -> { userDao.setIsRequesting(userId, isRequesting); }); } UserRepository(UserDao userDao, RequestEncoder encoder,
Handler backgroundHandler); LiveData<User> getUserLiveData(int userID); User getUser(String username); User getUser(int id); LiveData<PagedList<User>> getFriends(); LiveData<PagedList<User>> getFriendsAndPending(); LiveData<PagedList<User>> getAll(); LiveData<List<User>> getFriendsAsList(); LiveData<List<User>> getCurrentlySharing(); void updateSharing(); void setIsBlocked(int userId, boolean isBlocked); void setIsFriend(int userId, boolean isFriend); void setIsPending(int userId, boolean isPending); void setIsRequesting(int userId, boolean isRequesting); void setUserName(int userId, String username); void addUser(User user); void resetAllUsers(); void updateUser(User user); void requestAddUser(String username); void requestIsBlocked(int userId, boolean isBlocked); void requestAccept(int userId); void requestDecline(int userId); void requestCancel(int userId); void requestRefresh(); void deleteAllUsers(); }### Answer:
@Test public void requestUserTest() { testUserRepository.setIsRequesting(mockUser.getUserId(), true); testUserRepository.setIsRequesting(mockUser.getUserId(), false); verify(mockUserDao).setIsRequesting(mockUser.getUserId(), true); verify(mockUserDao).setIsRequesting(mockUser.getUserId(), false); } |
### Question:
UserRepository { public void setUserName(int userId, String username) { backgroundHandler.post(() -> { userDao.setUserName(userId, username); }); } UserRepository(UserDao userDao, RequestEncoder encoder,
Handler backgroundHandler); LiveData<User> getUserLiveData(int userID); User getUser(String username); User getUser(int id); LiveData<PagedList<User>> getFriends(); LiveData<PagedList<User>> getFriendsAndPending(); LiveData<PagedList<User>> getAll(); LiveData<List<User>> getFriendsAsList(); LiveData<List<User>> getCurrentlySharing(); void updateSharing(); void setIsBlocked(int userId, boolean isBlocked); void setIsFriend(int userId, boolean isFriend); void setIsPending(int userId, boolean isPending); void setIsRequesting(int userId, boolean isRequesting); void setUserName(int userId, String username); void addUser(User user); void resetAllUsers(); void updateUser(User user); void requestAddUser(String username); void requestIsBlocked(int userId, boolean isBlocked); void requestAccept(int userId); void requestDecline(int userId); void requestCancel(int userId); void requestRefresh(); void deleteAllUsers(); }### Answer:
@Test public void setUsernameTest() { testUserRepository.setUserName(mockUser.getUserId(), "New Username"); verify(mockUserDao).setUserName(mockUser.getUserId(), "New Username"); } |
### Question:
UserRepository { public void addUser(User user) { backgroundHandler.post(() -> { userDao.save(user); }); } UserRepository(UserDao userDao, RequestEncoder encoder,
Handler backgroundHandler); LiveData<User> getUserLiveData(int userID); User getUser(String username); User getUser(int id); LiveData<PagedList<User>> getFriends(); LiveData<PagedList<User>> getFriendsAndPending(); LiveData<PagedList<User>> getAll(); LiveData<List<User>> getFriendsAsList(); LiveData<List<User>> getCurrentlySharing(); void updateSharing(); void setIsBlocked(int userId, boolean isBlocked); void setIsFriend(int userId, boolean isFriend); void setIsPending(int userId, boolean isPending); void setIsRequesting(int userId, boolean isRequesting); void setUserName(int userId, String username); void addUser(User user); void resetAllUsers(); void updateUser(User user); void requestAddUser(String username); void requestIsBlocked(int userId, boolean isBlocked); void requestAccept(int userId); void requestDecline(int userId); void requestCancel(int userId); void requestRefresh(); void deleteAllUsers(); }### Answer:
@Test public void addUserTest() { testUserRepository.addUser(mockUser); verify(mockUserDao).save(mockUser); } |
### Question:
EventRepository { public void addEvent(Event event) { backgroundHandler.post(() -> { eventDao.save(event); }); } EventRepository(EventDao eventDao, RequestEncoder encoder,
Handler backgroundHandler); LiveData<PagedList<Event>> getEvents(); LiveData<PagedList<Event>> getEventsFromGroups(Set<Integer> idSet); LiveData<PagedList<Event>> getEventsFromGroup(int groupId); LiveData<Event> getEventLiveData(int eventId); Event getEvent(int eventId); void addEvent(Event event); void updateEvent(Event newEvent); void deleteEvent(int eventId); void requestAddEvent(int groupId, String name, Date start,
Date end, Location l); void requestDeleteEvent(int groupId, int eventId); void requestEditEvent(int eventId, int groupId, String title, Date
start, Date end, Location l); void deleteAllEvents(); void requestRefresh(); }### Answer:
@Test public void addEventTest() { testEventRepository.addEvent(mockEvent); verify(mockEventDao).save(mockEvent); } |
### Question:
EventRepository { public void updateEvent(Event newEvent) { eventDao.update(newEvent); } EventRepository(EventDao eventDao, RequestEncoder encoder,
Handler backgroundHandler); LiveData<PagedList<Event>> getEvents(); LiveData<PagedList<Event>> getEventsFromGroups(Set<Integer> idSet); LiveData<PagedList<Event>> getEventsFromGroup(int groupId); LiveData<Event> getEventLiveData(int eventId); Event getEvent(int eventId); void addEvent(Event event); void updateEvent(Event newEvent); void deleteEvent(int eventId); void requestAddEvent(int groupId, String name, Date start,
Date end, Location l); void requestDeleteEvent(int groupId, int eventId); void requestEditEvent(int eventId, int groupId, String title, Date
start, Date end, Location l); void deleteAllEvents(); void requestRefresh(); }### Answer:
@Test public void updateEventTest() { testEventRepository.updateEvent(mockEvent); verify(mockEventDao).update(mockEvent); } |
### Question:
EventRepository { public void deleteEvent(int eventId) { eventDao.delete(new Event(eventId, null, null, null, null, 0, 0)); } EventRepository(EventDao eventDao, RequestEncoder encoder,
Handler backgroundHandler); LiveData<PagedList<Event>> getEvents(); LiveData<PagedList<Event>> getEventsFromGroups(Set<Integer> idSet); LiveData<PagedList<Event>> getEventsFromGroup(int groupId); LiveData<Event> getEventLiveData(int eventId); Event getEvent(int eventId); void addEvent(Event event); void updateEvent(Event newEvent); void deleteEvent(int eventId); void requestAddEvent(int groupId, String name, Date start,
Date end, Location l); void requestDeleteEvent(int groupId, int eventId); void requestEditEvent(int eventId, int groupId, String title, Date
start, Date end, Location l); void deleteAllEvents(); void requestRefresh(); }### Answer:
@Test public void deleteEventTest() { testEventRepository.deleteEvent(mockEvent.getId()); verify(mockEventDao).delete(new Event(mockEvent.getId(), null, null, null, null, 0, 0)); } |
### Question:
EventRepository { public void requestAddEvent(int groupId, String name, Date start, Date end, Location l) { Context ctx = TreffPunkt.getAppContext(); SharedPreferences pref = PreferenceManager .getDefaultSharedPreferences(ctx); int creator = pref.getInt(ctx.getString(R.string.key_userId), -1); encoder.createEvent(groupId, name, creator, start, end, l); } EventRepository(EventDao eventDao, RequestEncoder encoder,
Handler backgroundHandler); LiveData<PagedList<Event>> getEvents(); LiveData<PagedList<Event>> getEventsFromGroups(Set<Integer> idSet); LiveData<PagedList<Event>> getEventsFromGroup(int groupId); LiveData<Event> getEventLiveData(int eventId); Event getEvent(int eventId); void addEvent(Event event); void updateEvent(Event newEvent); void deleteEvent(int eventId); void requestAddEvent(int groupId, String name, Date start,
Date end, Location l); void requestDeleteEvent(int groupId, int eventId); void requestEditEvent(int eventId, int groupId, String title, Date
start, Date end, Location l); void deleteAllEvents(); void requestRefresh(); }### Answer:
@Ignore @Test public void requestAddEventTest() { testEventRepository.requestAddEvent(mockEvent.getGroupId(), mockEvent .getName(), mockEvent.getStart(), mockEvent.getEnd(), mockEvent.getLocation()); } |
### Question:
UserGroupRepository { public void addGroup(UserGroup group) { backgroundHandler.post(() -> { userGroupDao.save(group); }); } UserGroupRepository(UserGroupDao userGroupDao,
UserDao userDao,
EventDao eventDao,
ChatDao chatDao,
RequestEncoder encoder,
Handler backgroundHandler); LiveData<UserGroup> getGroupLiveData(int id); UserGroup getGroup(int id); LiveData<PagedList<UserGroup>> getGroups(); LiveData<List<UserGroup>> getGroupsInList(); LiveData<List<User>> getGroupMembers(int groupId); void setIsSharing(int groupId, boolean isSharing); void addGroup(UserGroup group); void leaveGroup(UserGroup group); void removeGroup(UserGroup group); void addGroupMembers(int groupId, int[] members); void removeGroupMembers(int groupId, int[] members); void updateGroupMembers(int groupId, int[] newMembers); void updateGroup(UserGroup userGroup); void updateMembership(GroupMembership membership); void requestAddGroup(String groupName, int... members); void requestAddMembersToGroup(int groupId, int... members); void requestKickMembers(int groupId, int... members); void requestNameChange(int groupId, String newName); void requestRefresh(); void deleteAllGroups(); void deleteAllMemberships(); }### Answer:
@Test public void addGroupTest() { testUserGroupRepository.addGroup(mockGroup); verify(mockUserGroupDao).save(mockGroup); } |
### Question:
UserGroupRepository { public void addGroupMembers(int groupId, int[] members) { for (int i = 0; i < members.length; i++) { GroupMembership gms = new GroupMembership(members[i], groupId); userGroupDao.save(gms); } } UserGroupRepository(UserGroupDao userGroupDao,
UserDao userDao,
EventDao eventDao,
ChatDao chatDao,
RequestEncoder encoder,
Handler backgroundHandler); LiveData<UserGroup> getGroupLiveData(int id); UserGroup getGroup(int id); LiveData<PagedList<UserGroup>> getGroups(); LiveData<List<UserGroup>> getGroupsInList(); LiveData<List<User>> getGroupMembers(int groupId); void setIsSharing(int groupId, boolean isSharing); void addGroup(UserGroup group); void leaveGroup(UserGroup group); void removeGroup(UserGroup group); void addGroupMembers(int groupId, int[] members); void removeGroupMembers(int groupId, int[] members); void updateGroupMembers(int groupId, int[] newMembers); void updateGroup(UserGroup userGroup); void updateMembership(GroupMembership membership); void requestAddGroup(String groupName, int... members); void requestAddMembersToGroup(int groupId, int... members); void requestKickMembers(int groupId, int... members); void requestNameChange(int groupId, String newName); void requestRefresh(); void deleteAllGroups(); void deleteAllMemberships(); }### Answer:
@Test public void addMembersTest() { testUserGroupRepository .addGroupMembers(mockGroup.getGroupId(), testMemberIds); ArgumentCaptor<GroupMembership> gmCaptor = ArgumentCaptor.forClass(GroupMembership.class); verify(mockUserGroupDao, times(2)).save(gmCaptor.capture()); List<GroupMembership> gms = gmCaptor.getAllValues(); assertTrue(gms.get(0).getGroupId() == mockGroup.getGroupId()); assertTrue(gms.get(1).getGroupId() == mockGroup.getGroupId()); assertTrue(gms.get(0).getUserId() == 7654); assertTrue(gms.get(1).getUserId() == 8765); } |
### Question:
ChatRepository { public void requestSendMessage(int groupId, String message) { encoder.sendChatMessage(groupId, message); } ChatRepository(ChatDao chatDao, RequestEncoder encoder,
Handler backgroundHandler); void addMessage(ChatMessage message); LiveData<PagedList<ChatMessage>> getMessagesByGroupId(int groupId); void requestSendMessage(int groupId, String message); void deleteAllMessages(); }### Answer:
@Test public void requestMessageTest() { testChatRepository.requestSendMessage(mockGroupId, mockMessageContent); verify(mockEncoder).sendChatMessage(mockGroupId, mockMessageContent); } |
### Question:
ChatRepository { public void addMessage(ChatMessage message) { backgroundHandler.post(() -> { chatDao.save(message); }); } ChatRepository(ChatDao chatDao, RequestEncoder encoder,
Handler backgroundHandler); void addMessage(ChatMessage message); LiveData<PagedList<ChatMessage>> getMessagesByGroupId(int groupId); void requestSendMessage(int groupId, String message); void deleteAllMessages(); }### Answer:
@Test public void addMessageTest() { testChatRepository.addMessage(mockMessage); verify(mockChatDao).save(mockMessage); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.