method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
JRubyRackApplication implements RackApplication { @Override public RackResponse call(RackEnvironment environment) { RubyHash environmentHash = convertToRubyHash(environment.entrySet()); RubyArray response = callRackApplication(environmentHash); return convertToJavaRackResponse(response); } JRubyRackApplication(IRubyObject application); @Override RackResponse call(RackEnvironment environment); }### Answer:
@Test public void callSetsTheResponseHeaders() { RackResponse response = app.call(env); assertThat(response.getHeaders()).contains(entry("Content-Type", "text/plain")); }
@Test public void callSetsTheResponseBody() { RackResponse response = app.call(env); ImmutableList.Builder<String> strings = ImmutableList.builder(); Iterator<byte[]> bytes = response.getBody(); while (bytes.hasNext()) { strings.add(new String(bytes.next())); } assertThat(SPACE.join(strings.build())).isEqualTo(SPACE.join(env.keySet())); }
@Test public void callParsesTheResponseStatusFromAString() { IRubyObject callable = Ruby.getGlobalRuntime() .evalScriptlet("proc { |env| ['201', {'Content-Type' => 'text/plain'}, env.keys] }"); app = new JRubyRackApplication(callable); RackResponse response = app.call(env); assertThat(response.getStatus()).isEqualTo(201); }
@Test public void callSetsTheResponseStatus() { RackResponse response = app.call(env); assertThat(response.getStatus()).isEqualTo(200); }
|
### Question:
JRubyRackInput extends RubyObject { @JRubyMethod(optional = 1) public IRubyObject read(ThreadContext context, IRubyObject[] args) { Integer length = null; if (args.length > 0) { long arg = args[0].convertToInteger("to_i").getLongValue(); length = (int) Math.min(arg, Integer.MAX_VALUE); } try { return toRubyString(rackInput.read(length)); } catch (IOException e) { throw getRuntime().newIOErrorFromException(e); } } JRubyRackInput(Ruby runtime, RubyClass klass); JRubyRackInput(Ruby runtime, RackInput rackInput); @JRubyMethod IRubyObject gets(); @JRubyMethod IRubyObject each(ThreadContext context, Block block); @JRubyMethod(optional = 1) IRubyObject read(ThreadContext context, IRubyObject[] args); @JRubyMethod IRubyObject rewind(); }### Answer:
@Test public void shouldWrapJavaIOExceptions() throws Exception { Ruby ruby = Ruby.newInstance(); RackInput rackInput = mock(RackInput.class); when(rackInput.read(null)).thenThrow(new IOException("fake")); JRubyRackInput subject = new JRubyRackInput(ruby, rackInput); GlobalVariables globalVariables = ruby.getGlobalVariables(); globalVariables.set("$rack_input", subject); IRubyObject result = ruby.evalScriptlet( "begin; $rack_input.read; rescue IOError => e; \"rescued #{e.message}\"; end"); assertThat(result.asJavaString()).isEqualTo("rescued fake"); }
|
### Question:
RackResponsePropagator { public void propagate(RackResponse rackResponse, HttpServletResponse response) { propagateStatus(rackResponse, response); propagateHeaders(rackResponse, response); propagateBody(rackResponse, response); } void propagate(RackResponse rackResponse, HttpServletResponse response); }### Answer:
@Test public void propagateStatus() { rackResponse.status(404); subject.propagate(rackResponse.build(), response); verify(response).setStatus(404); }
@Test public void propagateHeadersSkipsHeadsRackHeaders() { rackResponse.header("rack.internal", "42"); subject.propagate(rackResponse.build(), response); verify(response, never()).addHeader(eq("rack.internal"), anyString()); }
@Test public void propagateHeadersMultipleValues() { rackResponse.header("Set-Cookie", "foo=bar\nbar=foo"); subject.propagate(rackResponse.build(), response); verify(response).addHeader("Set-Cookie", "foo=bar"); verify(response).addHeader("Set-Cookie", "bar=foo"); }
|
### Question:
RackResponsePropagator { private void propagateHeaders(RackResponse rackResponse, HttpServletResponse response) { for (Map.Entry<String, String> header : rackResponse.getHeaders().entrySet()) { if (shouldPropagateHeaderToClient(header)) { for (String val : header.getValue().split("\n")) { response.addHeader(header.getKey(), val); } } } try { response.flushBuffer(); } catch (IOException e) { Throwables.propagate(e); } } void propagate(RackResponse rackResponse, HttpServletResponse response); }### Answer:
@Test public void propagateHeaders() { rackResponse.header("Content-Type", "text/plain"); subject.propagate(rackResponse.build(), response); verify(response).addHeader("Content-Type", "text/plain"); }
|
### Question:
RackResponsePropagator { private void propagateBody(RackResponse rackResponse, HttpServletResponse response) { ServletOutputStream outputStream = null; try { outputStream = response.getOutputStream(); } catch (IOException e) { Throwables.propagate(e); } Iterator<byte[]> body = rackResponse.getBody(); while (body.hasNext()) { try { outputStream.write(body.next()); } catch (IOException e) { Throwables.propagate(e); } } try { outputStream.flush(); } catch (IOException e) { Throwables.propagate(e); } } void propagate(RackResponse rackResponse, HttpServletResponse response); }### Answer:
@Test public void propagateBody() throws IOException { rackResponse.body("Here ".getBytes(), "are ".getBytes(), "the ".getBytes(), "parts.".getBytes()); subject.propagate(rackResponse.build(), response); InOrder inOrder = inOrder(outputStream); inOrder.verify(outputStream).write("Here ".getBytes()); inOrder.verify(outputStream).write("are ".getBytes()); inOrder.verify(outputStream).write("the ".getBytes()); inOrder.verify(outputStream).write("parts.".getBytes()); inOrder.verify(outputStream).flush(); }
|
### Question:
RackEnvironmentBuilder { private RackInput rackInput(HttpServletRequest request) { try { return new RackInput(new TempfileBufferedInputStream(request.getInputStream())); } catch (IOException e) { throw propagate(e); } } RackEnvironment build(HttpServletRequest request); }### Answer:
@Test public void rackInput() throws IOException { request.method("POST").body("foo=42&bar=0"); assertThat(environment()).containsKey("rack.input"); assertThat(environment().get("rack.input")).isInstanceOf(RackInput.class); }
|
### Question:
RackLogger { public void info(String message) { logger.info(message); } RackLogger(Logger logger); void info(String message); void debug(String message); void warn(String message); void error(String message); void fatal(String message); static final Marker FATAL; }### Answer:
@Test public void info() { subject.info(MESSAGE); verify(delegate).info(MESSAGE); }
|
### Question:
RackServlet extends HttpServlet { @Override protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { RackEnvironment rackEnvironment = rackEnvironmentBuilder.build(request); try { RackResponse rackResponse = rackApplication.call(rackEnvironment); rackResponsePropagator.propagate(rackResponse, response); } finally { rackEnvironment.closeRackInput(); } } RackServlet(RackApplication rackApplication); RackServlet(RackEnvironmentBuilder rackEnvironmentBuilder,
RackApplication rackApplication,
RackResponsePropagator rackResponsePropagator); }### Answer:
@Test public void service() throws ServletException, IOException { when(rackApplication.call(rackEnvironment)).thenReturn(rackResponse); subject.service(request, response); InOrder inOrder = inOrder(rackResponsePropagator, rackEnvironment); inOrder.verify(rackResponsePropagator).propagate(rackResponse, response); inOrder.verify(rackEnvironment).closeRackInput(); }
|
### Question:
RackInput implements Closeable { public byte[] gets() throws IOException { return readToLinefeed(); } RackInput(InputStream inputStream); byte[] gets(); byte[] read(Integer length); void rewind(); @Override void close(); }### Answer:
@Test public void getsAtEof() throws Exception { assertThat(empty.gets()).isNull(); }
@Test public void gets() throws Exception { assertThat(full.gets()).isEqualTo("Hello,\n".getBytes()); }
@Test public void getsWithCrLf() throws Exception { assertThat(rackInputFor("Hello,\r\nWorld!").gets()).isEqualTo("Hello,\r\n".getBytes()); }
@Test public void getsAgain() throws Exception { full.gets(); assertThat(full.gets()).isEqualTo("World!".getBytes()); }
|
### Question:
RackInput implements Closeable { public byte[] read(Integer length) throws IOException { if (length == null) { return readToEof(); } else { return readTo(length); } } RackInput(InputStream inputStream); byte[] gets(); byte[] read(Integer length); void rewind(); @Override void close(); }### Answer:
@Test public void readWithLengthNilAtEof() throws Exception { assertThat(empty.read(null)).isEqualTo(EMPTY_BYTES); }
@Test public void readWithLengthZeroAtEof() throws Exception { assertThat(empty.read(0)).isEqualTo(EMPTY_BYTES); }
@Test public void readWithLengthAtEof() throws Exception { assertThat(empty.read(1)).isNull(); }
@Test public void readWithLengthNil() throws Exception { assertThat(full.read(null)).isEqualTo(BYTES); }
@Test public void readWithLengthNilAgain() throws Exception { full.read(null); assertThat(full.read(null)).isEqualTo(EMPTY_BYTES); }
@Test public void readWithLengthZero() throws Exception { assertThat(full.read(0)).isEqualTo(EMPTY_BYTES); }
@Test public void readWithLength() throws Exception { assertThat(full.read(4)).isEqualTo(copyOfRange(BYTES, 0, 4)); }
@Test public void readWithLengthAgain() throws Exception { full.read(4); assertThat(full.read(4)).isEqualTo(copyOfRange(BYTES, 4, 8)); }
@Test public void readFromSlowStreamWithLength() throws Exception { assertThat(fullSlow.read(4)).isEqualTo(copyOfRange(BYTES, 0, 4)); }
@Test public void readFromSlowStreamWithLengthAgain() throws Exception { fullSlow.read(4); assertThat(fullSlow.read(4)).isEqualTo(copyOfRange(BYTES, 4, 8)); }
@Test public void readWithLengthTooLong() throws Exception { assertThat(full.read(BYTES.length + 1)).isEqualTo(BYTES); }
@Test public void readWithLengthTooLongAgain() throws Exception { full.read(BYTES.length + 1); assertThat(full.read(BYTES.length + 1)).isNull(); }
|
### Question:
RackLogger { public void debug(String message) { logger.debug(message); } RackLogger(Logger logger); void info(String message); void debug(String message); void warn(String message); void error(String message); void fatal(String message); static final Marker FATAL; }### Answer:
@Test public void debug() { subject.debug(MESSAGE); verify(delegate).debug(MESSAGE); }
|
### Question:
RackInput implements Closeable { public void rewind() throws IOException { stream.reset(); buffer.reset(); bufferReadHead = 0; } RackInput(InputStream inputStream); byte[] gets(); byte[] read(Integer length); void rewind(); @Override void close(); }### Answer:
@Test public void rewind() throws Exception { full.read(4); full.rewind(); assertThat(full.read(4)).isEqualTo(copyOfRange(BYTES, 0, 4)); }
|
### Question:
RackLogger { public void warn(String message) { logger.warn(message); } RackLogger(Logger logger); void info(String message); void debug(String message); void warn(String message); void error(String message); void fatal(String message); static final Marker FATAL; }### Answer:
@Test public void warn() { subject.warn(MESSAGE); verify(delegate).warn(MESSAGE); }
|
### Question:
RackLogger { public void error(String message) { logger.error(message); } RackLogger(Logger logger); void info(String message); void debug(String message); void warn(String message); void error(String message); void fatal(String message); static final Marker FATAL; }### Answer:
@Test public void error() { subject.error(MESSAGE); verify(delegate).error(MESSAGE); }
|
### Question:
RackLogger { public void fatal(String message) { logger.error(FATAL, message); } RackLogger(Logger logger); void info(String message); void debug(String message); void warn(String message); void error(String message); void fatal(String message); static final Marker FATAL; }### Answer:
@Test public void fatal() { subject.fatal(MESSAGE); verify(delegate).error(FATAL, MESSAGE); }
|
### Question:
RackErrors { public void puts(String message) { logger.error(message); } RackErrors(Logger logger); void puts(String message); void write(String message); void flush(); }### Answer:
@Test public void puts() { rackErrors.puts("Boom!"); verify(logger).error("Boom!"); }
|
### Question:
RackErrors { public void write(String message) { buffer.append(message); } RackErrors(Logger logger); void puts(String message); void write(String message); void flush(); }### Answer:
@Test public void write() { rackErrors.write("Boom?"); verify(logger, never()).error(anyString()); }
|
### Question:
RackErrors { public void flush() { if (buffer.length() > 0) { logger.error(buffer.toString()); buffer.setLength(0); } } RackErrors(Logger logger); void puts(String message); void write(String message); void flush(); }### Answer:
@Test public void flushOnEmpty() { rackErrors.flush(); verify(logger, never()).error(anyString()); }
|
### Question:
MQClientInstance { public boolean registerProducer(final String group, final DefaultMQProducerImpl producer) { if (null == group || null == producer) { return false; } MQProducerInner prev = this.producerTable.putIfAbsent(group, producer); if (prev != null) { log.warn("the producer group[{}] exist already.", group); return false; } return true; } MQClientInstance(ClientConfig clientConfig, int instanceIndex, String clientId); MQClientInstance(ClientConfig clientConfig, int instanceIndex, String clientId, RPCHook rpcHook); static TopicPublishInfo topicRouteData2TopicPublishInfo(final String topic, final TopicRouteData route); static Set<MessageQueue> topicRouteData2TopicSubscribeInfo(final String topic, final TopicRouteData route); void start(); String getClientId(); void updateTopicRouteInfoFromNameServer(); void sendHeartbeatToAllBrokerWithLock(); void adjustThreadPool(); boolean updateTopicRouteInfoFromNameServer(final String topic); boolean updateTopicRouteInfoFromNameServer(final String topic, boolean isDefault, DefaultMQProducer defaultMQProducer); void shutdown(); boolean registerConsumer(final String group, final MQConsumerInner consumer); void unregisterConsumer(final String group); boolean registerProducer(final String group, final DefaultMQProducerImpl producer); void unregisterProducer(final String group); boolean registerAdminExt(final String group, final MQAdminExtInner admin); void unregisterAdminExt(final String group); void rebalanceImmediately(); void doRebalance(); MQProducerInner selectProducer(final String group); MQConsumerInner selectConsumer(final String group); FindBrokerResult findBrokerAddressInAdmin(final String brokerName); String findBrokerAddressInPublish(final String brokerName); FindBrokerResult findBrokerAddressInSubscribe(//
final String brokerName, //
final long brokerId, //
final boolean onlyThisBroker//
); List<String> findConsumerIdList(final String topic, final String group); String findBrokerAddrByTopic(final String topic); void resetOffset(String topic, String group, Map<MessageQueue, Long> offsetTable); Map<MessageQueue, Long> getConsumerStatus(String topic, String group); TopicRouteData getAnExistTopicRouteData(final String topic); MQClientAPIImpl getMQClientAPIImpl(); MQAdminImpl getMQAdminImpl(); long getBootTimestamp(); ScheduledExecutorService getScheduledExecutorService(); PullMessageService getPullMessageService(); DefaultMQProducer getDefaultMQProducer(); ConcurrentHashMap<String, TopicRouteData> getTopicRouteTable(); ConsumeMessageDirectlyResult consumeMessageDirectly(final MessageExt msg, //
final String consumerGroup, //
final String brokerName); ConsumerRunningInfo consumerRunningInfo(final String consumerGroup); ConsumerStatsManager getConsumerStatsManager(); NettyClientConfig getNettyClientConfig(); }### Answer:
@Test public void testRegisterProducer() { boolean flag = mqClientInstance.registerProducer(group, mock(DefaultMQProducerImpl.class)); assertThat(flag).isTrue(); flag = mqClientInstance.registerProducer(group, mock(DefaultMQProducerImpl.class)); assertThat(flag).isFalse(); mqClientInstance.unregisterProducer(group); flag = mqClientInstance.registerProducer(group, mock(DefaultMQProducerImpl.class)); assertThat(flag).isTrue(); }
|
### Question:
MQClientInstance { public boolean registerConsumer(final String group, final MQConsumerInner consumer) { if (null == group || null == consumer) { return false; } MQConsumerInner prev = this.consumerTable.putIfAbsent(group, consumer); if (prev != null) { log.warn("the consumer group[" + group + "] exist already."); return false; } return true; } MQClientInstance(ClientConfig clientConfig, int instanceIndex, String clientId); MQClientInstance(ClientConfig clientConfig, int instanceIndex, String clientId, RPCHook rpcHook); static TopicPublishInfo topicRouteData2TopicPublishInfo(final String topic, final TopicRouteData route); static Set<MessageQueue> topicRouteData2TopicSubscribeInfo(final String topic, final TopicRouteData route); void start(); String getClientId(); void updateTopicRouteInfoFromNameServer(); void sendHeartbeatToAllBrokerWithLock(); void adjustThreadPool(); boolean updateTopicRouteInfoFromNameServer(final String topic); boolean updateTopicRouteInfoFromNameServer(final String topic, boolean isDefault, DefaultMQProducer defaultMQProducer); void shutdown(); boolean registerConsumer(final String group, final MQConsumerInner consumer); void unregisterConsumer(final String group); boolean registerProducer(final String group, final DefaultMQProducerImpl producer); void unregisterProducer(final String group); boolean registerAdminExt(final String group, final MQAdminExtInner admin); void unregisterAdminExt(final String group); void rebalanceImmediately(); void doRebalance(); MQProducerInner selectProducer(final String group); MQConsumerInner selectConsumer(final String group); FindBrokerResult findBrokerAddressInAdmin(final String brokerName); String findBrokerAddressInPublish(final String brokerName); FindBrokerResult findBrokerAddressInSubscribe(//
final String brokerName, //
final long brokerId, //
final boolean onlyThisBroker//
); List<String> findConsumerIdList(final String topic, final String group); String findBrokerAddrByTopic(final String topic); void resetOffset(String topic, String group, Map<MessageQueue, Long> offsetTable); Map<MessageQueue, Long> getConsumerStatus(String topic, String group); TopicRouteData getAnExistTopicRouteData(final String topic); MQClientAPIImpl getMQClientAPIImpl(); MQAdminImpl getMQAdminImpl(); long getBootTimestamp(); ScheduledExecutorService getScheduledExecutorService(); PullMessageService getPullMessageService(); DefaultMQProducer getDefaultMQProducer(); ConcurrentHashMap<String, TopicRouteData> getTopicRouteTable(); ConsumeMessageDirectlyResult consumeMessageDirectly(final MessageExt msg, //
final String consumerGroup, //
final String brokerName); ConsumerRunningInfo consumerRunningInfo(final String consumerGroup); ConsumerStatsManager getConsumerStatsManager(); NettyClientConfig getNettyClientConfig(); }### Answer:
@Test public void testRegisterConsumer() throws RemotingException, InterruptedException, MQBrokerException { boolean flag = mqClientInstance.registerConsumer(group, mock(MQConsumerInner.class)); assertThat(flag).isTrue(); flag = mqClientInstance.registerConsumer(group, mock(MQConsumerInner.class)); assertThat(flag).isFalse(); mqClientInstance.unregisterConsumer(group); flag = mqClientInstance.registerConsumer(group, mock(MQConsumerInner.class)); assertThat(flag).isTrue(); }
|
### Question:
MQClientInstance { public boolean registerAdminExt(final String group, final MQAdminExtInner admin) { if (null == group || null == admin) { return false; } MQAdminExtInner prev = this.adminExtTable.putIfAbsent(group, admin); if (prev != null) { log.warn("the admin group[{}] exist already.", group); return false; } return true; } MQClientInstance(ClientConfig clientConfig, int instanceIndex, String clientId); MQClientInstance(ClientConfig clientConfig, int instanceIndex, String clientId, RPCHook rpcHook); static TopicPublishInfo topicRouteData2TopicPublishInfo(final String topic, final TopicRouteData route); static Set<MessageQueue> topicRouteData2TopicSubscribeInfo(final String topic, final TopicRouteData route); void start(); String getClientId(); void updateTopicRouteInfoFromNameServer(); void sendHeartbeatToAllBrokerWithLock(); void adjustThreadPool(); boolean updateTopicRouteInfoFromNameServer(final String topic); boolean updateTopicRouteInfoFromNameServer(final String topic, boolean isDefault, DefaultMQProducer defaultMQProducer); void shutdown(); boolean registerConsumer(final String group, final MQConsumerInner consumer); void unregisterConsumer(final String group); boolean registerProducer(final String group, final DefaultMQProducerImpl producer); void unregisterProducer(final String group); boolean registerAdminExt(final String group, final MQAdminExtInner admin); void unregisterAdminExt(final String group); void rebalanceImmediately(); void doRebalance(); MQProducerInner selectProducer(final String group); MQConsumerInner selectConsumer(final String group); FindBrokerResult findBrokerAddressInAdmin(final String brokerName); String findBrokerAddressInPublish(final String brokerName); FindBrokerResult findBrokerAddressInSubscribe(//
final String brokerName, //
final long brokerId, //
final boolean onlyThisBroker//
); List<String> findConsumerIdList(final String topic, final String group); String findBrokerAddrByTopic(final String topic); void resetOffset(String topic, String group, Map<MessageQueue, Long> offsetTable); Map<MessageQueue, Long> getConsumerStatus(String topic, String group); TopicRouteData getAnExistTopicRouteData(final String topic); MQClientAPIImpl getMQClientAPIImpl(); MQAdminImpl getMQAdminImpl(); long getBootTimestamp(); ScheduledExecutorService getScheduledExecutorService(); PullMessageService getPullMessageService(); DefaultMQProducer getDefaultMQProducer(); ConcurrentHashMap<String, TopicRouteData> getTopicRouteTable(); ConsumeMessageDirectlyResult consumeMessageDirectly(final MessageExt msg, //
final String consumerGroup, //
final String brokerName); ConsumerRunningInfo consumerRunningInfo(final String consumerGroup); ConsumerStatsManager getConsumerStatsManager(); NettyClientConfig getNettyClientConfig(); }### Answer:
@Test public void testRegisterAdminExt() { boolean flag = mqClientInstance.registerAdminExt(group, mock(MQAdminExtInner.class)); assertThat(flag).isTrue(); flag = mqClientInstance.registerAdminExt(group, mock(MQAdminExtInner.class)); assertThat(flag).isFalse(); mqClientInstance.unregisterAdminExt(group); flag = mqClientInstance.registerAdminExt(group, mock(MQAdminExtInner.class)); assertThat(flag).isTrue(); }
|
### Question:
RemotingCommand { public static byte[] markProtocolType(int source, SerializeType type) { byte[] result = new byte[4]; result[0] = type.getCode(); result[1] = (byte) ((source >> 16) & 0xFF); result[2] = (byte) ((source >> 8) & 0xFF); result[3] = (byte) (source & 0xFF); return result; } protected RemotingCommand(); static RemotingCommand createRequestCommand(int code, CommandCustomHeader customHeader); static RemotingCommand createResponseCommand(Class<? extends CommandCustomHeader> classHeader); static RemotingCommand createResponseCommand(int code, String remark, Class<? extends CommandCustomHeader> classHeader); static RemotingCommand createResponseCommand(int code, String remark); static RemotingCommand decode(final byte[] array); static RemotingCommand decode(final ByteBuffer byteBuffer); static int getHeaderLength(int length); static SerializeType getProtocolType(int source); static int createNewRequestId(); static SerializeType getSerializeTypeConfigInThisServer(); static byte[] markProtocolType(int source, SerializeType type); void markResponseType(); CommandCustomHeader readCustomHeader(); void writeCustomHeader(CommandCustomHeader customHeader); CommandCustomHeader decodeCommandCustomHeader(Class<? extends CommandCustomHeader> classHeader); ByteBuffer encode(); void makeCustomHeaderToNet(); ByteBuffer encodeHeader(); ByteBuffer encodeHeader(final int bodyLength); void markOnewayRPC(); @JSONField(serialize = false) boolean isOnewayRPC(); int getCode(); void setCode(int code); @JSONField(serialize = false) RemotingCommandType getType(); @JSONField(serialize = false) boolean isResponseType(); LanguageCode getLanguage(); void setLanguage(LanguageCode language); int getVersion(); void setVersion(int version); int getOpaque(); void setOpaque(int opaque); int getFlag(); void setFlag(int flag); String getRemark(); void setRemark(String remark); byte[] getBody(); void setBody(byte[] body); HashMap<String, String> getExtFields(); void setExtFields(HashMap<String, String> extFields); void addExtField(String key, String value); @Override String toString(); SerializeType getSerializeTypeCurrentRPC(); void setSerializeTypeCurrentRPC(SerializeType serializeTypeCurrentRPC); static final String SERIALIZE_TYPE_PROPERTY; static final String SERIALIZE_TYPE_ENV; static final String REMOTING_VERSION_KEY; }### Answer:
@Test public void testMarkProtocolType_JSONProtocolType() { int source = 261; SerializeType type = SerializeType.JSON; byte[] result = RemotingCommand.markProtocolType(source, type); assertThat(result).isEqualTo(new byte[]{0, 0, 1, 5}); }
@Test public void testMarkProtocolType_ROCKETMQProtocolType() { int source = 16777215; SerializeType type = SerializeType.ROCKETMQ; byte[] result = RemotingCommand.markProtocolType(source, type); assertThat(result).isEqualTo(new byte[]{1, -1, -1, -1}); }
|
### Question:
RemotingCommand { public static RemotingCommand createResponseCommand(Class<? extends CommandCustomHeader> classHeader) { return createResponseCommand(RemotingSysResponseCode.SYSTEM_ERROR, "not set any response code", classHeader); } protected RemotingCommand(); static RemotingCommand createRequestCommand(int code, CommandCustomHeader customHeader); static RemotingCommand createResponseCommand(Class<? extends CommandCustomHeader> classHeader); static RemotingCommand createResponseCommand(int code, String remark, Class<? extends CommandCustomHeader> classHeader); static RemotingCommand createResponseCommand(int code, String remark); static RemotingCommand decode(final byte[] array); static RemotingCommand decode(final ByteBuffer byteBuffer); static int getHeaderLength(int length); static SerializeType getProtocolType(int source); static int createNewRequestId(); static SerializeType getSerializeTypeConfigInThisServer(); static byte[] markProtocolType(int source, SerializeType type); void markResponseType(); CommandCustomHeader readCustomHeader(); void writeCustomHeader(CommandCustomHeader customHeader); CommandCustomHeader decodeCommandCustomHeader(Class<? extends CommandCustomHeader> classHeader); ByteBuffer encode(); void makeCustomHeaderToNet(); ByteBuffer encodeHeader(); ByteBuffer encodeHeader(final int bodyLength); void markOnewayRPC(); @JSONField(serialize = false) boolean isOnewayRPC(); int getCode(); void setCode(int code); @JSONField(serialize = false) RemotingCommandType getType(); @JSONField(serialize = false) boolean isResponseType(); LanguageCode getLanguage(); void setLanguage(LanguageCode language); int getVersion(); void setVersion(int version); int getOpaque(); void setOpaque(int opaque); int getFlag(); void setFlag(int flag); String getRemark(); void setRemark(String remark); byte[] getBody(); void setBody(byte[] body); HashMap<String, String> getExtFields(); void setExtFields(HashMap<String, String> extFields); void addExtField(String key, String value); @Override String toString(); SerializeType getSerializeTypeCurrentRPC(); void setSerializeTypeCurrentRPC(SerializeType serializeTypeCurrentRPC); static final String SERIALIZE_TYPE_PROPERTY; static final String SERIALIZE_TYPE_ENV; static final String REMOTING_VERSION_KEY; }### Answer:
@Test public void testCreateResponseCommand_FailToCreateCommand() { System.setProperty(RemotingCommand.REMOTING_VERSION_KEY, "2333"); int code = RemotingSysResponseCode.SUCCESS; String remark = "Sample remark"; RemotingCommand cmd = RemotingCommand.createResponseCommand(code ,remark, CommandCustomHeader.class); assertThat(cmd).isNull(); }
|
### Question:
ResetOffsetByTimeOldCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { String consumerGroup = commandLine.getOptionValue("g").trim(); String topic = commandLine.getOptionValue("t").trim(); String timeStampStr = commandLine.getOptionValue("s").trim(); long timestamp = 0; try { timestamp = Long.parseLong(timeStampStr); } catch (NumberFormatException e) { Date date = UtilAll.parseDate(timeStampStr, UtilAll.YYYY_MM_DD_HH_MM_SS_SSS); if (date != null) { timestamp = UtilAll.parseDate(timeStampStr, UtilAll.YYYY_MM_DD_HH_MM_SS_SSS).getTime(); } else { System.out.printf("specified timestamp invalid.%n"); return; } boolean force = true; if (commandLine.hasOption('f')) { force = Boolean.valueOf(commandLine.getOptionValue("f").trim()); } defaultMQAdminExt.start(); resetOffset(defaultMQAdminExt, consumerGroup, topic, timestamp, force, timeStampStr); } } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } static void resetOffset(DefaultMQAdminExt defaultMQAdminExt, String consumerGroup, String topic, long timestamp, boolean force,
String timeStampStr); @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { ResetOffsetByTimeOldCommand cmd = new ResetOffsetByTimeOldCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-g default-group", "-t unit-test", "-s 1412131213231", "-f false"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); assertThat(commandLine.getOptionValue('g').trim()).isEqualTo("default-group"); assertThat(commandLine.getOptionValue('t').trim()).isEqualTo("unit-test"); assertThat(commandLine.getOptionValue('s').trim()).isEqualTo("1412131213231"); }
|
### Question:
RouteInfoManager { public TopicRouteData pickupTopicRouteData(final String topic) { TopicRouteData topicRouteData = new TopicRouteData(); boolean foundQueueData = false; boolean foundBrokerData = false; Set<String> brokerNameSet = new HashSet<String>(); List<BrokerData> brokerDataList = new LinkedList<BrokerData>(); topicRouteData.setBrokerDatas(brokerDataList); HashMap<String, List<String>> filterServerMap = new HashMap<String, List<String>>(); topicRouteData.setFilterServerTable(filterServerMap); try { try { this.lock.readLock().lockInterruptibly(); List<QueueData> queueDataList = this.topicQueueTable.get(topic); if (queueDataList != null) { topicRouteData.setQueueDatas(queueDataList); foundQueueData = true; Iterator<QueueData> it = queueDataList.iterator(); while (it.hasNext()) { QueueData qd = it.next(); brokerNameSet.add(qd.getBrokerName()); } for (String brokerName : brokerNameSet) { BrokerData brokerData = this.brokerAddrTable.get(brokerName); if (null != brokerData) { BrokerData brokerDataClone = new BrokerData(); brokerDataClone.setBrokerName(brokerData.getBrokerName()); brokerDataClone.setBrokerAddrs((HashMap<Long, String>) brokerData .getBrokerAddrs().clone()); brokerDataList.add(brokerDataClone); foundBrokerData = true; for (final String brokerAddr : brokerDataClone.getBrokerAddrs().values()) { List<String> filterServerList = this.filterServerTable.get(brokerAddr); filterServerMap.put(brokerAddr, filterServerList); } } } } } finally { this.lock.readLock().unlock(); } } catch (Exception e) { log.error("pickupTopicRouteData Exception", e); } if (log.isDebugEnabled()) { log.debug("pickupTopicRouteData {} {}", topic, topicRouteData); } if (foundBrokerData && foundQueueData) { return topicRouteData; } return null; } RouteInfoManager(); byte[] getAllClusterInfo(); void deleteTopic(final String topic); byte[] getAllTopicList(); RegisterBrokerResult registerBroker(
final String clusterName,
final String brokerAddr,
final String brokerName,
final long brokerId,
final String haServerAddr,
final TopicConfigSerializeWrapper topicConfigWrapper,
final List<String> filterServerList,
final Channel channel); int wipeWritePermOfBrokerByLock(final String brokerName); void unregisterBroker(
final String clusterName,
final String brokerAddr,
final String brokerName,
final long brokerId); TopicRouteData pickupTopicRouteData(final String topic); void scanNotActiveBroker(); void onChannelDestroy(String remoteAddr, Channel channel); void printAllPeriodically(); byte[] getSystemTopicList(); byte[] getTopicsByCluster(String cluster); byte[] getUnitTopics(); byte[] getHasUnitSubTopicList(); byte[] getHasUnitSubUnUnitTopicList(); }### Answer:
@Test public void testPickupTopicRouteData() { TopicRouteData result = routeInfoManager.pickupTopicRouteData("unit_test"); assertThat(result).isNull(); }
|
### Question:
ResetOffsetByTimeCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { String group = commandLine.getOptionValue("g").trim(); String topic = commandLine.getOptionValue("t").trim(); String timeStampStr = commandLine.getOptionValue("s").trim(); long timestamp = timeStampStr.equals("now") ? System.currentTimeMillis() : 0; try { if (timestamp == 0) { timestamp = Long.parseLong(timeStampStr); } } catch (NumberFormatException e) { timestamp = UtilAll.parseDate(timeStampStr, UtilAll.YYYY_MM_DD_HH_MM_SS_SSS).getTime(); } boolean force = true; if (commandLine.hasOption('f')) { force = Boolean.valueOf(commandLine.getOptionValue("f").trim()); } boolean isC = false; if (commandLine.hasOption('c')) { isC = true; } defaultMQAdminExt.start(); Map<MessageQueue, Long> offsetTable; try { offsetTable = defaultMQAdminExt.resetOffsetByTimestamp(topic, group, timestamp, force, isC); } catch (MQClientException e) { if (ResponseCode.CONSUMER_NOT_ONLINE == e.getResponseCode()) { ResetOffsetByTimeOldCommand.resetOffset(defaultMQAdminExt, group, topic, timestamp, force, timeStampStr); return; } throw e; } System.out.printf("rollback consumer offset by specified group[%s], topic[%s], force[%s], timestamp(string)[%s], timestamp(long)[%s]%n", group, topic, force, timeStampStr, timestamp); System.out.printf("%-40s %-40s %-40s%n", "#brokerName", "#queueId", "#offset"); Iterator<Map.Entry<MessageQueue, Long>> iterator = offsetTable.entrySet().iterator(); while (iterator.hasNext()) { Map.Entry<MessageQueue, Long> entry = iterator.next(); System.out.printf("%-40s %-40d %-40d%n", UtilAll.frontStringAtLeast(entry.getKey().getBrokerName(), 32), entry.getKey().getQueueId(), entry.getValue()); } } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } static void main(String[] args); @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { ResetOffsetByTimeCommand cmd = new ResetOffsetByTimeCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-g default-group", "-t unit-test", "-s 1412131213231", "-f false"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
GetConsumerStatusCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { String group = commandLine.getOptionValue("g").trim(); String topic = commandLine.getOptionValue("t").trim(); String originClientId = ""; if (commandLine.hasOption("i")) { originClientId = commandLine.getOptionValue("i").trim(); } defaultMQAdminExt.start(); Map<String, Map<MessageQueue, Long>> consumerStatusTable = defaultMQAdminExt.getConsumeStatus(topic, group, originClientId); System.out.printf("get consumer status from client. group=%s, topic=%s, originClientId=%s%n", group, topic, originClientId); System.out.printf("%-50s %-15s %-15s %-20s%n", "#clientId", "#brokerName", "#queueId", "#offset"); for (Map.Entry<String, Map<MessageQueue, Long>> entry : consumerStatusTable.entrySet()) { String clientId = entry.getKey(); Map<MessageQueue, Long> mqTable = entry.getValue(); for (Map.Entry<MessageQueue, Long> entry1 : mqTable.entrySet()) { MessageQueue mq = entry1.getKey(); System.out.printf("%-50s %-15s %-15d %-20d%n", UtilAll.frontStringAtLeast(clientId, 50), mq.getBrokerName(), mq.getQueueId(), mqTable.get(mq)); } } } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { GetConsumerStatusCommand cmd = new GetConsumerStatusCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-g default-group", "-t unit-test", "-i clientid"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
CleanExpiredCQSubCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { boolean result = false; defaultMQAdminExt.start(); if (commandLine.hasOption('b')) { String addr = commandLine.getOptionValue('b').trim(); result = defaultMQAdminExt.cleanExpiredConsumerQueueByAddr(addr); } else { String cluster = commandLine.getOptionValue('c'); if (null != cluster) cluster = cluster.trim(); result = defaultMQAdminExt.cleanExpiredConsumerQueue(cluster); } System.out.printf(result ? "success" : "false"); } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { CleanExpiredCQSubCommand cmd = new CleanExpiredCQSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-b 127.0.0.1:10911", "-c default-cluster"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
CleanUnusedTopicCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { boolean result = false; defaultMQAdminExt.start(); if (commandLine.hasOption('b')) { String addr = commandLine.getOptionValue('b').trim(); result = defaultMQAdminExt.cleanUnusedTopicByAddr(addr); } else { String cluster = commandLine.getOptionValue('c'); if (null != cluster) cluster = cluster.trim(); result = defaultMQAdminExt.cleanUnusedTopicByAddr(cluster); } System.out.printf(result ? "success" : "false"); } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { CleanUnusedTopicCommand cmd = new CleanUnusedTopicCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-b 127.0.0.1:10911", "-c default-cluster"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
UpdateBrokerConfigSubCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { String key = commandLine.getOptionValue('k').trim(); String value = commandLine.getOptionValue('v').trim(); Properties properties = new Properties(); properties.put(key, value); if (commandLine.hasOption('b')) { String brokerAddr = commandLine.getOptionValue('b').trim(); defaultMQAdminExt.start(); defaultMQAdminExt.updateBrokerConfig(brokerAddr, properties); System.out.printf("update broker config success, %s\n", brokerAddr); return; } else if (commandLine.hasOption('c')) { String clusterName = commandLine.getOptionValue('c').trim(); defaultMQAdminExt.start(); Set<String> masterSet = CommandUtil.fetchMasterAddrByClusterName(defaultMQAdminExt, clusterName); for (String brokerAddr : masterSet) { try { defaultMQAdminExt.updateBrokerConfig(brokerAddr, properties); System.out.printf("update broker config success, %s\n", brokerAddr); } catch (Exception e) { e.printStackTrace(); } } return; } ServerUtil.printCommandLineHelp("mqadmin " + this.commandName(), options); } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { UpdateBrokerConfigSubCommand cmd = new UpdateBrokerConfigSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-b 127.0.0.1:10911", "-c default-cluster", "-k topicname", "-v unit_test"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
BrokerStatusSubCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { defaultMQAdminExt.start(); String brokerAddr = commandLine.hasOption('b') ? commandLine.getOptionValue('b').trim() : null; String clusterName = commandLine.hasOption('c') ? commandLine.getOptionValue('c').trim() : null; if (brokerAddr != null) { printBrokerRuntimeStats(defaultMQAdminExt, brokerAddr, false); } else if (clusterName != null) { Set<String> masterSet = CommandUtil.fetchMasterAndSlaveAddrByClusterName(defaultMQAdminExt, clusterName); for (String ba : masterSet) { try { printBrokerRuntimeStats(defaultMQAdminExt, ba, true); } catch (Exception e) { e.printStackTrace(); } } } } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); void printBrokerRuntimeStats(final DefaultMQAdminExt defaultMQAdminExt, final String brokerAddr,
final boolean printBroker); }### Answer:
@Test public void testExecute() { BrokerStatusSubCommand cmd = new BrokerStatusSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-b 127.0.0.1:10911", "-c default-cluster"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
GetBrokerConfigCommand implements SubCommand { @Override public void execute(final CommandLine commandLine, final Options options, final RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { if (commandLine.hasOption('b')) { String brokerAddr = commandLine.getOptionValue('b').trim(); defaultMQAdminExt.start(); getAndPrint(defaultMQAdminExt, String.format("============%s============\n", brokerAddr), brokerAddr); } else if (commandLine.hasOption('c')) { String clusterName = commandLine.getOptionValue('c').trim(); defaultMQAdminExt.start(); Map<String, List<String>> masterAndSlaveMap = CommandUtil.fetchMasterAndSlaveDistinguish(defaultMQAdminExt, clusterName); for (String masterAddr : masterAndSlaveMap.keySet()) { getAndPrint( defaultMQAdminExt, String.format("============Master: %s============\n", masterAddr), masterAddr ); for (String slaveAddr : masterAndSlaveMap.get(masterAddr)) { getAndPrint( defaultMQAdminExt, String.format("============My Master: %s=====Slave: %s============\n", masterAddr, slaveAddr), slaveAddr ); } } } } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(final Options options); @Override void execute(final CommandLine commandLine, final Options options, final RPCHook rpcHook); }### Answer:
@Test public void testExecute() { GetBrokerConfigCommand cmd = new GetBrokerConfigCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-b 127.0.0.1:10911", "-c default-cluster"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
BrokerConsumeStatsSubCommad implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { defaultMQAdminExt.start(); String brokerAddr = commandLine.getOptionValue('b').trim(); boolean isOrder = false; long timeoutMillis = 50000; long diffLevel = 0; if (commandLine.hasOption('o')) { isOrder = Boolean.parseBoolean(commandLine.getOptionValue('o').trim()); } if (commandLine.hasOption('t')) { timeoutMillis = Long.parseLong(commandLine.getOptionValue('t').trim()); } if (commandLine.hasOption('l')) { diffLevel = Long.parseLong(commandLine.getOptionValue('l').trim()); } ConsumeStatsList consumeStatsList = defaultMQAdminExt.fetchConsumeStatsInBroker(brokerAddr, isOrder, timeoutMillis); System.out.printf("%-32s %-32s %-32s %-4s %-20s %-20s %-20s %s%n", "#Topic", "#Group", "#Broker Name", "#QID", "#Broker Offset", "#Consumer Offset", "#Diff", "#LastTime"); for (Map<String, List<ConsumeStats>> map : consumeStatsList.getConsumeStatsList()) { for (Map.Entry<String, List<ConsumeStats>> entry : map.entrySet()) { String group = entry.getKey(); List<ConsumeStats> consumeStatsArray = entry.getValue(); for (ConsumeStats consumeStats : consumeStatsArray) { List<MessageQueue> mqList = new LinkedList<MessageQueue>(); mqList.addAll(consumeStats.getOffsetTable().keySet()); Collections.sort(mqList); for (MessageQueue mq : mqList) { OffsetWrapper offsetWrapper = consumeStats.getOffsetTable().get(mq); long diff = offsetWrapper.getBrokerOffset() - offsetWrapper.getConsumerOffset(); if (diff < diffLevel) { continue; } String lastTime = "-"; try { lastTime = UtilAll.formatDate(new Date(offsetWrapper.getLastTimestamp()), UtilAll.YYYY_MM_DD_HH_MM_SS); } catch (Exception ignored) { } if (offsetWrapper.getLastTimestamp() > 0) System.out.printf("%-32s %-32s %-32s %-4d %-20d %-20d %-20d %s%n", UtilAll.frontStringAtLeast(mq.getTopic(), 32), group, UtilAll.frontStringAtLeast(mq.getBrokerName(), 32), mq.getQueueId(), offsetWrapper.getBrokerOffset(), offsetWrapper.getConsumerOffset(), diff, lastTime ); } } } } System.out.printf("%nDiff Total: %d%n", consumeStatsList.getTotalDiff()); } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { BrokerConsumeStatsSubCommad cmd = new BrokerConsumeStatsSubCommad(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-b 127.0.0.1:10911", "-t 3000", "-l 5", "-o true"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
SendMsgStatusCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { final DefaultMQProducer producer = new DefaultMQProducer("PID_SMSC", rpcHook); producer.setInstanceName("PID_SMSC_" + System.currentTimeMillis()); try { producer.start(); String brokerName = commandLine.getOptionValue('b').trim(); int messageSize = commandLine.hasOption('s') ? Integer.parseInt(commandLine.getOptionValue('s')) : 128; int count = commandLine.hasOption('c') ? Integer.parseInt(commandLine.getOptionValue('c')) : 50; producer.send(buildMessage(brokerName, 16)); for (int i = 0; i < count; i++) { long begin = System.currentTimeMillis(); SendResult result = producer.send(buildMessage(brokerName, messageSize)); System.out.printf("rt:" + (System.currentTimeMillis() - begin) + "ms, SendResult=" + result); } } catch (Exception e) { e.printStackTrace(); } finally { producer.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { SendMsgStatusCommand cmd = new SendMsgStatusCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-b 127.0.0.1:10911", "-s 1024 -c 10"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); }
|
### Question:
ConsumerStatusSubCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { defaultMQAdminExt.start(); String group = commandLine.getOptionValue('g').trim(); ConsumerConnection cc = defaultMQAdminExt.examineConsumerConnectionInfo(group); boolean jstack = commandLine.hasOption('s'); if (!commandLine.hasOption('i')) { int i = 1; long now = System.currentTimeMillis(); final TreeMap<String, ConsumerRunningInfo> criTable = new TreeMap<String, ConsumerRunningInfo>(); for (Connection conn : cc.getConnectionSet()) { try { ConsumerRunningInfo consumerRunningInfo = defaultMQAdminExt.getConsumerRunningInfo(group, conn.getClientId(), jstack); if (consumerRunningInfo != null) { criTable.put(conn.getClientId(), consumerRunningInfo); String filePath = now + "/" + conn.getClientId(); MixAll.string2FileNotSafe(consumerRunningInfo.formatString(), filePath); System.out.printf("%03d %-40s %-20s %s%n", i++, conn.getClientId(), MQVersion.getVersionDesc(conn.getVersion()), filePath); } } catch (Exception e) { e.printStackTrace(); } } if (!criTable.isEmpty()) { boolean subSame = ConsumerRunningInfo.analyzeSubscription(criTable); boolean rebalanceOK = subSame && ConsumerRunningInfo.analyzeRebalance(criTable); if (subSame) { System.out.printf("%n%nSame subscription in the same group of consumer"); System.out.printf("%n%nRebalance %s%n", rebalanceOK ? "OK" : "Failed"); Iterator<Entry<String, ConsumerRunningInfo>> it = criTable.entrySet().iterator(); while (it.hasNext()) { Entry<String, ConsumerRunningInfo> next = it.next(); String result = ConsumerRunningInfo.analyzeProcessQueue(next.getKey(), next.getValue()); if (result.length() > 0) { System.out.printf(result); } } } else { System.out.printf("%n%nWARN: Different subscription in the same group of consumer!!!"); } } } else { String clientId = commandLine.getOptionValue('i').trim(); ConsumerRunningInfo consumerRunningInfo = defaultMQAdminExt.getConsumerRunningInfo(group, clientId, jstack); if (consumerRunningInfo != null) { System.out.printf("%s", consumerRunningInfo.formatString()); } } } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } static void main(String[] args); @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { ConsumerStatusSubCommand cmd = new ConsumerStatusSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-g default-group", "-i cid_one"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
GetNamesrvConfigCommand implements SubCommand { @Override public void execute(final CommandLine commandLine, final Options options, final RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { String servers = commandLine.getOptionValue('n'); List<String> serverList = null; if (servers != null && servers.length() > 0) { String[] serverArray = servers.trim().split(";"); if (serverArray.length > 0) { serverList = Arrays.asList(serverArray); } } defaultMQAdminExt.start(); Map<String, Properties> nameServerConfigs = defaultMQAdminExt.getNameServerConfig(serverList); for (String server : nameServerConfigs.keySet()) { System.out.printf("============%s============\n", server); for (Object key : nameServerConfigs.get(server).keySet()) { System.out.printf("%-50s= %s\n", key, nameServerConfigs.get(server).get(key)); } } } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(final Options options); @Override void execute(final CommandLine commandLine, final Options options, final RPCHook rpcHook); }### Answer:
@Test public void testExecute() { GetNamesrvConfigCommand cmd = new GetNamesrvConfigCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
WipeWritePermSubCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { defaultMQAdminExt.start(); String brokerName = commandLine.getOptionValue('b').trim(); List<String> namesrvList = defaultMQAdminExt.getNameServerAddressList(); if (namesrvList != null) { for (String namesrvAddr : namesrvList) { try { int wipeTopicCount = defaultMQAdminExt.wipeWritePermOfBroker(namesrvAddr, brokerName); System.out.printf("wipe write perm of broker[%s] in name server[%s] OK, %d%n", brokerName, namesrvAddr, wipeTopicCount ); } catch (Exception e) { System.out.printf("wipe write perm of broker[%s] in name server[%s] Failed%n", brokerName, namesrvAddr ); e.printStackTrace(); } } } } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { WipeWritePermSubCommand cmd = new WipeWritePermSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-b default-broker"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
UpdateTopicPermSubCommand implements SubCommand { @Override public void execute(final CommandLine commandLine, final Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { defaultMQAdminExt.start(); TopicConfig topicConfig = new TopicConfig(); String topic = commandLine.getOptionValue('t').trim(); TopicRouteData topicRouteData = defaultMQAdminExt.examineTopicRouteInfo(topic); assert topicRouteData != null; List<QueueData> queueDatas = topicRouteData.getQueueDatas(); assert queueDatas != null && queueDatas.size() > 0; QueueData queueData = queueDatas.get(0); topicConfig.setTopicName(topic); topicConfig.setWriteQueueNums(queueData.getWriteQueueNums()); topicConfig.setReadQueueNums(queueData.getReadQueueNums()); topicConfig.setPerm(queueData.getPerm()); topicConfig.setTopicSysFlag(queueData.getTopicSynFlag()); int perm = Integer.parseInt(commandLine.getOptionValue('p').trim()); int oldPerm = topicConfig.getPerm(); if (perm == oldPerm) { System.out.printf("new perm equals to the old one!%n"); return; } topicConfig.setPerm(perm); if (commandLine.hasOption('b')) { String addr = commandLine.getOptionValue('b').trim(); defaultMQAdminExt.createAndUpdateTopicConfig(addr, topicConfig); System.out.printf("update topic perm from %s to %s in %s success.%n", oldPerm, perm, addr); System.out.printf("%s%n", topicConfig); return; } else if (commandLine.hasOption('c')) { String clusterName = commandLine.getOptionValue('c').trim(); Set<String> masterSet = CommandUtil.fetchMasterAddrByClusterName(defaultMQAdminExt, clusterName); for (String addr : masterSet) { defaultMQAdminExt.createAndUpdateTopicConfig(addr, topicConfig); System.out.printf("update topic perm from %s to %s in %s success.%n", oldPerm, perm, addr); } return; } ServerUtil.printCommandLineHelp("mqadmin " + this.commandName(), options); } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(final CommandLine commandLine, final Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { UpdateTopicPermSubCommand cmd = new UpdateTopicPermSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-b 127.0.0.1:10911", "-c default-cluster", "-t unit-test", "-p 6"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); assertThat(commandLine.getOptionValue('b').trim()).isEqualTo("127.0.0.1:10911"); assertThat(commandLine.getOptionValue('c').trim()).isEqualTo("default-cluster"); assertThat(commandLine.getOptionValue('t').trim()).isEqualTo("unit-test"); assertThat(commandLine.getOptionValue('p').trim()).isEqualTo("6"); }
|
### Question:
TopicRouteSubCommand implements SubCommand { @Override public void execute(final CommandLine commandLine, final Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { defaultMQAdminExt.start(); String topic = commandLine.getOptionValue('t').trim(); TopicRouteData topicRouteData = defaultMQAdminExt.examineTopicRouteInfo(topic); String json = topicRouteData.toJson(true); System.out.printf("%s%n", json); } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(final CommandLine commandLine, final Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { TopicRouteSubCommand cmd = new TopicRouteSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-t unit-test"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); assertThat(commandLine.getOptionValue('t').trim()).isEqualTo("unit-test"); }
|
### Question:
DeleteTopicSubCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt adminExt = new DefaultMQAdminExt(rpcHook); adminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { String topic = commandLine.getOptionValue('t').trim(); if (commandLine.hasOption('c')) { String clusterName = commandLine.getOptionValue('c').trim(); adminExt.start(); deleteTopic(adminExt, clusterName, topic); return; } ServerUtil.printCommandLineHelp("mqadmin " + this.commandName(), options); } catch (Exception e) { e.printStackTrace(); } finally { adminExt.shutdown(); } } static void deleteTopic(final DefaultMQAdminExt adminExt,
final String clusterName,
final String topic
); @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { DeleteTopicSubCommand cmd = new DeleteTopicSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-t unit-test", "-c default-cluster"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); assertThat(commandLine.getOptionValue('t').trim()).isEqualTo("unit-test"); assertThat(commandLine.getOptionValue("c").trim()).isEqualTo("default-cluster"); }
|
### Question:
AllocateMQSubCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt adminExt = new DefaultMQAdminExt(rpcHook); adminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { adminExt.start(); String topic = commandLine.getOptionValue('t').trim(); String ips = commandLine.getOptionValue('i').trim(); final String[] split = ips.split(","); final List<String> ipList = new LinkedList<String>(); for (String ip : split) { ipList.add(ip); } final TopicRouteData topicRouteData = adminExt.examineTopicRouteInfo(topic); final Set<MessageQueue> mqs = MQClientInstance.topicRouteData2TopicSubscribeInfo(topic, topicRouteData); final AllocateMessageQueueAveragely averagely = new AllocateMessageQueueAveragely(); RebalanceResult rr = new RebalanceResult(); for (String i : ipList) { final List<MessageQueue> mqResult = averagely.allocate("aa", i, new ArrayList<MessageQueue>(mqs), ipList); rr.getResult().put(i, mqResult); } final String json = RemotingSerializable.toJson(rr, false); System.out.printf("%s%n", json); } catch (Exception e) { e.printStackTrace(); } finally { adminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { AllocateMQSubCommand cmd = new AllocateMQSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-t unit-test", "-i 127.0.0.1:10911"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); assertThat(commandLine.getOptionValue('t').trim()).isEqualTo("unit-test"); assertThat(commandLine.getOptionValue("i").trim()).isEqualTo("127.0.0.1:10911"); }
|
### Question:
TopicClusterSubCommand implements SubCommand { @Override public void execute(final CommandLine commandLine, final Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); String topic = commandLine.getOptionValue('t').trim(); try { defaultMQAdminExt.start(); Set<String> clusters = defaultMQAdminExt.getTopicClusterList(topic); for (String value : clusters) { System.out.printf("%s%n", value); } } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(final CommandLine commandLine, final Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { TopicClusterSubCommand cmd = new TopicClusterSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-t unit-test"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); assertThat(commandLine.getOptionValue('t').trim()).isEqualTo("unit-test"); }
|
### Question:
TopicStatusSubCommand implements SubCommand { @Override public void execute(final CommandLine commandLine, final Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { defaultMQAdminExt.start(); String topic = commandLine.getOptionValue('t').trim(); TopicStatsTable topicStatsTable = defaultMQAdminExt.examineTopicStats(topic); List<MessageQueue> mqList = new LinkedList<MessageQueue>(); mqList.addAll(topicStatsTable.getOffsetTable().keySet()); Collections.sort(mqList); System.out.printf("%-32s %-4s %-20s %-20s %s%n", "#Broker Name", "#QID", "#Min Offset", "#Max Offset", "#Last Updated" ); for (MessageQueue mq : mqList) { TopicOffset topicOffset = topicStatsTable.getOffsetTable().get(mq); String humanTimestamp = ""; if (topicOffset.getLastUpdateTimestamp() > 0) { humanTimestamp = UtilAll.timeMillisToHumanString2(topicOffset.getLastUpdateTimestamp()); } System.out.printf("%-32s %-4d %-20d %-20d %s%n", UtilAll.frontStringAtLeast(mq.getBrokerName(), 32), mq.getQueueId(), topicOffset.getMinOffset(), topicOffset.getMaxOffset(), humanTimestamp ); } } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(final CommandLine commandLine, final Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { TopicStatusSubCommand cmd = new TopicStatusSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-t unit-test"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); assertThat(commandLine.getOptionValue('t').trim()).isEqualTo("unit-test"); }
|
### Question:
UpdateOrderConfCommand implements SubCommand { @Override public void execute(final CommandLine commandLine, final Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { String topic = commandLine.getOptionValue('t').trim(); String type = commandLine.getOptionValue('m').trim(); if ("get".equals(type)) { defaultMQAdminExt.start(); String orderConf = defaultMQAdminExt.getKVConfig(NamesrvUtil.NAMESPACE_ORDER_TOPIC_CONFIG, topic); System.out.printf("get orderConf success. topic=[%s], orderConf=[%s] ", topic, orderConf); return; } else if ("put".equals(type)) { defaultMQAdminExt.start(); String orderConf = ""; if (commandLine.hasOption('v')) { orderConf = commandLine.getOptionValue('v').trim(); } if (UtilAll.isBlank(orderConf)) { throw new Exception("please set orderConf with option -v."); } defaultMQAdminExt.createOrUpdateOrderConf(topic, orderConf, true); System.out.printf("update orderConf success. topic=[%s], orderConf=[%s]", topic, orderConf.toString()); return; } else if ("delete".equals(type)) { defaultMQAdminExt.start(); defaultMQAdminExt.deleteKvConfig(NamesrvUtil.NAMESPACE_ORDER_TOPIC_CONFIG, topic); System.out.printf("delete orderConf success. topic=[%s]", topic); return; } ServerUtil.printCommandLineHelp("mqadmin " + this.commandName(), options); } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(final CommandLine commandLine, final Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { UpdateOrderConfCommand cmd = new UpdateOrderConfCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-t unit-test", "-v default-broker:8", "-m post"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); assertThat(commandLine.getOptionValue('t').trim()).isEqualTo("unit-test"); assertThat(commandLine.getOptionValue('v').trim()).isEqualTo("default-broker:8"); assertThat(commandLine.getOptionValue('m').trim()).isEqualTo("post"); }
|
### Question:
ProducerManager { public void scanNotActiveChannel() { try { if (this.hashcodeChannelLock.tryLock(LOCK_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) { try { Iterator<Entry<Integer, List<ClientChannelInfo>>> it = this.hashcodeChannelTable.entrySet().iterator(); while (it.hasNext()) { Entry<Integer, List<ClientChannelInfo>> entry = it.next(); final Integer groupHashCode = entry.getKey(); final List<ClientChannelInfo> clientChannelInfoList = entry.getValue(); Iterator<ClientChannelInfo> itChannelInfo = clientChannelInfoList.iterator(); while (itChannelInfo.hasNext()) { ClientChannelInfo clientChannelInfo = itChannelInfo.next(); long diff = System.currentTimeMillis() - clientChannelInfo.getLastUpdateTimestamp(); if (diff > CHANNEL_EXPIRED_TIMEOUT) { log.warn( "SCAN: remove expired channel[{}] from ProducerManager hashcodeChannelTable, producer group hash code: {}", RemotingHelper.parseChannelRemoteAddr(clientChannelInfo.getChannel()), groupHashCode); RemotingUtil.closeChannel(clientChannelInfo.getChannel()); itChannelInfo.remove(); } } } } finally { this.hashcodeChannelLock.unlock(); } } else { log.warn("ProducerManager scanNotActiveChannel lock timeout"); } } catch (InterruptedException e) { log.error("", e); } try { if (this.groupChannelLock.tryLock(LOCK_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) { try { for (final Map.Entry<String, HashMap<Channel, ClientChannelInfo>> entry : this.groupChannelTable .entrySet()) { final String group = entry.getKey(); final HashMap<Channel, ClientChannelInfo> chlMap = entry.getValue(); Iterator<Entry<Channel, ClientChannelInfo>> it = chlMap.entrySet().iterator(); while (it.hasNext()) { Entry<Channel, ClientChannelInfo> item = it.next(); final ClientChannelInfo info = item.getValue(); long diff = System.currentTimeMillis() - info.getLastUpdateTimestamp(); if (diff > CHANNEL_EXPIRED_TIMEOUT) { it.remove(); log.warn( "SCAN: remove expired channel[{}] from ProducerManager groupChannelTable, producer group name: {}", RemotingHelper.parseChannelRemoteAddr(info.getChannel()), group); RemotingUtil.closeChannel(info.getChannel()); } } } } finally { this.groupChannelLock.unlock(); } } else { log.warn("ProducerManager scanNotActiveChannel lock timeout"); } } catch (InterruptedException e) { log.error("", e); } } ProducerManager(); HashMap<String, HashMap<Channel, ClientChannelInfo>> getGroupChannelTable(); void scanNotActiveChannel(); void doChannelCloseEvent(final String remoteAddr, final Channel channel); void registerProducer(final String group, final ClientChannelInfo clientChannelInfo); void unregisterProducer(final String group, final ClientChannelInfo clientChannelInfo); ClientChannelInfo pickProducerChannelRandomly(final int producerGroupHashCode); }### Answer:
@Test public void scanNotActiveChannel() throws Exception { producerManager.registerProducer(group, clientInfo); assertThat(producerManager.getGroupChannelTable().get(group).get(channel)).isNotNull(); Field field = ProducerManager.class.getDeclaredField("CHANNEL_EXPIRED_TIMEOUT"); field.setAccessible(true); long CHANNEL_EXPIRED_TIMEOUT = field.getLong(producerManager); clientInfo.setLastUpdateTimestamp(System.currentTimeMillis() - CHANNEL_EXPIRED_TIMEOUT - 10); when(channel.close()).thenReturn(mock(ChannelFuture.class)); producerManager.scanNotActiveChannel(); assertThat(producerManager.getGroupChannelTable().get(group).get(channel)).isNull(); }
|
### Question:
ProducerManager { public void doChannelCloseEvent(final String remoteAddr, final Channel channel) { if (channel != null) { try { if (this.hashcodeChannelLock.tryLock(LOCK_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) { try { for (final Map.Entry<Integer, List<ClientChannelInfo>> entry : this.hashcodeChannelTable .entrySet()) { final Integer groupHashCode = entry.getKey(); final List<ClientChannelInfo> clientChannelInfoList = entry.getValue(); boolean result = clientChannelInfoList.remove(new ClientChannelInfo(channel)); if (result) { log.info( "NETTY EVENT: remove channel[{}][{}] from ProducerManager hashcodeChannelTable, producer group hash code: {}", RemotingHelper.parseChannelRemoteAddr(channel), remoteAddr, groupHashCode); } } } finally { this.hashcodeChannelLock.unlock(); } } else { log.warn("ProducerManager doChannelCloseEvent lock timeout"); } } catch (InterruptedException e) { log.error("", e); } try { if (this.groupChannelLock.tryLock(LOCK_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) { try { for (final Map.Entry<String, HashMap<Channel, ClientChannelInfo>> entry : this.groupChannelTable .entrySet()) { final String group = entry.getKey(); final HashMap<Channel, ClientChannelInfo> clientChannelInfoTable = entry.getValue(); final ClientChannelInfo clientChannelInfo = clientChannelInfoTable.remove(channel); if (clientChannelInfo != null) { log.info( "NETTY EVENT: remove channel[{}][{}] from ProducerManager groupChannelTable, producer group: {}", clientChannelInfo.toString(), remoteAddr, group); } } } finally { this.groupChannelLock.unlock(); } } else { log.warn("ProducerManager doChannelCloseEvent lock timeout"); } } catch (InterruptedException e) { log.error("", e); } } } ProducerManager(); HashMap<String, HashMap<Channel, ClientChannelInfo>> getGroupChannelTable(); void scanNotActiveChannel(); void doChannelCloseEvent(final String remoteAddr, final Channel channel); void registerProducer(final String group, final ClientChannelInfo clientChannelInfo); void unregisterProducer(final String group, final ClientChannelInfo clientChannelInfo); ClientChannelInfo pickProducerChannelRandomly(final int producerGroupHashCode); }### Answer:
@Test public void doChannelCloseEvent() throws Exception { producerManager.registerProducer(group, clientInfo); assertThat(producerManager.getGroupChannelTable().get(group).get(channel)).isNotNull(); producerManager.doChannelCloseEvent("127.0.0.1", channel); assertThat(producerManager.getGroupChannelTable().get(group).get(channel)).isNull(); }
|
### Question:
ProducerManager { public void registerProducer(final String group, final ClientChannelInfo clientChannelInfo) { try { ClientChannelInfo clientChannelInfoFound = null; if (this.hashcodeChannelLock.tryLock(LOCK_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) { try { List<ClientChannelInfo> clientChannelInfoList = this.hashcodeChannelTable.get(group.hashCode()); if (null == clientChannelInfoList) { clientChannelInfoList = new ArrayList<ClientChannelInfo>(); this.hashcodeChannelTable.put(group.hashCode(), clientChannelInfoList); } int index = clientChannelInfoList.indexOf(clientChannelInfo); if (index >= 0) { clientChannelInfoFound = clientChannelInfoList.get(index); } if (null == clientChannelInfoFound) { clientChannelInfoList.add(clientChannelInfo); } } finally { this.hashcodeChannelLock.unlock(); } if (clientChannelInfoFound != null) { clientChannelInfoFound.setLastUpdateTimestamp(System.currentTimeMillis()); } } else { log.warn("ProducerManager registerProducer lock timeout"); } } catch (InterruptedException e) { log.error("", e); } try { ClientChannelInfo clientChannelInfoFound = null; if (this.groupChannelLock.tryLock(LOCK_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) { try { HashMap<Channel, ClientChannelInfo> channelTable = this.groupChannelTable.get(group); if (null == channelTable) { channelTable = new HashMap<>(); this.groupChannelTable.put(group, channelTable); } clientChannelInfoFound = channelTable.get(clientChannelInfo.getChannel()); if (null == clientChannelInfoFound) { channelTable.put(clientChannelInfo.getChannel(), clientChannelInfo); log.info("new producer connected, group: {} channel: {}", group, clientChannelInfo.toString()); } } finally { this.groupChannelLock.unlock(); } if (clientChannelInfoFound != null) { clientChannelInfoFound.setLastUpdateTimestamp(System.currentTimeMillis()); } } else { log.warn("ProducerManager registerProducer lock timeout"); } } catch (InterruptedException e) { log.error("", e); } } ProducerManager(); HashMap<String, HashMap<Channel, ClientChannelInfo>> getGroupChannelTable(); void scanNotActiveChannel(); void doChannelCloseEvent(final String remoteAddr, final Channel channel); void registerProducer(final String group, final ClientChannelInfo clientChannelInfo); void unregisterProducer(final String group, final ClientChannelInfo clientChannelInfo); ClientChannelInfo pickProducerChannelRandomly(final int producerGroupHashCode); }### Answer:
@Test public void testRegisterProducer() throws Exception { producerManager.registerProducer(group, clientInfo); HashMap<Channel, ClientChannelInfo> channelMap = producerManager.getGroupChannelTable().get(group); assertThat(channelMap).isNotNull(); assertThat(channelMap.get(channel)).isEqualTo(clientInfo); }
|
### Question:
ProducerManager { public void unregisterProducer(final String group, final ClientChannelInfo clientChannelInfo) { try { if (this.hashcodeChannelLock.tryLock(LOCK_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) { try { List<ClientChannelInfo> clientChannelInfoList = this.hashcodeChannelTable.get(group.hashCode()); if (null != clientChannelInfoList && !clientChannelInfoList.isEmpty()) { boolean result = clientChannelInfoList.remove(clientChannelInfo); if (result) { log.info("unregister a producer[{}] from hashcodeChannelTable {}", group, clientChannelInfo.toString()); } if (clientChannelInfoList.isEmpty()) { this.hashcodeChannelTable.remove(group.hashCode()); log.info("unregister a producer group[{}] from hashcodeChannelTable", group); } } } finally { this.hashcodeChannelLock.unlock(); } } else { log.warn("ProducerManager unregisterProducer lock timeout"); } } catch (InterruptedException e) { log.error("", e); } try { if (this.groupChannelLock.tryLock(LOCK_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)) { try { HashMap<Channel, ClientChannelInfo> channelTable = this.groupChannelTable.get(group); if (null != channelTable && !channelTable.isEmpty()) { ClientChannelInfo old = channelTable.remove(clientChannelInfo.getChannel()); if (old != null) { log.info("unregister a producer[{}] from groupChannelTable {}", group, clientChannelInfo.toString()); } if (channelTable.isEmpty()) { this.groupChannelTable.remove(group); log.info("unregister a producer group[{}] from groupChannelTable", group); } } } finally { this.groupChannelLock.unlock(); } } else { log.warn("ProducerManager unregisterProducer lock timeout"); } } catch (InterruptedException e) { log.error("", e); } } ProducerManager(); HashMap<String, HashMap<Channel, ClientChannelInfo>> getGroupChannelTable(); void scanNotActiveChannel(); void doChannelCloseEvent(final String remoteAddr, final Channel channel); void registerProducer(final String group, final ClientChannelInfo clientChannelInfo); void unregisterProducer(final String group, final ClientChannelInfo clientChannelInfo); ClientChannelInfo pickProducerChannelRandomly(final int producerGroupHashCode); }### Answer:
@Test public void unregisterProducer() throws Exception { producerManager.registerProducer(group, clientInfo); HashMap<Channel, ClientChannelInfo> channelMap = producerManager.getGroupChannelTable().get(group); assertThat(channelMap).isNotNull(); assertThat(channelMap.get(channel)).isEqualTo(clientInfo); producerManager.unregisterProducer(group, clientInfo); channelMap = producerManager.getGroupChannelTable().get(group); assertThat(channelMap).isNull(); }
|
### Question:
SendMessageProcessor extends AbstractSendMessageProcessor implements NettyRequestProcessor { @Override public RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request) throws RemotingCommandException { SendMessageContext mqtraceContext; switch (request.getCode()) { case RequestCode.CONSUMER_SEND_MSG_BACK: return this.consumerSendMsgBack(ctx, request); default: SendMessageRequestHeader requestHeader = parseRequestHeader(request); if (requestHeader == null) { return null; } mqtraceContext = buildMsgContext(ctx, requestHeader); this.executeSendMessageHookBefore(ctx, request, mqtraceContext); final RemotingCommand response = this.sendMessage(ctx, request, mqtraceContext, requestHeader); this.executeSendMessageHookAfter(response, mqtraceContext); return response; } } SendMessageProcessor(final BrokerController brokerController); @Override RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request); @Override boolean rejectRequest(); boolean hasConsumeMessageHook(); void executeConsumeMessageHookAfter(final ConsumeMessageContext context); SocketAddress getStoreHost(); void registerConsumeMessageHook(List<ConsumeMessageHook> consumeMessageHookList); }### Answer:
@Test public void testProcessRequest() throws RemotingCommandException { when(messageStore.putMessage(any(MessageExtBrokerInner.class))).thenReturn(new PutMessageResult(PutMessageStatus.PUT_OK, new AppendMessageResult(AppendMessageStatus.PUT_OK))); assertPutResult(ResponseCode.SUCCESS); }
@Test public void testProcessRequest_WithMsgBack() throws RemotingCommandException { when(messageStore.putMessage(any(MessageExtBrokerInner.class))).thenReturn(new PutMessageResult(PutMessageStatus.PUT_OK, new AppendMessageResult(AppendMessageStatus.PUT_OK))); final RemotingCommand request = createSendMsgBackCommand(RequestCode.CONSUMER_SEND_MSG_BACK); sendMessageProcessor = new SendMessageProcessor(brokerController); final RemotingCommand response = sendMessageProcessor.processRequest(handlerContext, request); assertThat(response).isNotNull(); assertThat(response.getCode()).isEqualTo(ResponseCode.SUCCESS); }
|
### Question:
ClientManageProcessor implements NettyRequestProcessor { @Override public RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request) throws RemotingCommandException { switch (request.getCode()) { case RequestCode.HEART_BEAT: return this.heartBeat(ctx, request); case RequestCode.UNREGISTER_CLIENT: return this.unregisterClient(ctx, request); default: break; } return null; } ClientManageProcessor(final BrokerController brokerController); @Override RemotingCommand processRequest(ChannelHandlerContext ctx, RemotingCommand request); @Override boolean rejectRequest(); RemotingCommand heartBeat(ChannelHandlerContext ctx, RemotingCommand request); RemotingCommand unregisterClient(ChannelHandlerContext ctx, RemotingCommand request); }### Answer:
@Test public void processRequest_UnRegisterProducer() throws Exception { brokerController.getProducerManager().registerProducer(group, clientChannelInfo); HashMap<Channel, ClientChannelInfo> channelMap = brokerController.getProducerManager().getGroupChannelTable().get(group); assertThat(channelMap).isNotNull(); assertThat(channelMap.get(channel)).isEqualTo(clientChannelInfo); RemotingCommand request = createUnRegisterProducerCommand(); RemotingCommand response = clientManageProcessor.processRequest(handlerContext, request); assertThat(response).isNotNull(); assertThat(response.getCode()).isEqualTo(ResponseCode.SUCCESS); channelMap = brokerController.getProducerManager().getGroupChannelTable().get(group); assertThat(channelMap).isNull(); }
@Test public void processRequest_UnRegisterConsumer() throws RemotingCommandException { ConsumerGroupInfo consumerGroupInfo = brokerController.getConsumerManager().getConsumerGroupInfo(group); assertThat(consumerGroupInfo).isNotNull(); RemotingCommand request = createUnRegisterConsumerCommand(); RemotingCommand response = clientManageProcessor.processRequest(handlerContext, request); assertThat(response).isNotNull(); assertThat(response.getCode()).isEqualTo(ResponseCode.SUCCESS); consumerGroupInfo = brokerController.getConsumerManager().getConsumerGroupInfo(group); assertThat(consumerGroupInfo).isNull(); }
|
### Question:
MappedFile extends ReferenceResource { public SelectMappedBufferResult selectMappedBuffer(int pos, int size) { int readPosition = getReadPosition(); if ((pos + size) <= readPosition) { if (this.hold()) { ByteBuffer byteBuffer = this.mappedByteBuffer.slice(); byteBuffer.position(pos); ByteBuffer byteBufferNew = byteBuffer.slice(); byteBufferNew.limit(size); return new SelectMappedBufferResult(this.fileFromOffset + pos, byteBufferNew, size, this); } else { log.warn("matched, but hold failed, request pos: " + pos + ", fileFromOffset: " + this.fileFromOffset); } } else { log.warn("selectMappedBuffer request pos invalid, request pos: " + pos + ", size: " + size + ", fileFromOffset: " + this.fileFromOffset); } return null; } MappedFile(); MappedFile(final String fileName, final int fileSize); MappedFile(final String fileName, final int fileSize, final TransientStorePool transientStorePool); static void ensureDirOK(final String dirName); static void clean(final ByteBuffer buffer); static int getTotalMappedFiles(); static long getTotalMappedVirtualMemory(); void init(final String fileName, final int fileSize, final TransientStorePool transientStorePool); long getLastModifiedTimestamp(); int getFileSize(); FileChannel getFileChannel(); AppendMessageResult appendMessage(final MessageExtBrokerInner msg, final AppendMessageCallback cb); long getFileFromOffset(); boolean appendMessage(final byte[] data); int flush(final int flushLeastPages); int commit(final int commitLeastPages); int getFlushedPosition(); void setFlushedPosition(int pos); boolean isFull(); SelectMappedBufferResult selectMappedBuffer(int pos, int size); SelectMappedBufferResult selectMappedBuffer(int pos); @Override boolean cleanup(final long currentRef); boolean destroy(final long intervalForcibly); int getWrotePosition(); void setWrotePosition(int pos); int getReadPosition(); void setCommittedPosition(int pos); void warmMappedFile(FlushDiskType type, int pages); String getFileName(); MappedByteBuffer getMappedByteBuffer(); ByteBuffer sliceByteBuffer(); long getStoreTimestamp(); boolean isFirstCreateInQueue(); void setFirstCreateInQueue(boolean firstCreateInQueue); void mlock(); void munlock(); @Override String toString(); static final int OS_PAGE_SIZE; }### Answer:
@Test public void testSelectMappedBuffer() throws IOException { MappedFile mappedFile = new MappedFile("target/unit_test_store/MappedFileTest/000", 1024 * 64); boolean result = mappedFile.appendMessage(storeMessage.getBytes()); assertThat(result).isTrue(); SelectMappedBufferResult selectMappedBufferResult = mappedFile.selectMappedBuffer(0); byte[] data = new byte[storeMessage.length()]; selectMappedBufferResult.getByteBuffer().get(data); String readString = new String(data); assertThat(readString).isEqualTo(storeMessage); mappedFile.shutdown(1000); assertThat(mappedFile.isAvailable()).isFalse(); selectMappedBufferResult.release(); assertThat(mappedFile.isCleanupOver()).isTrue(); assertThat(mappedFile.destroy(1000)).isTrue(); }
|
### Question:
MappedFileQueue { public MappedFile getLastMappedFile(final long startOffset, boolean needCreate) { long createOffset = -1; MappedFile mappedFileLast = getLastMappedFile(); if (mappedFileLast == null) { createOffset = startOffset - (startOffset % this.mappedFileSize); } if (mappedFileLast != null && mappedFileLast.isFull()) { createOffset = mappedFileLast.getFileFromOffset() + this.mappedFileSize; } if (createOffset != -1 && needCreate) { String nextFilePath = this.storePath + File.separator + UtilAll.offset2FileName(createOffset); String nextNextFilePath = this.storePath + File.separator + UtilAll.offset2FileName(createOffset + this.mappedFileSize); MappedFile mappedFile = null; if (this.allocateMappedFileService != null) { mappedFile = this.allocateMappedFileService.putRequestAndReturnMappedFile(nextFilePath, nextNextFilePath, this.mappedFileSize); } else { try { mappedFile = new MappedFile(nextFilePath, this.mappedFileSize); } catch (IOException e) { log.error("create mappedFile exception", e); } } if (mappedFile != null) { if (this.mappedFiles.isEmpty()) { mappedFile.setFirstCreateInQueue(true); } this.mappedFiles.add(mappedFile); } return mappedFile; } return mappedFileLast; } MappedFileQueue(final String storePath, int mappedFileSize,
AllocateMappedFileService allocateMappedFileService); void checkSelf(); MappedFile getMappedFileByTime(final long timestamp); void truncateDirtyFiles(long offset); boolean load(); long howMuchFallBehind(); MappedFile getLastMappedFile(final long startOffset, boolean needCreate); MappedFile getLastMappedFile(final long startOffset); MappedFile getLastMappedFile(); boolean resetOffset(long offset); long getMinOffset(); long getMaxOffset(); long getMaxWrotePosition(); long remainHowManyDataToCommit(); long remainHowManyDataToFlush(); void deleteLastMappedFile(); int deleteExpiredFileByTime(final long expiredTime,
final int deleteFilesInterval,
final long intervalForcibly,
final boolean cleanImmediately,
final long minTransOffset); int deleteExpiredFileByOffset(long offset, int unitSize); boolean flush(final int flushLeastPages); boolean commit(final int commitLeastPages); List<MappedFile> findGreaterThanMappedFileByOffset(final long offset); MappedFile findMappedFileByOffset(final long offset, final boolean returnFirstOnNotFound); MappedFile getFirstMappedFile(); MappedFile findMappedFileByOffset(final long offset); long getMappedMemorySize(); boolean retryDeleteFirstFile(final long intervalForcibly); void shutdown(final long intervalForcibly); void destroy(); long getFlushedWhere(); void setFlushedWhere(long flushedWhere); long getStoreTimestamp(); List<MappedFile> getMappedFiles(); int getMappedFileSize(); long getCommittedWhere(); void setCommittedWhere(final long committedWhere); }### Answer:
@Test public void testGetLastMappedFile() { final String fixedMsg = "0123456789abcdef"; MappedFileQueue mappedFileQueue = new MappedFileQueue("target/unit_test_store/a/", 1024, null); for (int i = 0; i < 1024; i++) { MappedFile mappedFile = mappedFileQueue.getLastMappedFile(0); assertThat(mappedFile).isNotNull(); assertThat(mappedFile.appendMessage(fixedMsg.getBytes())).isTrue(); } mappedFileQueue.shutdown(1000); mappedFileQueue.destroy(); }
|
### Question:
MappedFileQueue { public long getMappedMemorySize() { long size = 0; Object[] mfs = this.copyMappedFiles(0); if (mfs != null) { for (Object mf : mfs) { if (((ReferenceResource) mf).isAvailable()) { size += this.mappedFileSize; } } } return size; } MappedFileQueue(final String storePath, int mappedFileSize,
AllocateMappedFileService allocateMappedFileService); void checkSelf(); MappedFile getMappedFileByTime(final long timestamp); void truncateDirtyFiles(long offset); boolean load(); long howMuchFallBehind(); MappedFile getLastMappedFile(final long startOffset, boolean needCreate); MappedFile getLastMappedFile(final long startOffset); MappedFile getLastMappedFile(); boolean resetOffset(long offset); long getMinOffset(); long getMaxOffset(); long getMaxWrotePosition(); long remainHowManyDataToCommit(); long remainHowManyDataToFlush(); void deleteLastMappedFile(); int deleteExpiredFileByTime(final long expiredTime,
final int deleteFilesInterval,
final long intervalForcibly,
final boolean cleanImmediately,
final long minTransOffset); int deleteExpiredFileByOffset(long offset, int unitSize); boolean flush(final int flushLeastPages); boolean commit(final int commitLeastPages); List<MappedFile> findGreaterThanMappedFileByOffset(final long offset); MappedFile findMappedFileByOffset(final long offset, final boolean returnFirstOnNotFound); MappedFile getFirstMappedFile(); MappedFile findMappedFileByOffset(final long offset); long getMappedMemorySize(); boolean retryDeleteFirstFile(final long intervalForcibly); void shutdown(final long intervalForcibly); void destroy(); long getFlushedWhere(); void setFlushedWhere(long flushedWhere); long getStoreTimestamp(); List<MappedFile> getMappedFiles(); int getMappedFileSize(); long getCommittedWhere(); void setCommittedWhere(final long committedWhere); }### Answer:
@Test public void testGetMappedMemorySize() { final String fixedMsg = "abcd"; MappedFileQueue mappedFileQueue = new MappedFileQueue("target/unit_test_store/d/", 1024, null); for (int i = 0; i < 1024; i++) { MappedFile mappedFile = mappedFileQueue.getLastMappedFile(0); assertThat(mappedFile).isNotNull(); assertThat(mappedFile.appendMessage(fixedMsg.getBytes())).isTrue(); } assertThat(mappedFileQueue.getMappedMemorySize()).isEqualTo(fixedMsg.length() * 1024); mappedFileQueue.shutdown(1000); mappedFileQueue.destroy(); }
|
### Question:
FilterAPI { public static SubscriptionData buildSubscriptionData(final String consumerGroup, String topic, String subString) throws Exception { SubscriptionData subscriptionData = new SubscriptionData(); subscriptionData.setTopic(topic); subscriptionData.setSubString(subString); if (null == subString || subString.equals(SubscriptionData.SUB_ALL) || subString.length() == 0) { subscriptionData.setSubString(SubscriptionData.SUB_ALL); } else { String[] tags = subString.split("\\|\\|"); if (tags.length > 0) { for (String tag : tags) { if (tag.length() > 0) { String trimString = tag.trim(); if (trimString.length() > 0) { subscriptionData.getTagsSet().add(trimString); subscriptionData.getCodeSet().add(trimString.hashCode()); } } } } else { throw new Exception("subString split error"); } } return subscriptionData; } static URL classFile(final String className); static String simpleClassName(final String className); static SubscriptionData buildSubscriptionData(final String consumerGroup, String topic,
String subString); }### Answer:
@Test public void testBuildSubscriptionData() throws Exception { SubscriptionData subscriptionData = FilterAPI.buildSubscriptionData(group, topic, subString); assertThat(subscriptionData.getTopic()).isEqualTo(topic); assertThat(subscriptionData.getSubString()).isEqualTo(subString); String [] tags = subString.split("\\|\\|"); Set<String> tagSet = new HashSet<>(); for (String tag : tags) { tagSet.add(tag.trim()); } assertThat(subscriptionData.getTagsSet()).isEqualTo(tagSet); }
|
### Question:
ConsumerConnectionSubCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { defaultMQAdminExt.start(); String group = commandLine.getOptionValue('g').trim(); ConsumerConnection cc = defaultMQAdminExt.examineConsumerConnectionInfo(group); int i = 1; for (Connection conn : cc.getConnectionSet()) { System.out.printf("%03d %-32s %-22s %-8s %s%n", i++, conn.getClientId(), conn.getClientAddr(), conn.getLanguage(), MQVersion.getVersionDesc(conn.getVersion()) ); } System.out.printf("%nBelow is subscription:"); Iterator<Entry<String, SubscriptionData>> it = cc.getSubscriptionTable().entrySet().iterator(); i = 1; while (it.hasNext()) { Entry<String, SubscriptionData> entry = it.next(); SubscriptionData sd = entry.getValue(); System.out.printf("%03d Topic: %-40s SubExpression: %s%n", i++, sd.getTopic(), sd.getSubString() ); } System.out.printf(""); System.out.printf("ConsumeType: %s%n", cc.getConsumeType()); System.out.printf("MessageModel: %s%n", cc.getMessageModel()); System.out.printf("ConsumeFromWhere: %s%n", cc.getConsumeFromWhere()); } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { ConsumerConnectionSubCommand cmd = new ConsumerConnectionSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-g default-consumer-group"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
UtilAll { public static String currentStackTrace() { StringBuilder sb = new StringBuilder(); StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace(); for (StackTraceElement ste : stackTrace) { sb.append("\n\t"); sb.append(ste.toString()); } return sb.toString(); } static int getPid(); static String currentStackTrace(); static String offset2FileName(final long offset); static long computeEclipseTimeMilliseconds(final long beginTime); static boolean isItTimeToDo(final String when); static String timeMillisToHumanString(); static String timeMillisToHumanString(final long t); static long computNextMorningTimeMillis(); static long computNextMinutesTimeMillis(); static long computNextHourTimeMillis(); static long computNextHalfHourTimeMillis(); static String timeMillisToHumanString2(final long t); static String timeMillisToHumanString3(final long t); static double getDiskPartitionSpaceUsedPercent(final String path); static int crc32(byte[] array); static int crc32(byte[] array, int offset, int length); static String bytes2string(byte[] src); static byte[] string2bytes(String hexString); static byte[] uncompress(final byte[] src); static byte[] compress(final byte[] src, final int level); static int asInt(String str, int defaultValue); static long asLong(String str, long defaultValue); static String formatDate(Date date, String pattern); static Date parseDate(String date, String pattern); static String responseCode2String(final int code); static String frontStringAtLeast(final String str, final int size); static boolean isBlank(String str); static String jstack(); static String jstack(Map<Thread, StackTraceElement[]> map); static boolean isInternalIP(byte[] ip); static String ipToIPv4Str(byte[] ip); static byte[] getIP(); static final String YYYY_MM_DD_HH_MM_SS; static final String YYYY_MM_DD_HH_MM_SS_SSS; static final String YYYY_MMDD_HHMMSS; }### Answer:
@Test public void testCurrentStackTrace() { String currentStackTrace = UtilAll.currentStackTrace(); assertThat(currentStackTrace).contains("UtilAll.currentStackTrace"); assertThat(currentStackTrace).contains("UtilAllTest.testCurrentStackTrace("); }
|
### Question:
UtilAll { public static int getPid() { RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean(); String name = runtime.getName(); try { return Integer.parseInt(name.substring(0, name.indexOf('@'))); } catch (Exception e) { return -1; } } static int getPid(); static String currentStackTrace(); static String offset2FileName(final long offset); static long computeEclipseTimeMilliseconds(final long beginTime); static boolean isItTimeToDo(final String when); static String timeMillisToHumanString(); static String timeMillisToHumanString(final long t); static long computNextMorningTimeMillis(); static long computNextMinutesTimeMillis(); static long computNextHourTimeMillis(); static long computNextHalfHourTimeMillis(); static String timeMillisToHumanString2(final long t); static String timeMillisToHumanString3(final long t); static double getDiskPartitionSpaceUsedPercent(final String path); static int crc32(byte[] array); static int crc32(byte[] array, int offset, int length); static String bytes2string(byte[] src); static byte[] string2bytes(String hexString); static byte[] uncompress(final byte[] src); static byte[] compress(final byte[] src, final int level); static int asInt(String str, int defaultValue); static long asLong(String str, long defaultValue); static String formatDate(Date date, String pattern); static Date parseDate(String date, String pattern); static String responseCode2String(final int code); static String frontStringAtLeast(final String str, final int size); static boolean isBlank(String str); static String jstack(); static String jstack(Map<Thread, StackTraceElement[]> map); static boolean isInternalIP(byte[] ip); static String ipToIPv4Str(byte[] ip); static byte[] getIP(); static final String YYYY_MM_DD_HH_MM_SS; static final String YYYY_MM_DD_HH_MM_SS_SSS; static final String YYYY_MMDD_HHMMSS; }### Answer:
@Test public void testGetPid() { assertThat(UtilAll.getPid()).isGreaterThan(0); }
|
### Question:
UtilAll { public static double getDiskPartitionSpaceUsedPercent(final String path) { if (null == path || path.isEmpty()) return -1; try { File file = new File(path); if (!file.exists()) return -1; long totalSpace = file.getTotalSpace(); if (totalSpace > 0) { long freeSpace = file.getFreeSpace(); long usedSpace = totalSpace - freeSpace; return usedSpace / (double) totalSpace; } } catch (Exception e) { return -1; } return -1; } static int getPid(); static String currentStackTrace(); static String offset2FileName(final long offset); static long computeEclipseTimeMilliseconds(final long beginTime); static boolean isItTimeToDo(final String when); static String timeMillisToHumanString(); static String timeMillisToHumanString(final long t); static long computNextMorningTimeMillis(); static long computNextMinutesTimeMillis(); static long computNextHourTimeMillis(); static long computNextHalfHourTimeMillis(); static String timeMillisToHumanString2(final long t); static String timeMillisToHumanString3(final long t); static double getDiskPartitionSpaceUsedPercent(final String path); static int crc32(byte[] array); static int crc32(byte[] array, int offset, int length); static String bytes2string(byte[] src); static byte[] string2bytes(String hexString); static byte[] uncompress(final byte[] src); static byte[] compress(final byte[] src, final int level); static int asInt(String str, int defaultValue); static long asLong(String str, long defaultValue); static String formatDate(Date date, String pattern); static Date parseDate(String date, String pattern); static String responseCode2String(final int code); static String frontStringAtLeast(final String str, final int size); static boolean isBlank(String str); static String jstack(); static String jstack(Map<Thread, StackTraceElement[]> map); static boolean isInternalIP(byte[] ip); static String ipToIPv4Str(byte[] ip); static byte[] getIP(); static final String YYYY_MM_DD_HH_MM_SS; static final String YYYY_MM_DD_HH_MM_SS_SSS; static final String YYYY_MMDD_HHMMSS; }### Answer:
@Test public void testGetDiskPartitionSpaceUsedPercent() { String tmpDir = System.getProperty("java.io.tmpdir"); assertThat(UtilAll.getDiskPartitionSpaceUsedPercent(null)).isCloseTo(-1, within(0.000001)); assertThat(UtilAll.getDiskPartitionSpaceUsedPercent("")).isCloseTo(-1, within(0.000001)); assertThat(UtilAll.getDiskPartitionSpaceUsedPercent("nonExistingPath")).isCloseTo(-1, within(0.000001)); assertThat(UtilAll.getDiskPartitionSpaceUsedPercent(tmpDir)).isNotCloseTo(-1, within(0.000001)); }
|
### Question:
UtilAll { public static boolean isBlank(String str) { int strLen; if (str == null || (strLen = str.length()) == 0) { return true; } for (int i = 0; i < strLen; i++) { if (!Character.isWhitespace(str.charAt(i))) { return false; } } return true; } static int getPid(); static String currentStackTrace(); static String offset2FileName(final long offset); static long computeEclipseTimeMilliseconds(final long beginTime); static boolean isItTimeToDo(final String when); static String timeMillisToHumanString(); static String timeMillisToHumanString(final long t); static long computNextMorningTimeMillis(); static long computNextMinutesTimeMillis(); static long computNextHourTimeMillis(); static long computNextHalfHourTimeMillis(); static String timeMillisToHumanString2(final long t); static String timeMillisToHumanString3(final long t); static double getDiskPartitionSpaceUsedPercent(final String path); static int crc32(byte[] array); static int crc32(byte[] array, int offset, int length); static String bytes2string(byte[] src); static byte[] string2bytes(String hexString); static byte[] uncompress(final byte[] src); static byte[] compress(final byte[] src, final int level); static int asInt(String str, int defaultValue); static long asLong(String str, long defaultValue); static String formatDate(Date date, String pattern); static Date parseDate(String date, String pattern); static String responseCode2String(final int code); static String frontStringAtLeast(final String str, final int size); static boolean isBlank(String str); static String jstack(); static String jstack(Map<Thread, StackTraceElement[]> map); static boolean isInternalIP(byte[] ip); static String ipToIPv4Str(byte[] ip); static byte[] getIP(); static final String YYYY_MM_DD_HH_MM_SS; static final String YYYY_MM_DD_HH_MM_SS_SSS; static final String YYYY_MMDD_HHMMSS; }### Answer:
@Test public void testIsBlank() { assertThat(UtilAll.isBlank("Hello ")).isFalse(); assertThat(UtilAll.isBlank(" Hello")).isFalse(); assertThat(UtilAll.isBlank("He llo")).isFalse(); assertThat(UtilAll.isBlank(" ")).isTrue(); assertThat(UtilAll.isBlank("Hello")).isFalse(); }
|
### Question:
MixAll { public static String brokerVIPChannel(final boolean isChange, final String brokerAddr) { if (isChange) { String[] ipAndPort = brokerAddr.split(":"); String brokerAddrNew = ipAndPort[0] + ":" + (Integer.parseInt(ipAndPort[1]) - 2); return brokerAddrNew; } else { return brokerAddr; } } static String getRetryTopic(final String consumerGroup); static boolean isSysConsumerGroup(final String consumerGroup); static boolean isSystemTopic(final String topic); static String getDLQTopic(final String consumerGroup); static String brokerVIPChannel(final boolean isChange, final String brokerAddr); static long getPID(); static long createBrokerId(final String ip, final int port); static void string2File(final String str, final String fileName); static void string2FileNotSafe(final String str, final String fileName); static String file2String(final String fileName); static String file2String(final File file); static String file2String(final URL url); static String findClassPath(Class<?> c); static void printObjectProperties(final Logger log, final Object object); static void printObjectProperties(final Logger log, final Object object, final boolean onlyImportantField); static String properties2String(final Properties properties); static Properties string2Properties(final String str); static Properties object2Properties(final Object object); static void properties2Object(final Properties p, final Object object); static boolean isPropertiesEqual(final Properties p1, final Properties p2); static List<String> getLocalInetAddress(); static boolean isLocalAddr(String address); static boolean compareAndIncreaseOnly(final AtomicLong target, final long value); static String localhostName(); static String humanReadableByteCount(long bytes, boolean si); Set<String> list2Set(List<String> values); List<String> set2List(Set<String> values); static final String ROCKETMQ_HOME_ENV; static final String ROCKETMQ_HOME_PROPERTY; static final String NAMESRV_ADDR_ENV; static final String NAMESRV_ADDR_PROPERTY; static final String MESSAGE_COMPRESS_LEVEL; static final String DEFAULT_NAMESRV_ADDR_LOOKUP; static final String WS_DOMAIN_NAME; static final String WS_DOMAIN_SUBGROUP; static final String WS_ADDR; static final String DEFAULT_TOPIC; static final String BENCHMARK_TOPIC; static final String DEFAULT_PRODUCER_GROUP; static final String DEFAULT_CONSUMER_GROUP; static final String TOOLS_CONSUMER_GROUP; static final String FILTERSRV_CONSUMER_GROUP; static final String MONITOR_CONSUMER_GROUP; static final String CLIENT_INNER_PRODUCER_GROUP; static final String SELF_TEST_PRODUCER_GROUP; static final String SELF_TEST_CONSUMER_GROUP; static final String SELF_TEST_TOPIC; static final String OFFSET_MOVED_EVENT; static final String ONS_HTTP_PROXY_GROUP; static final String CID_ONSAPI_PERMISSION_GROUP; static final String CID_ONSAPI_OWNER_GROUP; static final String CID_ONSAPI_PULL_GROUP; static final String CID_RMQ_SYS_PREFIX; static final List<String> LOCAL_INET_ADDRESS; static final String LOCALHOST; static final String DEFAULT_CHARSET; static final long MASTER_ID; static final long CURRENT_JVM_PID; static final String RETRY_GROUP_TOPIC_PREFIX; static final String DLQ_GROUP_TOPIC_PREFIX; static final String SYSTEM_TOPIC_PREFIX; static final String UNIQUE_MSG_QUERY_FLAG; static final String DEFAULT_TRACE_REGION_ID; static final String CONSUME_CONTEXT_TYPE; }### Answer:
@Test public void testBrokerVIPChannel() { assertThat(MixAll.brokerVIPChannel(true, "127.0.0.1:10911")).isEqualTo("127.0.0.1:10909"); }
|
### Question:
MixAll { public static boolean compareAndIncreaseOnly(final AtomicLong target, final long value) { long prev = target.get(); while (value > prev) { boolean updated = target.compareAndSet(prev, value); if (updated) return true; prev = target.get(); } return false; } static String getRetryTopic(final String consumerGroup); static boolean isSysConsumerGroup(final String consumerGroup); static boolean isSystemTopic(final String topic); static String getDLQTopic(final String consumerGroup); static String brokerVIPChannel(final boolean isChange, final String brokerAddr); static long getPID(); static long createBrokerId(final String ip, final int port); static void string2File(final String str, final String fileName); static void string2FileNotSafe(final String str, final String fileName); static String file2String(final String fileName); static String file2String(final File file); static String file2String(final URL url); static String findClassPath(Class<?> c); static void printObjectProperties(final Logger log, final Object object); static void printObjectProperties(final Logger log, final Object object, final boolean onlyImportantField); static String properties2String(final Properties properties); static Properties string2Properties(final String str); static Properties object2Properties(final Object object); static void properties2Object(final Properties p, final Object object); static boolean isPropertiesEqual(final Properties p1, final Properties p2); static List<String> getLocalInetAddress(); static boolean isLocalAddr(String address); static boolean compareAndIncreaseOnly(final AtomicLong target, final long value); static String localhostName(); static String humanReadableByteCount(long bytes, boolean si); Set<String> list2Set(List<String> values); List<String> set2List(Set<String> values); static final String ROCKETMQ_HOME_ENV; static final String ROCKETMQ_HOME_PROPERTY; static final String NAMESRV_ADDR_ENV; static final String NAMESRV_ADDR_PROPERTY; static final String MESSAGE_COMPRESS_LEVEL; static final String DEFAULT_NAMESRV_ADDR_LOOKUP; static final String WS_DOMAIN_NAME; static final String WS_DOMAIN_SUBGROUP; static final String WS_ADDR; static final String DEFAULT_TOPIC; static final String BENCHMARK_TOPIC; static final String DEFAULT_PRODUCER_GROUP; static final String DEFAULT_CONSUMER_GROUP; static final String TOOLS_CONSUMER_GROUP; static final String FILTERSRV_CONSUMER_GROUP; static final String MONITOR_CONSUMER_GROUP; static final String CLIENT_INNER_PRODUCER_GROUP; static final String SELF_TEST_PRODUCER_GROUP; static final String SELF_TEST_CONSUMER_GROUP; static final String SELF_TEST_TOPIC; static final String OFFSET_MOVED_EVENT; static final String ONS_HTTP_PROXY_GROUP; static final String CID_ONSAPI_PERMISSION_GROUP; static final String CID_ONSAPI_OWNER_GROUP; static final String CID_ONSAPI_PULL_GROUP; static final String CID_RMQ_SYS_PREFIX; static final List<String> LOCAL_INET_ADDRESS; static final String LOCALHOST; static final String DEFAULT_CHARSET; static final long MASTER_ID; static final long CURRENT_JVM_PID; static final String RETRY_GROUP_TOPIC_PREFIX; static final String DLQ_GROUP_TOPIC_PREFIX; static final String SYSTEM_TOPIC_PREFIX; static final String UNIQUE_MSG_QUERY_FLAG; static final String DEFAULT_TRACE_REGION_ID; static final String CONSUME_CONTEXT_TYPE; }### Answer:
@Test public void testCompareAndIncreaseOnly() { AtomicLong target = new AtomicLong(5); assertThat(MixAll.compareAndIncreaseOnly(target, 6)).isTrue(); assertThat(target.get()).isEqualTo(6); assertThat(MixAll.compareAndIncreaseOnly(target, 4)).isFalse(); assertThat(target.get()).isEqualTo(6); }
|
### Question:
MixAll { public static String file2String(final String fileName) { File file = new File(fileName); return file2String(file); } static String getRetryTopic(final String consumerGroup); static boolean isSysConsumerGroup(final String consumerGroup); static boolean isSystemTopic(final String topic); static String getDLQTopic(final String consumerGroup); static String brokerVIPChannel(final boolean isChange, final String brokerAddr); static long getPID(); static long createBrokerId(final String ip, final int port); static void string2File(final String str, final String fileName); static void string2FileNotSafe(final String str, final String fileName); static String file2String(final String fileName); static String file2String(final File file); static String file2String(final URL url); static String findClassPath(Class<?> c); static void printObjectProperties(final Logger log, final Object object); static void printObjectProperties(final Logger log, final Object object, final boolean onlyImportantField); static String properties2String(final Properties properties); static Properties string2Properties(final String str); static Properties object2Properties(final Object object); static void properties2Object(final Properties p, final Object object); static boolean isPropertiesEqual(final Properties p1, final Properties p2); static List<String> getLocalInetAddress(); static boolean isLocalAddr(String address); static boolean compareAndIncreaseOnly(final AtomicLong target, final long value); static String localhostName(); static String humanReadableByteCount(long bytes, boolean si); Set<String> list2Set(List<String> values); List<String> set2List(Set<String> values); static final String ROCKETMQ_HOME_ENV; static final String ROCKETMQ_HOME_PROPERTY; static final String NAMESRV_ADDR_ENV; static final String NAMESRV_ADDR_PROPERTY; static final String MESSAGE_COMPRESS_LEVEL; static final String DEFAULT_NAMESRV_ADDR_LOOKUP; static final String WS_DOMAIN_NAME; static final String WS_DOMAIN_SUBGROUP; static final String WS_ADDR; static final String DEFAULT_TOPIC; static final String BENCHMARK_TOPIC; static final String DEFAULT_PRODUCER_GROUP; static final String DEFAULT_CONSUMER_GROUP; static final String TOOLS_CONSUMER_GROUP; static final String FILTERSRV_CONSUMER_GROUP; static final String MONITOR_CONSUMER_GROUP; static final String CLIENT_INNER_PRODUCER_GROUP; static final String SELF_TEST_PRODUCER_GROUP; static final String SELF_TEST_CONSUMER_GROUP; static final String SELF_TEST_TOPIC; static final String OFFSET_MOVED_EVENT; static final String ONS_HTTP_PROXY_GROUP; static final String CID_ONSAPI_PERMISSION_GROUP; static final String CID_ONSAPI_OWNER_GROUP; static final String CID_ONSAPI_PULL_GROUP; static final String CID_RMQ_SYS_PREFIX; static final List<String> LOCAL_INET_ADDRESS; static final String LOCALHOST; static final String DEFAULT_CHARSET; static final long MASTER_ID; static final long CURRENT_JVM_PID; static final String RETRY_GROUP_TOPIC_PREFIX; static final String DLQ_GROUP_TOPIC_PREFIX; static final String SYSTEM_TOPIC_PREFIX; static final String UNIQUE_MSG_QUERY_FLAG; static final String DEFAULT_TRACE_REGION_ID; static final String CONSUME_CONTEXT_TYPE; }### Answer:
@Test public void testFile2String() throws IOException { String fileName = System.getProperty("java.io.tmpdir") + File.separator + "MixAllTest" + System.currentTimeMillis(); File file = new File(fileName); if (file.exists()) { file.delete(); } file.createNewFile(); try (PrintWriter out = new PrintWriter(fileName)) { out.write("TestForMixAll"); } String string = MixAll.file2String(fileName); assertThat(string).isEqualTo("TestForMixAll"); file.delete(); }
|
### Question:
MixAll { public static void string2File(final String str, final String fileName) throws IOException { String tmpFile = fileName + ".tmp"; string2FileNotSafe(str, tmpFile); String bakFile = fileName + ".bak"; String prevContent = file2String(fileName); if (prevContent != null) { string2FileNotSafe(prevContent, bakFile); } File file = new File(fileName); file.delete(); file = new File(tmpFile); file.renameTo(new File(fileName)); } static String getRetryTopic(final String consumerGroup); static boolean isSysConsumerGroup(final String consumerGroup); static boolean isSystemTopic(final String topic); static String getDLQTopic(final String consumerGroup); static String brokerVIPChannel(final boolean isChange, final String brokerAddr); static long getPID(); static long createBrokerId(final String ip, final int port); static void string2File(final String str, final String fileName); static void string2FileNotSafe(final String str, final String fileName); static String file2String(final String fileName); static String file2String(final File file); static String file2String(final URL url); static String findClassPath(Class<?> c); static void printObjectProperties(final Logger log, final Object object); static void printObjectProperties(final Logger log, final Object object, final boolean onlyImportantField); static String properties2String(final Properties properties); static Properties string2Properties(final String str); static Properties object2Properties(final Object object); static void properties2Object(final Properties p, final Object object); static boolean isPropertiesEqual(final Properties p1, final Properties p2); static List<String> getLocalInetAddress(); static boolean isLocalAddr(String address); static boolean compareAndIncreaseOnly(final AtomicLong target, final long value); static String localhostName(); static String humanReadableByteCount(long bytes, boolean si); Set<String> list2Set(List<String> values); List<String> set2List(Set<String> values); static final String ROCKETMQ_HOME_ENV; static final String ROCKETMQ_HOME_PROPERTY; static final String NAMESRV_ADDR_ENV; static final String NAMESRV_ADDR_PROPERTY; static final String MESSAGE_COMPRESS_LEVEL; static final String DEFAULT_NAMESRV_ADDR_LOOKUP; static final String WS_DOMAIN_NAME; static final String WS_DOMAIN_SUBGROUP; static final String WS_ADDR; static final String DEFAULT_TOPIC; static final String BENCHMARK_TOPIC; static final String DEFAULT_PRODUCER_GROUP; static final String DEFAULT_CONSUMER_GROUP; static final String TOOLS_CONSUMER_GROUP; static final String FILTERSRV_CONSUMER_GROUP; static final String MONITOR_CONSUMER_GROUP; static final String CLIENT_INNER_PRODUCER_GROUP; static final String SELF_TEST_PRODUCER_GROUP; static final String SELF_TEST_CONSUMER_GROUP; static final String SELF_TEST_TOPIC; static final String OFFSET_MOVED_EVENT; static final String ONS_HTTP_PROXY_GROUP; static final String CID_ONSAPI_PERMISSION_GROUP; static final String CID_ONSAPI_OWNER_GROUP; static final String CID_ONSAPI_PULL_GROUP; static final String CID_RMQ_SYS_PREFIX; static final List<String> LOCAL_INET_ADDRESS; static final String LOCALHOST; static final String DEFAULT_CHARSET; static final long MASTER_ID; static final long CURRENT_JVM_PID; static final String RETRY_GROUP_TOPIC_PREFIX; static final String DLQ_GROUP_TOPIC_PREFIX; static final String SYSTEM_TOPIC_PREFIX; static final String UNIQUE_MSG_QUERY_FLAG; static final String DEFAULT_TRACE_REGION_ID; static final String CONSUME_CONTEXT_TYPE; }### Answer:
@Test public void testString2File() throws IOException { String fileName = System.getProperty("java.io.tmpdir") + File.separator + "MixAllTest" + System.currentTimeMillis(); MixAll.string2File("MixAll_testString2File", fileName); assertThat(MixAll.file2String(fileName)).isEqualTo("MixAll_testString2File"); }
|
### Question:
ProducerConnectionSubCommand implements SubCommand { @Override public void execute(CommandLine commandLine, Options options, RPCHook rpcHook) { DefaultMQAdminExt defaultMQAdminExt = new DefaultMQAdminExt(rpcHook); defaultMQAdminExt.setInstanceName(Long.toString(System.currentTimeMillis())); try { defaultMQAdminExt.start(); String group = commandLine.getOptionValue('g').trim(); String topic = commandLine.getOptionValue('t').trim(); ProducerConnection pc = defaultMQAdminExt.examineProducerConnectionInfo(group, topic); int i = 1; for (Connection conn : pc.getConnectionSet()) { System.out.printf("%04d %-32s %-22s %-8s %s%n", i++, conn.getClientId(), conn.getClientAddr(), conn.getLanguage(), MQVersion.getVersionDesc(conn.getVersion()) ); } } catch (Exception e) { e.printStackTrace(); } finally { defaultMQAdminExt.shutdown(); } } @Override String commandName(); @Override String commandDesc(); @Override Options buildCommandlineOptions(Options options); @Override void execute(CommandLine commandLine, Options options, RPCHook rpcHook); }### Answer:
@Test public void testExecute() { ProducerConnectionSubCommand cmd = new ProducerConnectionSubCommand(); Options options = ServerUtil.buildCommandlineOptions(new Options()); String[] subargs = new String[] {"-g default-producer-group", "-t unit-test"}; final CommandLine commandLine = ServerUtil.parseCmdLine("mqadmin " + cmd.commandName(), subargs, cmd.buildCommandlineOptions(options), new PosixParser()); cmd.execute(commandLine, options, null); }
|
### Question:
SelectMessageQueueByHash implements MessageQueueSelector { @Override public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) { int value = arg.hashCode(); if (value < 0) { value = Math.abs(value); } value = value % mqs.size(); return mqs.get(value); } @Override MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg); }### Answer:
@Test public void testSelect() throws Exception { SelectMessageQueueByHash selector = new SelectMessageQueueByHash(); Message message = new Message(topic, new byte[] {}); List<MessageQueue> messageQueues = new ArrayList<>(); for (int i = 0; i < 10; i++) { MessageQueue messageQueue = new MessageQueue(topic, "DefaultBroker", i); messageQueues.add(messageQueue); } String orderId = "123"; String anotherOrderId = "234"; MessageQueue selected = selector.select(messageQueues, message, orderId); assertThat(selector.select(messageQueues, message, anotherOrderId)).isNotEqualTo(selected); }
@Test public void testSelect() throws Exception { SelectMessageQueueByHash selector = new SelectMessageQueueByHash(); Message message = new Message(topic, new byte[] {}); List<MessageQueue> messageQueues = new ArrayList<MessageQueue>(); for (int i = 0; i < 10; i++) { MessageQueue messageQueue = new MessageQueue(topic, "DefaultBroker", i); messageQueues.add(messageQueue); } String orderId = "123"; String anotherOrderId = "234"; MessageQueue selected = selector.select(messageQueues, message, orderId); assertThat(selector.select(messageQueues, message, anotherOrderId)).isNotEqualTo(selected); }
|
### Question:
ChecksumHelper { protected byte[] addChecksum(byte[] source) { CRC32 crc32 = new CRC32(); crc32.update(source); long checkSum = crc32.getValue(); byte[] checkSumBytes = String.valueOf(checkSum).getBytes(); byte[] concat = Bytes.concat(source, (SEPARATOR+"").getBytes(), checkSumBytes); return concat; } }### Answer:
@Test public void testAddChecksum() { ChecksumHelper checksumHelper = new ChecksumHelper(); byte[] source = "foobarbaz".getBytes(); log.debug("source : " + new String(source)); byte[] withChecksum = checksumHelper.addChecksum(source); log.debug("withChecksum: " + new String(withChecksum)); assertEquals("foobarbaz#444082090", new String(withChecksum)); }
|
### Question:
ChecksumHelper { protected byte[] validateAndStripChecksum(byte[] source) { int lastIndexOf = Bytes.lastIndexOf(source, (byte) SEPARATOR); if (lastIndexOf < 0) { throw new RuntimeException("no checksum was found on source: " + new String(source)); } long checkSum = Long.parseLong(new String(Arrays.copyOfRange(source, lastIndexOf + 1, source.length))); byte[] data = Arrays.copyOfRange(source, 0, lastIndexOf); CRC32 crc32 = new CRC32(); crc32.update(data); long calculatedCheckSum = crc32.getValue(); if (Long.compare(checkSum, calculatedCheckSum) != 0) { throw new RuntimeException("checksums do not match! calculated: " + calculatedCheckSum + ", provided: " + checkSum); } return data; } }### Answer:
@Test public void testValidateChecksum() { ChecksumHelper checksumHelper = new ChecksumHelper(); byte[] withChecksum = "foobarbaz#444082090".getBytes(); log.debug("withChecksum: " + new String(withChecksum)); assertNotNull(withChecksum); byte[] stripped = checksumHelper.validateAndStripChecksum(withChecksum); log.debug("stripped : " + new String(stripped)); assertEquals("foobarbaz", new String(stripped)); }
@Test(expected = RuntimeException.class) public void testValidateChecksumFailsOnMissingChecksum() { ChecksumHelper checksumHelper = new ChecksumHelper(); byte[] withChecksum = "foobarbaz".getBytes(); log.debug("withChecksum: " + new String(withChecksum)); assertNotNull(withChecksum); checksumHelper.validateAndStripChecksum(withChecksum); fail("should have thrown an exception by now"); }
@Test(expected = RuntimeException.class) public void testValidateChecksumFailsOnFalseChecksum() { ChecksumHelper checksumHelper = new ChecksumHelper(); byte[] withChecksum = "foobarbaz#444082092".getBytes(); log.debug("withChecksum: " + new String(withChecksum)); assertNotNull(withChecksum); checksumHelper.validateAndStripChecksum(withChecksum); fail("should have thrown an exception by now"); }
@Test(expected = RuntimeException.class) public void testValidateChecksumFailsOnFalseChecksum2() { ChecksumHelper checksumHelper = new ChecksumHelper(); byte[] withChecksum = "foobarbal#444082090".getBytes(); log.debug("withChecksum: " + new String(withChecksum)); assertNotNull(withChecksum); checksumHelper.validateAndStripChecksum(withChecksum); fail("should have thrown an exception by now"); }
|
### Question:
Compressor { public byte[] compress(byte[] source) throws IOException { return compress(DEFAULTCOMPRESSIONTYPE, source); } byte[] compress(byte[] source); byte[] compress(CompressionType type, byte[] source); byte[] decompress(byte[] source); byte[] decompress(CompressionType type, byte[] source); }### Answer:
@Test public void testCompressionDoesCompress() throws IOException { Compressor compressor = new Compressor(); String uncompressed = "foobarbazamassivelylongstringofsomethingthatshouldcompressprettyfineeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; log.info("uncompressed: " + uncompressed); byte[] compressed = compressor.compress(uncompressed.getBytes()); log.info("compressed: " + new String(compressed)); assertTrue(compressed.length <= uncompressed.length()); }
|
### Question:
ExtrasHandler { void addToExtras(List<Person> persons) { persons.forEach(p -> { p.setRelationshipStatus(null); p.clearFamilyID(); }); this.extras.addAll(persons); persons.clear(); } ExtrasHandler(List<IndRecord> indRecords, Random random); }### Answer:
@Test public void testAddToExtras() throws NoSuchFieldException, IllegalAccessException { int startingSize = extrasHandler.remainingExtras(); Person p = new Person(); p.setRelationshipStatus(RelationshipStatus.RELATIVE); p.setAgeRange(AgeRange.A25_39); p.setSex(Sex.Male); extrasHandler.addToExtras(new ArrayList<>(Collections.singleton(p))); Assert.assertTrue("New person added to extras - extras increments by one", startingSize + 1 == extrasHandler.remainingExtras()); Field field = ExtrasHandler.class.getDeclaredField("extras"); field.setAccessible(true); List<Person> extras = (List<Person>) field.get(extrasHandler); Person lastAddedToExtras = extras.get(extras.size() - 1); Assert.assertEquals("New person added to extra - age", lastAddedToExtras.getAgeRange(), AgeRange.A25_39); Assert.assertEquals("New person added to extra - sex", lastAddedToExtras.getSex(), Sex.Male); Assert.assertEquals("New person added to extra - relationship status", lastAddedToExtras.getRelationshipStatus(), null); }
|
### Question:
ExtrasHandler { List<Person> getPersonsFromExtras(RelationshipStatus relStatus, Sex sex, AgeRange ageRange, int count) { return getPersonsFromExtras(relStatus == null ? null : Collections.singletonList(relStatus), sex == null ? null : Collections.singletonList(sex), ageRange == null ? null : Collections.singletonList(ageRange), count); } ExtrasHandler(List<IndRecord> indRecords, Random random); }### Answer:
@Test public void testGetPersonsFromExtras() throws NoSuchFieldException, IllegalAccessException { int startExtrasCount = extrasHandler.remainingExtras(); List<Person> pl = extrasHandler.getPersonsFromExtras(RelationshipStatus.LONE_PARENT, Sex.Female, AgeRange.A40_54, 1); Assert.assertTrue("Person taken from extras - count", startExtrasCount - 1 == extrasHandler.remainingExtras()); Assert.assertEquals("Person taken from extras - age", pl.get(0).getAgeRange(), AgeRange.A40_54); Assert.assertEquals("Person taken from extras - sex", pl.get(0).getSex(), Sex.Female); Assert.assertEquals("Person taken from extras - relationship status", pl.get(0).getRelationshipStatus(), RelationshipStatus.LONE_PARENT); Person p = new Person(); p.setRelationshipStatus(RelationshipStatus.RELATIVE); p.setAgeRange(AgeRange.A25_39); p.setSex(Sex.Male); extrasHandler.addToExtras(new ArrayList<>(Collections.singleton(p))); pl = extrasHandler.getPersonsFromExtras(RelationshipStatus.RELATIVE, Sex.Male, AgeRange.A25_39, 1); Field field = ExtrasHandler.class.getDeclaredField("extras"); field.setAccessible(true); List<Person> extras = (List<Person>) field.get(extrasHandler); Assert.assertTrue("All persons in extras have no sex", extras.stream().filter(e -> e.getSex() == null).count() == extrasHandler.remainingExtras()); Assert.assertTrue("All persons in extras have no age range", extras.stream().filter(e -> e.getAgeRange() == null).count() == extrasHandler.remainingExtras()); Assert.assertTrue("All persons in extras have no relationship status", extras.stream().filter(e -> e.getRelationshipStatus() == null).count() == extrasHandler.remainingExtras()); }
|
### Question:
HouseholdFactory { private void assignOneParentUnitsAsNonPrimaryFamilies(List<Household> households, List<Family> basicUnits) { Log.info("Adding " + FamilyType.ONE_PARENT + " as non primary"); Log.debug(FamilyType.ONE_PARENT + ": available family units: " + basicUnits.size()); List<Household> eligibleHhs = households.stream() .filter(h -> (FamilyType.ONE_PARENT == h.getPrimaryFamilyType() || FamilyType.COUPLE_WITH_CHILDREN == h.getPrimaryFamilyType()) && (h.getExpectedFamilyCount() > h.getCurrentFamilyCount()) && (h.getExpectedSize() - h.getCurrentSize() >= FamilyType.ONE_PARENT.basicSize())) .collect(Collectors.toList()); Log.debug(FamilyType.ONE_PARENT + ": total eligible households: " + eligibleHhs.size()); int added = 0, completed = 0; while (!basicUnits.isEmpty() && !eligibleHhs.isEmpty()) { int randIndex = random.nextInt(eligibleHhs.size()); Family f = basicUnits.remove(0); f.setType(FamilyType.ONE_PARENT); eligibleHhs.get(randIndex).addFamily(f); if (eligibleHhs.get(randIndex).getExpectedFamilyCount() == eligibleHhs.get(randIndex) .getCurrentFamilyCount()) { eligibleHhs.remove(randIndex); completed++; } added++; } Log.debug(FamilyType.ONE_PARENT + ": updated households: " + added); Log.debug(FamilyType.ONE_PARENT + ": family count completed households: " + completed); Log.debug(FamilyType.ONE_PARENT + ": remaining eligible households: " + eligibleHhs.stream() .filter(h -> h.getExpectedFamilyCount() > h .getCurrentFamilyCount()) .count()); } HouseholdFactory(List<HhRecord> hhRecords, Random random, ExtrasHandler extrasHandler); }### Answer:
@Test public void testAssignOneParentUnitsAsNonPrimaryFamilies() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { setup(); Assert.assertTrue("One parent families are not empty", !oneParentFamilies.isEmpty()); int startOneParentFamiliesCount = oneParentFamilies.size(); int startNonPrimarySlots = households.parallelStream().mapToInt(h -> h.getExpectedFamilyCount() - h.getCurrentFamilyCount()).sum(); Method method = HouseholdFactory.class.getDeclaredMethod("assignOneParentUnitsAsNonPrimaryFamilies", List.class, List.class); method.setAccessible(true); method.invoke(hf, households, oneParentFamilies); Assert.assertTrue("One parent families were assigned as non-primary families", startOneParentFamiliesCount > oneParentFamilies.size()); int usedOneParentFamilies = startOneParentFamiliesCount - oneParentFamilies.size(); int endNonPrimarySlots = households.parallelStream().mapToInt(h -> h.getExpectedFamilyCount() - h.getCurrentFamilyCount()).sum(); Assert.assertEquals("Only One Parent families are used as non-primary families", (startNonPrimarySlots - endNonPrimarySlots), usedOneParentFamilies); }
|
### Question:
HouseholdFactory { void completeHouseholdsWithChildren(List<Household> households, List<Person> knownChildren) { Log.info("Adding all known children to households"); Log.debug("Total known Children from data: " + knownChildren.size()); knownChildren.sort(new AgeRange.AgeComparator().reversed()); List<Household> parentHhs = households.stream() .filter(h -> h.getPrimaryFamilyType() == FamilyType.ONE_PARENT || h.getPrimaryFamilyType() == FamilyType.COUPLE_WITH_CHILDREN) .sorted(Comparator.comparing(Household::getPrimaryFamily, new AgeRange.YoungestParentAgeComparator().reversed())) .collect(Collectors.toList()); Log.debug("All: Eligible households: " + parentHhs.size()); Log.debug("All: Slots to fill: " + parentHhs.stream().mapToInt(h -> h.getExpectedSize() - h.getCurrentSize()).sum()); Iterator<Person> childItr = knownChildren.iterator(); int updated = 0, completed = 0; while (childItr.hasNext()) { Person child = childItr.next(); int hhIndex = selectHouseholdWithSuitablePrimaryFamilyForChild(child, parentHhs); if (hhIndex >= 0) { Family pf = parentHhs.get(hhIndex).getPrimaryFamily(); try { pf.addMember(child); } catch (Error er) { er.printStackTrace(); Family current = parentHhs.stream() .map(Household::getFamilies) .flatMap(List::stream) .filter(f -> f.getID().equals(child.getFamilyID())) .collect(Collectors.toList()) .get(0); Log.error("Problematic family: " + current.toString()); } childItr.remove(); updated++; if (parentHhs.get(hhIndex).getExpectedSize() == parentHhs.get(hhIndex).getCurrentSize()) { completed++; parentHhs.remove(hhIndex); } } } Log.debug("Children with no suitable primary family in any eligible household: " + knownChildren.size()); childItr = knownChildren.iterator(); while (childItr.hasNext()) { Person child = childItr.next(); for (Household h : parentHhs) { Family suitableFamily = selectSuitableNonPrimaryFamilyForChild(child, h); if (suitableFamily != null) { suitableFamily.addMember(child); childItr.remove(); updated++; if (h.getExpectedSize() == h.getCurrentSize()) { completed++; } } } } Log.debug("Children with no suitable non-primary families in any eligible household: " + knownChildren.size()); Log.debug("Updated households: " + updated); Log.debug("Completed households: " + completed); } HouseholdFactory(List<HhRecord> hhRecords, Random random, ExtrasHandler extrasHandler); }### Answer:
@Test public void testCompleteHouseholdsWithChildren() { setup(); hf.addNonPrimaryFamiliesToHouseholds(households, couples, oneParentFamilies, children, relatives, marriedMales, marriedFemales, loneParents, 0.2, null, ff); int startingChildCount = children.size(); int startingLoneParents = loneParents.size(); hf.completeHouseholdsWithChildren(households, children); Assert.assertEquals("One children from children list was assigned to One Parent primary family household", startingChildCount - 1, children.size()); Assert.assertEquals("Lone parents should not be assigned to families", startingLoneParents, loneParents.size()); }
|
### Question:
HouseholdFactory { void completeHouseholdsWithRelatives(List<Household> households, List<Person> relatives, FamilyHouseholdType familyHouseholdType) { Log.info("Fill " + ((familyHouseholdType == null) ? "All" : familyHouseholdType) + " households with relatives"); Log.debug("Start remaining relatives: " + relatives.size()); Log.debug("Start remaining extras: " + extrasHandler.remainingExtras()); Collections.shuffle(relatives, random); List<Household> availableHhs = households.stream() .filter(hh -> (hh.getFamilyHouseholdType() == familyHouseholdType || familyHouseholdType == null) && (hh.getExpectedSize() > hh.getCurrentSize())) .collect(Collectors.toList()); Log.debug((familyHouseholdType != null ? familyHouseholdType.name() : "All") + ": Eligible households: " + availableHhs.size()); Log.debug((familyHouseholdType != null ? familyHouseholdType.name() : "All") + ": Slots to fill: " + availableHhs.stream() .mapToInt(h -> h .getExpectedSize() - h .getCurrentSize()) .sum()); int formed = 0; for (Household h : availableHhs) { int diff = h.getExpectedSize() - h.getCurrentSize(); if (diff > 0) { Family f = h.getPrimaryFamily(); if (relatives.size() >= diff) { f.addMembers(relatives.subList(0, diff)); relatives.subList(0, diff).clear(); } else { int rels = relatives.size(); f.addMembers(relatives); relatives.clear(); f.addMembers(extrasHandler.getPersonsFromExtras(RelationshipStatus.RELATIVE, null, null, diff - rels)); } formed++; } } Log.info((familyHouseholdType != null ? familyHouseholdType.name() : "All") + ": updated households: " + formed); Log.debug("End remaining relatives: " + relatives.size()); Log.debug("End remaining extras: " + extrasHandler.remainingExtras()); } HouseholdFactory(List<HhRecord> hhRecords, Random random, ExtrasHandler extrasHandler); }### Answer:
@Test public void testcompleteHouseholdsWithRelatives(){ setup(); hf.addNonPrimaryFamiliesToHouseholds(households, couples, oneParentFamilies, children, relatives, marriedMales, marriedFemales, loneParents, 0.2, null, ff); hf.completeHouseholdsWithChildren(households, children); hf.addExtrasAsChildrenAndRelatives(households, indRecords, marriedMales, marriedFemales, loneParents, children); Assert.assertTrue("There are relatives remaining", !relatives.isEmpty()); hf.completeHouseholdsWithRelatives(households, relatives, null); Assert.assertTrue("All households are complete", households.parallelStream().allMatch(h -> h.validate())); Assert.assertTrue("All Relatives were used", relatives.isEmpty()); }
|
### Question:
ExtrasHandler { int remainingExtras() { return extras.size(); } ExtrasHandler(List<IndRecord> indRecords, Random random); }### Answer:
@Test public void testFormingExtras() { Assert.assertNotNull(extrasHandler); Assert.assertEquals("Number of extras", extrasHandler.remainingExtras(), 145); }
|
### Question:
EasyPermissions { public static boolean hasPermissions(@NonNull Context context, @Size(min = 1) @NonNull String... perms) { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) { Log.w(TAG, "hasPermissions: API version < M, returning true by default"); return true; } if (context == null) { throw new IllegalArgumentException("Can't check permissions for null context"); } for (String perm : perms) { if (ContextCompat.checkSelfPermission(context, perm) != PackageManager.PERMISSION_GRANTED) { return false; } } return true; } static boolean hasPermissions(@NonNull Context context,
@Size(min = 1) @NonNull String... perms); static void requestPermissions(
@NonNull Activity host, @NonNull String rationale,
int requestCode, @Size(min = 1) @NonNull String... perms); static void requestPermissions(
@NonNull Fragment host, @NonNull String rationale,
int requestCode, @Size(min = 1) @NonNull String... perms); static void requestPermissions(
@NonNull android.app.Fragment host, @NonNull String rationale,
int requestCode, @Size(min = 1) @NonNull String... perms); static void requestPermissions(
@NonNull Activity host, @NonNull String rationale,
@StringRes int positiveButton, @StringRes int negativeButton,
int requestCode, @Size(min = 1) @NonNull String... perms); static void requestPermissions(
@NonNull Fragment host, @NonNull String rationale,
@StringRes int positiveButton, @StringRes int negativeButton,
int requestCode, @Size(min = 1) @NonNull String... perms); static void requestPermissions(
@NonNull android.app.Fragment host, @NonNull String rationale,
@StringRes int positiveButton, @StringRes int negativeButton,
int requestCode, @Size(min = 1) @NonNull String... perms); static void onRequestPermissionsResult(int requestCode,
@NonNull String[] permissions,
@NonNull int[] grantResults,
@NonNull Object... receivers); static boolean somePermissionPermanentlyDenied(@NonNull Activity host,
@NonNull List<String> deniedPermissions); static boolean somePermissionPermanentlyDenied(@NonNull Fragment host,
@NonNull List<String> deniedPermissions); static boolean somePermissionPermanentlyDenied(@NonNull android.app.Fragment host,
@NonNull List<String> deniedPermissions); static boolean permissionPermanentlyDenied(@NonNull Activity host,
@NonNull String deniedPermission); static boolean permissionPermanentlyDenied(@NonNull Fragment host,
@NonNull String deniedPermission); static boolean permissionPermanentlyDenied(@NonNull android.app.Fragment host,
@NonNull String deniedPermission); static boolean somePermissionDenied(@NonNull Activity host,
@NonNull String... perms); static boolean somePermissionDenied(@NonNull Fragment host,
@NonNull String... perms); static boolean somePermissionDenied(@NonNull android.app.Fragment host,
@NonNull String... perms); }### Answer:
@Test public void testHasPermissions() { Application app = RuntimeEnvironment.application; String[] perms = new String[]{ Manifest.permission.READ_SMS, Manifest.permission.ACCESS_FINE_LOCATION }; assertFalse(EasyPermissions.hasPermissions(app, perms)); ShadowApplication.getInstance().grantPermissions(perms[0]); assertFalse(EasyPermissions.hasPermissions(app, perms)); ShadowApplication.getInstance().grantPermissions(perms); assertTrue(EasyPermissions.hasPermissions(app, perms)); }
|
### Question:
CacheLoaderAdapter implements CacheLoader<K, V>, Factory<CacheLoader<K, V>> { @Override public Map<K, V> loadAll(final Iterable<? extends K> keys) throws CacheLoaderException { final Map<K, V> result = new HashMap<K, V>(); for (final K k : keys) { final V v = load(k); if (v != null) { result.put(k, v); } } return result; } @Override Map<K, V> loadAll(final Iterable<? extends K> keys); @Override CacheLoader<K, V> create(); }### Answer:
@Test public void checkLoadAll() { assertFalse(cache.iterator().hasNext()); assertEquals("foo", cache.get("foo")); count.decrementAndGet(); cache.loadAll(new HashSet<String>(asList("a", "b")), true, null); int retries = 100; while (retries-- > 0 && count.get() != 2) { try { Thread.sleep(20); } catch (final InterruptedException e) { Thread.interrupted(); } } assertEquals(2, count.get()); assertEquals("a", cache.get("a")); assertEquals("b", cache.get("b")); assertEquals(2, count.get()); }
|
### Question:
CDIJCacheHelper { public MethodMeta findMeta(final InvocationContext ic) { final Method mtd = ic.getMethod(); final Class<?> refType = findKeyType(ic.getTarget()); final MethodKey key = new MethodKey(refType, mtd); MethodMeta methodMeta = methods.get(key); if (methodMeta == null) { synchronized (this) { methodMeta = methods.get(key); if (methodMeta == null) { methodMeta = createMeta(ic); methods.put(key, methodMeta); } } } return methodMeta; } MethodMeta findMeta(final InvocationContext ic); boolean isIncluded(final Class<?> aClass, final Class<?>[] in, final Class<?>[] out); }### Answer:
@Test public void proxyCacheDefaults() { final CDIJCacheHelper helper = new CDIJCacheHelper(); final MyParent child1 = MyParent.class.cast(Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[]{MyChild1.class}, (proxy, method, args) -> null)); final CDIJCacheHelper.MethodMeta meta1 = helper.findMeta(newContext(child1)); assertEquals("child", meta1.getCacheResultCacheName()); final MyParent child2 = MyParent.class.cast(Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[]{MyChild2.class}, (proxy, method, args) -> null)); final CDIJCacheHelper.MethodMeta meta2 = helper.findMeta(newContext(child2)); assertEquals("child2", meta2.getCacheResultCacheName()); }
|
### Question:
DelegatingInvoker implements Invoker { @Override public Object invoke(Object proxy, Method method, Object[] arguments) throws Throwable { try { return method.invoke(delegateProvider.getObject(), arguments); } catch (InvocationTargetException e) { throw e.getTargetException(); } } DelegatingInvoker(ObjectProvider<? extends T> delegateProvider); @Override Object invoke(Object proxy, Method method, Object[] arguments); }### Answer:
@Test public void test() throws Throwable { final Invoker invoker = new DelegatingInvoker<Echo>(ObjectProviderUtils.constant(new EchoImpl())); assertEquals("foo", invoker.invoke(null, Echo.class.getDeclaredMethod("echoBack", String.class), new Object[] { "foo" })); }
|
### Question:
CloningProvider implements ObjectProvider<T>, Serializable { @Override public T getObject() { try { return ObjectUtils.clone(cloneable); } catch (CloneFailedException e) { throw new ObjectProviderException(e.getMessage(), e.getCause()); } } CloningProvider(T cloneable); @Override T getObject(); }### Answer:
@Test public void testValidCloneable() { final Date now = new Date(); final CloningProvider<Date> provider = new CloningProvider<Date>(now); final Date clone1 = provider.getObject(); assertEquals(now, clone1); assertNotSame(now, clone1); final Date clone2 = provider.getObject(); assertEquals(now, clone2); assertNotSame(now, clone2); assertNotSame(clone2, clone1); }
@Test public void testWithExceptionThrown() { final CloningProvider<ExceptionCloneable> provider = new CloningProvider<ExceptionCloneable>( new ExceptionCloneable()); try { provider.getObject(); fail(); } catch (ObjectProviderException e) { } }
@Test(expected = IllegalArgumentException.class) public void testWithProtectedCloneMethod() { final CloningProvider<ProtectedCloneable> provider = new CloningProvider<ProtectedCloneable>( new ProtectedCloneable()); provider.getObject(); }
|
### Question:
InterceptorUtils { public static Interceptor constant(Object value) { return new ObjectProviderInterceptor(ObjectProviderUtils.constant(value)); } private InterceptorUtils(); static Interceptor constant(Object value); static Interceptor provider(ObjectProvider<?> provider); static Interceptor throwing(Exception e); static Interceptor throwing(ObjectProvider<? extends Exception> provider); static Interceptor invoking(Invoker invoker); }### Answer:
@Test public void testConstant() throws Throwable { Interceptor interceptor = InterceptorUtils.constant("Hello!"); Invocation invocation = mockInvocation(Echo.class, "echoBack", String.class).withArguments("World!").build(); assertEquals("Hello!", interceptor.intercept(invocation)); }
|
### Question:
InterceptorUtils { public static Interceptor provider(ObjectProvider<?> provider) { return new ObjectProviderInterceptor(provider); } private InterceptorUtils(); static Interceptor constant(Object value); static Interceptor provider(ObjectProvider<?> provider); static Interceptor throwing(Exception e); static Interceptor throwing(ObjectProvider<? extends Exception> provider); static Interceptor invoking(Invoker invoker); }### Answer:
@Test public void testProvider() throws Throwable { Interceptor interceptor = InterceptorUtils.provider(ObjectProviderUtils.constant("Foo!")); Invocation invocation = mockInvocation(Echo.class, "echoBack", String.class).withArguments("World!").build(); assertEquals("Foo!", interceptor.intercept(invocation)); }
|
### Question:
InterceptorUtils { public static Interceptor throwing(Exception e) { return new ThrowingInterceptor(ObjectProviderUtils.constant(e)); } private InterceptorUtils(); static Interceptor constant(Object value); static Interceptor provider(ObjectProvider<?> provider); static Interceptor throwing(Exception e); static Interceptor throwing(ObjectProvider<? extends Exception> provider); static Interceptor invoking(Invoker invoker); }### Answer:
@Test(expected = RuntimeException.class) public void testThrowingExceptionObject() throws Throwable { Interceptor interceptor = InterceptorUtils.throwing(new RuntimeException("Oops!")); Invocation invocation = mockInvocation(Echo.class, "echoBack", String.class).withArguments("World!").build(); interceptor.intercept(invocation); }
|
### Question:
ObjectProviderInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { return provider.getObject(); } ObjectProviderInterceptor(ObjectProvider<?> provider); @Override Object intercept(Invocation invocation); }### Answer:
@Test public void testIntercept() throws Throwable { ObjectProviderInterceptor interceptor = new ObjectProviderInterceptor(ObjectProviderUtils.constant("Hello!")); assertEquals("Hello!", interceptor.intercept(null)); }
|
### Question:
SwitchInterceptor implements Interceptor, Serializable { @Override public Object intercept(Invocation invocation) throws Throwable { for (Pair<InvocationMatcher, Interceptor> currentCase : cases) { if (currentCase.getLeft().matches(invocation)) { return currentCase.getRight().intercept(invocation); } } return invocation.proceed(); } SwitchInterceptor(); @Override Object intercept(Invocation invocation); CaseBuilder when(InvocationMatcher matcher); }### Answer:
@Test public void testWithNoAdvice() throws Throwable { SwitchInterceptor interceptor = new SwitchInterceptor(); Method method = Echo.class.getMethod("echoBack", String.class); Invocation invocation = new MockInvocation(method, "foo", "foo"); assertEquals("foo", interceptor.intercept(invocation)); }
|
### Question:
InvokerInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { return invoker.invoke(invocation.getProxy(), invocation.getMethod(), invocation.getArguments()); } InvokerInterceptor(Invoker invoker); @Override Object intercept(Invocation invocation); }### Answer:
@Test public void testIntercept() throws Throwable { final InvokerInterceptor interceptor = new InvokerInterceptor(new Invoker() { private static final long serialVersionUID = 1L; @Override public Object invoke(Object proxy, Method method, Object[] arguments) throws Throwable { return "Hello!"; } }); final Invocation invocation = new MockInvocationBuilder(Echo.class.getDeclaredMethod("echoBack", String.class)) .withArguments("foo").build(); assertEquals("Hello!", interceptor.intercept(invocation)); }
|
### Question:
ArgumentMatcherUtils { public static <T> ArgumentMatcher<T> any() { return new AnyMatcher<T>(); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testAny() throws Exception { ArgumentMatcher<Object> matcher = ArgumentMatcherUtils.any(); assertTrue(matcher.matches(null)); assertTrue(matcher.matches("Hello!")); assertTrue(matcher.matches(12345)); }
|
### Question:
BeanProvider implements ObjectProvider<T>, Serializable { @Override public T getObject() { try { return beanClass.newInstance(); } catch (InstantiationException e) { throw new ObjectProviderException(e, "%s is not concrete.", beanClass); } catch (IllegalAccessException e) { throw new ObjectProviderException(e, "Constructor for %s is not accessible.", beanClass); } } BeanProvider(Class<? extends T> beanClass); @Override T getObject(); }### Answer:
@Test(expected = ObjectProviderException.class) public void testAbstractBeanClass() { final BeanProvider<Number> p = new BeanProvider<Number>(Number.class); p.getObject(); }
@Test(expected = ObjectProviderException.class) public void testNonAccessibleConstructor() { new BeanProvider<MyBean>(MyBean.class).getObject(); }
@Test(expected = NullPointerException.class) public void testWithNullBeanClass() { final BeanProvider<Object> p = new BeanProvider<Object>(null); p.getObject(); }
|
### Question:
ArgumentMatcherUtils { public static <T> ArgumentMatcher<T> eq(final T value) { return new EqualsMatcher<T>(value); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testEq() throws Exception { ArgumentMatcher<String> matcher = ArgumentMatcherUtils.eq("Hello"); assertTrue(matcher.matches("Hello")); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static <C extends Comparable<C>> ArgumentMatcher<C> gt(C comparable) { return new GreaterThanMatcher<C>(comparable); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testGt() throws Exception { ArgumentMatcher<Integer> matcher = ArgumentMatcherUtils.gt(5); assertTrue(matcher.matches(6)); assertFalse(matcher.matches(5)); assertFalse(matcher.matches(1)); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static <C extends Comparable<C>> ArgumentMatcher<C> gte(C comparable) { return new GreaterThanOrEqualMatcher<C>(comparable); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testGte() throws Exception { ArgumentMatcher<Integer> matcher = ArgumentMatcherUtils.gte(5); assertTrue(matcher.matches(6)); assertTrue(matcher.matches(5)); assertFalse(matcher.matches(1)); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static <T> ArgumentMatcher<T> isA(final Class<?> type) { return new InstanceOfMatcher<T>(type); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testIsA() throws Exception { ArgumentMatcher<Object> matcher = ArgumentMatcherUtils.isA(String.class); assertFalse(matcher.matches(null)); assertTrue(matcher.matches("Hello")); assertFalse(matcher.matches(123)); }
|
### Question:
ArgumentMatcherUtils { public static <T> ArgumentMatcher<T> isNull() { return new IsNullMatcher<T>(); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testIsNull() throws Exception { ArgumentMatcher<Object> matcher = ArgumentMatcherUtils.isNull(); assertTrue(matcher.matches(null)); assertFalse(matcher.matches("Hello")); assertFalse(matcher.matches(123)); }
|
### Question:
ArgumentMatcherUtils { public static <C extends Comparable<C>> ArgumentMatcher<C> lt(C comparable) { return new LessThanMatcher<C>(comparable); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testLt() throws Exception { ArgumentMatcher<Integer> matcher = ArgumentMatcherUtils.lt(5); assertTrue(matcher.matches(4)); assertFalse(matcher.matches(5)); assertFalse(matcher.matches(19)); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static <C extends Comparable<C>> ArgumentMatcher<C> lte(C comparable) { return new LessThanOrEqualMatcher<C>(comparable); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testLte() throws Exception { ArgumentMatcher<Integer> matcher = ArgumentMatcherUtils.lte(5); assertTrue(matcher.matches(4)); assertTrue(matcher.matches(5)); assertFalse(matcher.matches(19)); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static ArgumentMatcher<String> matches(String regex) { return new RegexMatcher(Validate.notNull(regex)); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testMatches() throws Exception { ArgumentMatcher<String> matcher = ArgumentMatcherUtils.matches("(abc)+"); assertTrue(matcher.matches("abc")); assertTrue(matcher.matches("abcabc")); assertFalse(matcher.matches("")); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static <T> ArgumentMatcher<T> notNull() { return new NotNullMatcher<T>(); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testNotNull() throws Exception { ArgumentMatcher<String> matcher = ArgumentMatcherUtils.notNull(); assertTrue(matcher.matches("Hello")); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static ArgumentMatcher<String> startsWith(String prefix) { return new StartsWithMatcher(Validate.notNull(prefix)); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testStartsWith() throws Exception { ArgumentMatcher<String> matcher = ArgumentMatcherUtils.startsWith("abc"); assertTrue(matcher.matches("abc")); assertTrue(matcher.matches("abcd")); assertFalse(matcher.matches("ab")); assertFalse(matcher.matches(null)); }
|
### Question:
ArgumentMatcherUtils { public static ArgumentMatcher<String> endsWith(String suffix) { return new EndsWithMatcher(Validate.notNull(suffix)); } private ArgumentMatcherUtils(); static ArgumentMatcher<T> any(); static ArgumentMatcher<String> endsWith(String suffix); static ArgumentMatcher<T> eq(final T value); static ArgumentMatcher<C> gt(C comparable); static ArgumentMatcher<C> gte(C comparable); static ArgumentMatcher<T> isA(final Class<?> type); static ArgumentMatcher<T> isNull(); static ArgumentMatcher<C> lt(C comparable); static ArgumentMatcher<C> lte(C comparable); static ArgumentMatcher<String> matches(String regex); static ArgumentMatcher<T> notNull(); static ArgumentMatcher<String> startsWith(String prefix); }### Answer:
@Test public void testEndsWith() throws Exception { ArgumentMatcher<String> matcher = ArgumentMatcherUtils.endsWith("abc"); assertTrue(matcher.matches("abc")); assertTrue(matcher.matches("dabc")); assertFalse(matcher.matches("ab")); assertFalse(matcher.matches(null)); }
|
### Question:
ProxyUtils { public static <T> T nullValue(Class<T> type) { @SuppressWarnings("unchecked") final T result = (T) NULL_VALUE_MAP.get(type); return result; } private ProxyUtils(); static Class<?>[] getAllInterfaces(Class<?> cls); static String getJavaClassName(Class<?> clazz); static Class<?> getWrapperClass(Class<?> primitiveType); static T nullValue(Class<T> type); static boolean isEqualsMethod(Method method); static boolean isHashCode(Method method); static ProxyFactory proxyFactory(); static final Object[] EMPTY_ARGUMENTS; static final Class<?>[] EMPTY_ARGUMENT_TYPES; }### Answer:
@Test public void testNullValue() { assertNullValue(null, String.class); assertNullValue(Character.valueOf((char) 0), Character.TYPE); assertNullValue(Integer.valueOf(0), Integer.TYPE); assertNullValue(Long.valueOf(0), Long.TYPE); assertNullValue(Short.valueOf((short) 0), Short.TYPE); assertNullValue(Double.valueOf(0), Double.TYPE); assertNullValue(Float.valueOf(0), Float.TYPE); assertNullValue(Boolean.FALSE, Boolean.TYPE); assertNullValue(Byte.valueOf((byte) 0), Byte.TYPE); }
|
### Question:
ProxyUtils { public static Class<?>[] getAllInterfaces(Class<?> cls) { return cls == null ? null : ClassUtils.getAllInterfaces(cls).toArray(ArrayUtils.EMPTY_CLASS_ARRAY); } private ProxyUtils(); static Class<?>[] getAllInterfaces(Class<?> cls); static String getJavaClassName(Class<?> clazz); static Class<?> getWrapperClass(Class<?> primitiveType); static T nullValue(Class<T> type); static boolean isEqualsMethod(Method method); static boolean isHashCode(Method method); static ProxyFactory proxyFactory(); static final Object[] EMPTY_ARGUMENTS; static final Class<?>[] EMPTY_ARGUMENT_TYPES; }### Answer:
@Test public void testGetAllInterfaces() { assertNull(ProxyUtils.getAllInterfaces(null)); assertEquals(Arrays.asList(new Class[] { DuplicateEcho.class, Serializable.class, Echo.class }), Arrays.asList(ProxyUtils.getAllInterfaces(EchoImpl.class))); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.