method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
ValueWidget extends DOMWidget { public Boolean getBoolean(Object input) { Boolean ret = false; if (input != null) { if (input instanceof Boolean) { ret = (Boolean) input; } else if (input instanceof String) { ret = new Boolean((String) input); } } return ret; } T getValue(); void setValue(Object value); @Override void updateValue(Object input); abstract T getValueFromObject(Object input); Boolean getDisabled(); void setDisabled(Object disabled); Boolean getVisible(); void setVisible(Object visible); String getDescription(); void setDescription(Object description); Integer getMsg_throttle(); void setMsg_throttle(Object msg_throttle); Integer getInteger(Object input); Double getDouble(Object input); String getString(Object input); String[] getStringArray(Object input); Boolean getBoolean(Object input); }### Answer:
@Test public void getBooleanWithBooleanParam_returnBoolean() throws Exception { Boolean value = valueWidget.getBoolean(Boolean.TRUE); Assertions.assertThat(value).isTrue(); }
@Test public void getBooleanWithStringParam_returnBoolean() throws Exception { Boolean value = valueWidget.getBoolean("true"); Assertions.assertThat(value).isTrue(); }
@Test public void getBooleanWithNullParam_returnFalse() throws Exception { Boolean value = valueWidget.getBoolean(null); Assertions.assertThat(value).isFalse(); }
|
### Question:
Comm { public void open() { Message parentMessage = getParentMessage(); Message message = new Message(); message.setHeader(new Header(COMM_OPEN, parentMessage != null ? parentMessage.getHeader().getSession() : null)); if (parentMessage != null) { message.setParentHeader(getParentMessage().getHeader()); } HashMap<String, Serializable> map = new HashMap<>(); map.put(COMM_ID, getCommId()); map.put(TARGET_NAME, getTargetName()); map.put(DATA, data); map.put(TARGET_MODULE, getTargetModule()); message.setContent(map); kernel.publish(message); kernel.addComm(getCommId(), this); } Comm(String commId, String targetName); Comm(String commId, TargetNamesEnum targetName); Comm(TargetNamesEnum targetName); Comm(String targetName); String getCommId(); String getTargetName(); HashMap<?, ?> getData(); void setData(HashMap<?, ?> data); String getTargetModule(); void setTargetModule(String targetModule); List<Handler<Message>> getMsgCallbackList(); void addMsgCallbackList(Handler<Message>... handlers); void clearMsgCallbackList(); List<Handler<Message>> getCloseCallbackList(); void addCloseCallbackList(Handler<Message>... handlers); void clearCloseCallbackList(); void open(); void close(); void send(); void sendUpdate(final String propertyName, final Object value); void handleMsg(Message parentMessage); @Override String toString(); static final String METHOD; static final String UPDATE; static final String STATE; static final String COMM_ID; static final String TARGET_NAME; static final String DATA; static final String TARGET_MODULE; static final String COMMS; }### Answer:
@Test public void commOpen_shouldSendIOPubSocketMessage() throws NoSuchAlgorithmException { comm.open(); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Assertions.assertThat(kernel.getPublishedMessages().get(0)).isNotNull(); }
@Test public void commOpen_sentMessageHasTypeIsCommOpen() throws NoSuchAlgorithmException { comm.open(); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message sendMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getType()) .isEqualTo(JupyterMessages.COMM_OPEN.getName()); }
@Test public void commOpen_sentMessageHasCommId() throws NoSuchAlgorithmException { comm.open(); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message sendMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat((String) sendMessage.getContent().get(Comm.COMM_ID)).isNotEmpty(); }
@Test public void commOpen_sentMessageHasTargetName() throws NoSuchAlgorithmException { comm.open(); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message sendMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat((String) sendMessage.getContent().get(Comm.TARGET_NAME)).isNotEmpty(); }
@Test public void commOpen_sentMessageHasData() throws NoSuchAlgorithmException { initCommData(comm); comm.open(); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message sendMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat((Map) sendMessage.getContent().get(Comm.DATA)).isNotEmpty(); }
|
### Question:
Comm { public void close() { Message parentMessage = getParentMessage(); if (this.getCloseCallbackList() != null && !this.getCloseCallbackList().isEmpty()) { for (Handler<Message> handler : getCloseCallbackList()) { handler.handle(parentMessage); } } Message message = new Message(); message.setHeader(new Header(COMM_CLOSE, parentMessage != null ? parentMessage.getHeader().getSession() : null)); if (parentMessage != null) { message.setParentHeader(parentMessage.getHeader()); } HashMap<String, Serializable> map = new HashMap<>(); map.put(COMM_ID, getCommId()); map.put(DATA, new HashMap<>()); message.setContent(map); kernel.removeComm(getCommId()); kernel.publish(message); } Comm(String commId, String targetName); Comm(String commId, TargetNamesEnum targetName); Comm(TargetNamesEnum targetName); Comm(String targetName); String getCommId(); String getTargetName(); HashMap<?, ?> getData(); void setData(HashMap<?, ?> data); String getTargetModule(); void setTargetModule(String targetModule); List<Handler<Message>> getMsgCallbackList(); void addMsgCallbackList(Handler<Message>... handlers); void clearMsgCallbackList(); List<Handler<Message>> getCloseCallbackList(); void addCloseCallbackList(Handler<Message>... handlers); void clearCloseCallbackList(); void open(); void close(); void send(); void sendUpdate(final String propertyName, final Object value); void handleMsg(Message parentMessage); @Override String toString(); static final String METHOD; static final String UPDATE; static final String STATE; static final String COMM_ID; static final String TARGET_NAME; static final String DATA; static final String TARGET_MODULE; static final String COMMS; }### Answer:
@Test public void commClose_shouldSendIOPubSocketMessage() throws NoSuchAlgorithmException { comm.close(); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Assertions.assertThat(kernel.getPublishedMessages().get(0)).isNotNull(); }
@Test public void commClose_sentMessageHasTypeIsCommClose() throws NoSuchAlgorithmException { comm.close(); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message sendMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getType()) .isEqualTo(JupyterMessages.COMM_CLOSE.getName()); }
@Test public void commClose_sentMessageHasEmptyData() throws NoSuchAlgorithmException { initCommData(comm); comm.close(); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message sendMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat((Map) sendMessage.getContent().get(Comm.DATA)).isEmpty(); }
|
### Question:
ScalaCommOpenHandler extends CommOpenHandler { public Handler<Message>[] getKernelControlChanelHandlers(String targetName){ if(TargetNamesEnum.KERNEL_CONTROL_CHANNEL.getTargetName().equalsIgnoreCase(targetName)){ return (Handler<Message>[]) KERNEL_CONTROL_CHANNEL_HANDLERS; }else{ return (Handler<Message>[]) new Handler<?>[0]; } } ScalaCommOpenHandler(KernelFunctionality kernel); Handler<Message>[] getKernelControlChanelHandlers(String targetName); }### Answer:
@Test public void getControlHandlersWithTargetName_returnNotEmptyHandlersArray() throws Exception { Handler<Message>[] handlers = commOpenHandler.getKernelControlChanelHandlers(targetName); Assertions.assertThat(handlers).isNotEmpty(); }
@Test public void getControlHandlersWithEmptyString_returnEmptyHandlersArray() throws Exception { Handler<Message>[] handlers = commOpenHandler.getKernelControlChanelHandlers(""); Assertions.assertThat(handlers).isEmpty(); }
|
### Question:
Comm { public void send() { Message parentMessage = getParentMessage(); Message message = new Message(); message.setHeader(new Header(COMM_MSG, parentMessage != null ? parentMessage.getHeader().getSession() : null)); if (parentMessage != null) { message.setParentHeader(getParentMessage().getHeader()); } HashMap<String, Serializable> map = new HashMap<>(6); map.put(COMM_ID, getCommId()); map.put(DATA, data); message.setContent(map); kernel.publish(message); } Comm(String commId, String targetName); Comm(String commId, TargetNamesEnum targetName); Comm(TargetNamesEnum targetName); Comm(String targetName); String getCommId(); String getTargetName(); HashMap<?, ?> getData(); void setData(HashMap<?, ?> data); String getTargetModule(); void setTargetModule(String targetModule); List<Handler<Message>> getMsgCallbackList(); void addMsgCallbackList(Handler<Message>... handlers); void clearMsgCallbackList(); List<Handler<Message>> getCloseCallbackList(); void addCloseCallbackList(Handler<Message>... handlers); void clearCloseCallbackList(); void open(); void close(); void send(); void sendUpdate(final String propertyName, final Object value); void handleMsg(Message parentMessage); @Override String toString(); static final String METHOD; static final String UPDATE; static final String STATE; static final String COMM_ID; static final String TARGET_NAME; static final String DATA; static final String TARGET_MODULE; static final String COMMS; }### Answer:
@Test public void commSend_shouldSendIOPubSocketMessage() throws NoSuchAlgorithmException { comm.send(); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Assertions.assertThat(kernel.getPublishedMessages().get(0)).isNotNull(); }
@Test public void commSend_sentMessageHasTypeIsCommClose() throws NoSuchAlgorithmException { comm.send(); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message sendMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getType()) .isEqualTo(JupyterMessages.COMM_MSG.getName()); }
@Test public void commSend_sentMessageHasCommId() throws NoSuchAlgorithmException { comm.send(); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message sendMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat((String) sendMessage.getContent().get(Comm.COMM_ID)).isNotEmpty(); }
@Test public void commClose_sentMessageHasData() throws NoSuchAlgorithmException { initCommData(comm); comm.send(); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message sendMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat((Map) sendMessage.getContent().get(Comm.DATA)).isNotEmpty(); }
|
### Question:
CommMsgHandler extends KernelHandler<Message> { public void handle(Message message) { wrapBusyIdle(kernel, message, () -> { handleMsg(message); }); } CommMsgHandler(final KernelFunctionality kernel, final MessageCreator messageCreator); void handle(Message message); static String getString(Map<String, Serializable> map, String name); }### Answer:
@Test public void handleMessage_shouldSendTwoMessages() throws Exception { commMsgHandler.handle(message); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Assertions.assertThat(kernel.getPublishedMessages().size()).isEqualTo(2); }
@Test public void handleMessage_firstSentMessageHasExecutionStateIsBusy() throws Exception { commMsgHandler.handle(message); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message publishMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat(publishMessage.getContent().get("execution_state")).isEqualTo("busy"); }
@Test public void handleMessage_firstSentMessageHasSessionId() throws Exception { String expectedSessionId = message.getHeader().getSession(); commMsgHandler.handle(message); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message publishMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat(publishMessage.getHeader().getSession()).isEqualTo(expectedSessionId); }
@Test public void handleMessage_firstSentMessageHasTypeIsStatus() throws Exception { commMsgHandler.handle(message); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message publishMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat(publishMessage.getHeader().getType()) .isEqualTo(JupyterMessages.STATUS.getName()); }
@Test public void handleMessage_firstSentMessageHasParentHeader() throws Exception { String expectedHeader = message.getHeader().asJson(); commMsgHandler.handle(message); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message publishMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat(publishMessage.getParentHeader().asJson()).isEqualTo(expectedHeader); }
@Test public void handleMessage_firstSentMessageHasIdentities() throws Exception { String expectedIdentities = new String(message.getIdentities().get(0)); commMsgHandler.handle(message); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message publishMessage = kernel.getPublishedMessages().get(0); Assertions.assertThat(new String(publishMessage.getIdentities().get(0))) .isEqualTo(expectedIdentities); }
@Test public void handleMessage_secondSentMessageHasExecutionStateIsIdle() throws Exception { commMsgHandler.handle(message); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message publishMessage = kernel.getPublishedMessages().get(1); Assertions.assertThat(publishMessage.getContent().get("execution_state")).isEqualTo("idle"); }
@Test public void handleMessage_secondSentMessageHasSessionId() throws Exception { String expectedSessionId = message.getHeader().getSession(); commMsgHandler.handle(message); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message publishMessage = kernel.getPublishedMessages().get(1); Assertions.assertThat(publishMessage.getHeader().getSession()).isEqualTo(expectedSessionId); }
@Test public void handleMessage_secondSendMessageHasTypeIsStatus() throws Exception { commMsgHandler.handle(message); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message publishMessage = kernel.getPublishedMessages().get(1); Assertions.assertThat(publishMessage.getHeader().getType()) .isEqualTo(JupyterMessages.STATUS.getName()); }
@Test public void handleMessage_secondSentMessageHasIdentities() throws Exception { String expectedIdentities = new String(message.getIdentities().get(0)); commMsgHandler.handle(message); Assertions.assertThat(kernel.getPublishedMessages()).isNotEmpty(); Message publishMessage = kernel.getPublishedMessages().get(1); Assertions.assertThat(new String(publishMessage.getIdentities().get(0))) .isEqualTo(expectedIdentities); }
|
### Question:
ScalaKernelInfoHandler extends KernelHandler<Message> { @Override public void handle(Message message) { logger.debug("Processing kernel info request"); Message reply = new Message(); HashMap<String, Serializable> map = new HashMap<>(6); map.put("protocol_version", "5.0"); map.put("implementation", "scala"); map.put("implementation_version", "1.0.0"); HashMap<String, Serializable> map1 = new HashMap<String, Serializable>(7); map1.put("name", "Scala"); map1.put("version", scala.util.Properties.scalaPropOrElse("version.number", "(unknown)")); map1.put("mimetype", ""); map1.put("file_extension", ".scala"); map1.put("codemirror_mode", "text/x-scala"); map1.put("nbconverter_exporter", ""); map.put("language_info", map1); map.put("banner", "BeakerX kernel for Scala"); map.put("beakerx", true); map.put("help_links", new ArrayList<String>()); reply.setContent(map); reply.setHeader(new Header(KERNEL_INFO_REPLY, message.getHeader().getSession())); reply.setParentHeader(message.getHeader()); reply.setIdentities(message.getIdentities()); send(reply); } ScalaKernelInfoHandler(KernelFunctionality kernel); @Override void handle(Message message); }### Answer:
@Test public void handle_shouldSendMessage() throws Exception { handler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); }
@Test public void handle_sentMessageHasContent() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sentMessage.getContent()).isNotEmpty(); }
@Test public void handle_sentMessageHasHeaderTypeIsKernelInfoReply() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Header header = sentMessage.getHeader(); Assertions.assertThat(header).isNotNull(); Assertions.assertThat(header.getType()).isEqualTo(KERNEL_INFO_REPLY.getName()); }
@Test public void handle_sentMessageHasLanguageInfo() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Map<String, Serializable> map = sentMessage.getContent(); Assertions.assertThat(map).isNotNull(); Assertions.assertThat(map.get("language_info")).isNotNull(); }
@Test public void handle_messageContentHasScalaLabel() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Map<String, Serializable> map = sentMessage.getContent(); Assertions.assertThat(map).isNotNull(); Assertions.assertThat(map.get("implementation")).isEqualTo("scala"); }
|
### Question:
CommCloseHandler extends KernelHandler<Message> { @Override public void handle(Message message) { wrapBusyIdle(kernel, message, () -> { handleMsg(message); }); } CommCloseHandler(KernelFunctionality kernel); static String getString(Map<String, Serializable> map, String name); @Override void handle(Message message); }### Answer:
@Test public void handleMessage_shouldSendShellSocketMessage() throws Exception { commCloseHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); }
@Test public void handleMessage_sentMessageHasTypeIsCommClose() throws Exception { commCloseHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getType()) .isEqualTo(JupyterMessages.COMM_CLOSE.getName()); }
@Test public void handleMessage_sentMessageHasSessionId() throws Exception { String expectedSessionId = message.getHeader().getSession(); commCloseHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getSession()).isEqualTo(expectedSessionId); }
@Test public void handleMessage_sentMessageHasParentHeader() throws Exception { String expectedHeader = message.getHeader().asJson(); commCloseHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getParentHeader().asJson()).isEqualTo(expectedHeader); }
@Test public void handleMessage_sentMessageHasIdentities() throws Exception { String expectedIdentities = new String(message.getIdentities().get(0)); commCloseHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(new String(sendMessage.getIdentities().get(0))) .isEqualTo(expectedIdentities); }
|
### Question:
CommInfoHandler extends KernelHandler<Message> { @Override public void handle(Message message) { wrapBusyIdle(kernel, message, () -> { handleMsg(message); }); } CommInfoHandler(KernelFunctionality kernel); @Override void handle(Message message); }### Answer:
@Test public void handleMessage_shouldSendShellSocketMessage() throws Exception { commInfoHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); }
@Test public void handleMessage_sentMessageHasTypeIsCommInfoReply() throws Exception { commInfoHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getType()) .isEqualTo(JupyterMessages.COMM_INFO_REPLY.getName()); }
@Test public void handleMessage_sentMessageHasSessionId() throws Exception { String expectedSessionId = message.getHeader().getSession(); commInfoHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getSession()).isEqualTo(expectedSessionId); }
@Test public void handleMessage_sentMessageHasParentHeader() throws Exception { String expectedHeader = message.getHeader().asJson(); commInfoHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getParentHeader().asJson()).isEqualTo(expectedHeader); }
@Test public void handleMessage_sentMessageHasIdentities() throws Exception { String expectedIdentities = new String(message.getIdentities().get(0)); commInfoHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(new String(sendMessage.getIdentities().get(0))) .isEqualTo(expectedIdentities); }
|
### Question:
CommOpenHandler extends KernelHandler<Message> { @Override public void handle(Message message) { wrapBusyIdle(kernel, message, () -> { handleMsg(message); }); } CommOpenHandler(KernelFunctionality kernel); @Override void handle(Message message); abstract Handler<Message>[] getKernelControlChanelHandlers(String targetName); static String getString(Map<String, Serializable> map, String name); }### Answer:
@Test public void handleMessage_shouldSendShellSocketMessage() throws Exception { commOpenHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); }
@Test public void handleMessageWithoutCommId_shouldSendCloseCommMessage() throws Exception { message.getContent().remove(COMM_ID); commOpenHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getType()) .isEqualTo(JupyterMessages.COMM_CLOSE.getName()); }
@Test public void handleMessageWithoutTargetName_shouldSendCloseCommMessage() throws Exception { message.getContent().remove(TARGET_NAME); commOpenHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getType()) .isEqualTo(JupyterMessages.COMM_CLOSE.getName()); }
@Test public void handleMessage_sentMessageHasCommId() throws Exception { String expectedCommId = (String) message.getContent().get(COMM_ID); commOpenHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getContent().get(COMM_ID)).isEqualTo(expectedCommId); }
@Test public void handleMessage_sentMessageHasTargetName() throws Exception { String expectedTargetName = (String) message.getContent().get(TARGET_NAME); commOpenHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getContent().get(TARGET_NAME)).isEqualTo(expectedTargetName); }
@Test public void handleMessage_sentMessageHasEmptyData() throws Exception { commOpenHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat((Map) sendMessage.getContent().get(DATA)).isEmpty(); }
@Test public void handleMessage_sentMessageHasTargetModule() throws Exception { String expectedTargetModule = (String) message.getContent().get(TARGET_MODULE); commOpenHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getContent().get(TARGET_MODULE)) .isEqualTo(expectedTargetModule); }
@Test public void handleMessage_sentMessageHasParentHeader() throws Exception { String expectedHeader = message.getHeader().asJson(); commOpenHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getParentHeader().asJson()).isEqualTo(expectedHeader); }
@Test public void handleMessage_sentMessageHasIdentities() throws Exception { String expectedIdentities = new String(message.getIdentities().get(0)); commOpenHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(new String(sendMessage.getIdentities().get(0))) .isEqualTo(expectedIdentities); }
|
### Question:
MessageCreator { public Message createIdleMessage(Message parentMessage) { return getExecutionStateMessage(parentMessage, IDLE); } MessageCreator(KernelFunctionality kernel); Message buildMessage(Message message, String mime, String code, int executionCount); Message buildClearOutput(Message message, boolean wait); Message buildDisplayData(Message message, MIMEContainer value); Message buildOutputMessage(Message message, String text, boolean hasError); synchronized void createMagicMessage(Message reply, int executionCount, Message message); synchronized List<MessageHolder> createMessage(SimpleEvaluationObject seo); Message createBusyMessage(Message parentMessage); Message createIdleMessage(Message parentMessage); static final String EXECUTION_STATE; static final String BUSY; static final String IDLE; static final String TEXT_PLAIN; static final String NULL_RESULT; static Logger logger; }### Answer:
@Test public void createIdleMessage_messageHasTypeIsStatus() { Message message = messageCreator.createIdleMessage(new Message()); assertThat(message.type()).isEqualTo(JupyterMessages.STATUS); }
@Test public void createIdleMessage_messageHasExecutionStateIsIdle() { Message message = messageCreator.createIdleMessage(new Message()); Map data = message.getContent(); assertThat(data.get(MessageCreator.EXECUTION_STATE)).isEqualTo(MessageCreator.IDLE); }
|
### Question:
MessageCreator { public Message createBusyMessage(Message parentMessage) { return getExecutionStateMessage(parentMessage, BUSY); } MessageCreator(KernelFunctionality kernel); Message buildMessage(Message message, String mime, String code, int executionCount); Message buildClearOutput(Message message, boolean wait); Message buildDisplayData(Message message, MIMEContainer value); Message buildOutputMessage(Message message, String text, boolean hasError); synchronized void createMagicMessage(Message reply, int executionCount, Message message); synchronized List<MessageHolder> createMessage(SimpleEvaluationObject seo); Message createBusyMessage(Message parentMessage); Message createIdleMessage(Message parentMessage); static final String EXECUTION_STATE; static final String BUSY; static final String IDLE; static final String TEXT_PLAIN; static final String NULL_RESULT; static Logger logger; }### Answer:
@Test public void createBusyMessage_messageHasTypeIsStatus() { Message message = messageCreator.createBusyMessage(new Message()); assertThat(message.type()).isEqualTo(JupyterMessages.STATUS); }
@Test public void createBusyMessage_messageHasExecutionStateIsBusy() { Message message = messageCreator.createBusyMessage(new Message()); Map data = message.getContent(); assertThat(data.get(MessageCreator.EXECUTION_STATE)).isEqualTo(MessageCreator.BUSY); }
|
### Question:
TableDisplay extends ObservableTableDisplay implements InternalCommWidget { @Override public Comm getComm() { return this.comm; } TableDisplay(List<List<?>> v, List<String> co, List<String> cl); TableDisplay(Collection<Map<?,?>> v); TableDisplay(Collection<Map<?,?>> v, BeakerObjectConverter serializer); private TableDisplay(Map<?, ?> v); @Override Comm getComm(); @Override void close(); @Override String getModelNameValue(); @Override String getViewNameValue(); static TableDisplay createTableDisplayForMap(Map<?,?> v); TimeUnit getStringFormatForTimes(); void setStringFormatForTimes(TimeUnit stringFormatForTimes); Map<ColumnType, TableDisplayStringFormat> getStringFormatForType(); void setStringFormatForType(ColumnType type, TableDisplayStringFormat format); Map<String, TableDisplayStringFormat> getStringFormatForColumn(); void setStringFormatForColumn(String column, TableDisplayStringFormat format); void setStringFormatForColumn(String column, Object closure); Map<ColumnType, TableDisplayCellRenderer> getRendererForType(); void setRendererForType(ColumnType type, TableDisplayCellRenderer renderer); Map<String, TableDisplayCellRenderer> getRendererForColumn(); void setRendererForColumn(String column, TableDisplayCellRenderer renderer); Map<ColumnType, TableDisplayAlignmentProvider> getAlignmentForType(); void setAlignmentProviderForType(ColumnType type, TableDisplayAlignmentProvider alignmentProvider); Map<String, TableDisplayAlignmentProvider> getAlignmentForColumn(); void setAlignmentProviderForColumn(String column, TableDisplayAlignmentProvider alignmentProvider); Map<String, Boolean> getColumnsFrozen(); void setColumnFrozen(String column, boolean frozen); Map<String, Boolean> getColumnsFrozenRight(); void setColumnFrozenRight(String column, boolean frozen); Map<String, Boolean> getColumnsVisible(); void setColumnVisible(String column, boolean visible); List<String> getColumnOrder(); List<TableDisplayCellHighlighter> getCellHighlighters(); void addCellHighlighter(TableDisplayCellHighlighter cellHighlighter); void addCellHighlighter(Object closure); void removeAllCellHighlighters(); void setColumnOrder(List<String> columnOrder); void setToolTip(Object closure); List<List<String>> getTooltips(); Integer getDataFontSize(); void setDataFontSize(Integer dataFontSize); Integer getHeaderFontSize(); void setHeaderFontSize(Integer headerFontSize); List<List<Color>> getFontColor(); void setFontColorProvider(Object closure); void setRowFilter(Object closure); void setHeadersVertical(boolean headersVertical); Boolean getHeadersVertical(); void setHasIndex(String hasIndex); String getHasIndex(); void setTimeZone(String timeZone); String getTimeZone(); List<List<?>> getFilteredValues(); static List<Map<String, Object>> getValuesAsRows(List<List<?>> values, List<String> columns); static List<List<?>> getValuesAsMatrix(List<List<?>> values); static Map<String, Object> getValuesAsDictionary(List<List<?>> values); List<Map<String, Object>> getValuesAsRows(); List<List<?>> getValuesAsMatrix(); Map<String, Object> getValuesAsDictionary(); List<List<?>> getValues(); List<String> getColumnNames(); List<String> getTypes(); String getSubtype(); static final String VIEW_NAME_VALUE; static final String MODEL_NAME_VALUE; static final String TABLE_DISPLAY_SUBTYPE; static final String LIST_OF_MAPS_SUBTYPE; static final String MATRIX_SUBTYPE; static final String DICTIONARY_SUBTYPE; }### Answer:
@Test public void createTableDisplay_hasCommIsNotNull() throws Exception { TableDisplay tableDisplay = new TableDisplay(getListOfMapsData()); Assertions.assertThat(tableDisplay.getComm()).isNotNull(); }
|
### Question:
ScalaEvaluator implements Evaluator { @Override public void evaluate(SimpleEvaluationObject seo, String code) { jobQueue.add(new jobDescriptor(code,seo)); syncObject.release(); } @Inject ScalaEvaluator(Provider<BeakerObjectConverter> osp); void initialize(String id, String sId); @Override void startWorker(); String getShellId(); void setupAutoTranslation(); void killAllThreads(); void cancelExecution(); void resetEnvironment(); void exit(); @Override void setShellOptions(final KernelParameters kernelParameters); @Override void evaluate(SimpleEvaluationObject seo, String code); @Override AutocompleteResult autocomplete(String code, int caretPosition); }### Answer:
@Test public void evaluatePlot_shouldCreatePlotObject() throws Exception { String code = "import com.twosigma.beaker.chart.xychart.Plot;\n" + "val plot = new Plot();\n" + "plot.setTitle(\"test title\");"; SimpleEvaluationObject seo = new SimpleEvaluationObject(code, new ExecuteCodeCallbackTest()); scalaEvaluator.evaluate(seo, code); waitForResult(seo); Assertions.assertThat(seo.getStatus()).isEqualTo(FINISHED); Assertions.assertThat(seo.getPayload() instanceof Plot).isTrue(); Assertions.assertThat(((Plot)seo.getPayload()).getTitle()).isEqualTo("test title"); }
@Test public void evaluateDivisionByZero_shouldReturnArithmeticException() throws Exception { String code = "16/0"; SimpleEvaluationObject seo = new SimpleEvaluationObject(code, new ExecuteCodeCallbackTest()); scalaEvaluator.evaluate(seo, code); waitForResult(seo); Assertions.assertThat(seo.getStatus()).isEqualTo(ERROR); Assertions.assertThat((String)seo.getPayload()).contains("java.lang.ArithmeticException"); }
|
### Question:
TableDisplay extends ObservableTableDisplay implements InternalCommWidget { public static List<List<?>> getValuesAsMatrix(List<List<?>> values) { return values; } TableDisplay(List<List<?>> v, List<String> co, List<String> cl); TableDisplay(Collection<Map<?,?>> v); TableDisplay(Collection<Map<?,?>> v, BeakerObjectConverter serializer); private TableDisplay(Map<?, ?> v); @Override Comm getComm(); @Override void close(); @Override String getModelNameValue(); @Override String getViewNameValue(); static TableDisplay createTableDisplayForMap(Map<?,?> v); TimeUnit getStringFormatForTimes(); void setStringFormatForTimes(TimeUnit stringFormatForTimes); Map<ColumnType, TableDisplayStringFormat> getStringFormatForType(); void setStringFormatForType(ColumnType type, TableDisplayStringFormat format); Map<String, TableDisplayStringFormat> getStringFormatForColumn(); void setStringFormatForColumn(String column, TableDisplayStringFormat format); void setStringFormatForColumn(String column, Object closure); Map<ColumnType, TableDisplayCellRenderer> getRendererForType(); void setRendererForType(ColumnType type, TableDisplayCellRenderer renderer); Map<String, TableDisplayCellRenderer> getRendererForColumn(); void setRendererForColumn(String column, TableDisplayCellRenderer renderer); Map<ColumnType, TableDisplayAlignmentProvider> getAlignmentForType(); void setAlignmentProviderForType(ColumnType type, TableDisplayAlignmentProvider alignmentProvider); Map<String, TableDisplayAlignmentProvider> getAlignmentForColumn(); void setAlignmentProviderForColumn(String column, TableDisplayAlignmentProvider alignmentProvider); Map<String, Boolean> getColumnsFrozen(); void setColumnFrozen(String column, boolean frozen); Map<String, Boolean> getColumnsFrozenRight(); void setColumnFrozenRight(String column, boolean frozen); Map<String, Boolean> getColumnsVisible(); void setColumnVisible(String column, boolean visible); List<String> getColumnOrder(); List<TableDisplayCellHighlighter> getCellHighlighters(); void addCellHighlighter(TableDisplayCellHighlighter cellHighlighter); void addCellHighlighter(Object closure); void removeAllCellHighlighters(); void setColumnOrder(List<String> columnOrder); void setToolTip(Object closure); List<List<String>> getTooltips(); Integer getDataFontSize(); void setDataFontSize(Integer dataFontSize); Integer getHeaderFontSize(); void setHeaderFontSize(Integer headerFontSize); List<List<Color>> getFontColor(); void setFontColorProvider(Object closure); void setRowFilter(Object closure); void setHeadersVertical(boolean headersVertical); Boolean getHeadersVertical(); void setHasIndex(String hasIndex); String getHasIndex(); void setTimeZone(String timeZone); String getTimeZone(); List<List<?>> getFilteredValues(); static List<Map<String, Object>> getValuesAsRows(List<List<?>> values, List<String> columns); static List<List<?>> getValuesAsMatrix(List<List<?>> values); static Map<String, Object> getValuesAsDictionary(List<List<?>> values); List<Map<String, Object>> getValuesAsRows(); List<List<?>> getValuesAsMatrix(); Map<String, Object> getValuesAsDictionary(); List<List<?>> getValues(); List<String> getColumnNames(); List<String> getTypes(); String getSubtype(); static final String VIEW_NAME_VALUE; static final String MODEL_NAME_VALUE; static final String TABLE_DISPLAY_SUBTYPE; static final String LIST_OF_MAPS_SUBTYPE; static final String MATRIX_SUBTYPE; static final String DICTIONARY_SUBTYPE; }### Answer:
@Test public void getValuesAsMatrixWithoutParams_returnedListOfListIsNotEmpty() throws Exception { TableDisplay tableDisplay = new TableDisplay(getListOfMapsData()); List<List<?>> values = tableDisplay.getValuesAsMatrix(); Assertions.assertThat(values).isNotEmpty(); }
@Test public void getValuesAsMatrixWithParam_returnedListOfListIsNotEmpty() throws Exception { List<List<?>> values = TableDisplay.getValuesAsMatrix(Arrays.asList(getStringList(), getRowData())); Assertions.assertThat(values).isNotEmpty(); }
|
### Question:
TableDisplay extends ObservableTableDisplay implements InternalCommWidget { public static Map<String, Object> getValuesAsDictionary(List<List<?>> values) { Map<String, Object> m = new HashMap<String, Object>(); for (List<?> l : values) { if (l.size() != 2) throw new IllegalArgumentException("Method 'getValuesAsDictionary' doesn't supported for this table"); ; m.put(l.get(0).toString(), l.get(1)); } return m; } TableDisplay(List<List<?>> v, List<String> co, List<String> cl); TableDisplay(Collection<Map<?,?>> v); TableDisplay(Collection<Map<?,?>> v, BeakerObjectConverter serializer); private TableDisplay(Map<?, ?> v); @Override Comm getComm(); @Override void close(); @Override String getModelNameValue(); @Override String getViewNameValue(); static TableDisplay createTableDisplayForMap(Map<?,?> v); TimeUnit getStringFormatForTimes(); void setStringFormatForTimes(TimeUnit stringFormatForTimes); Map<ColumnType, TableDisplayStringFormat> getStringFormatForType(); void setStringFormatForType(ColumnType type, TableDisplayStringFormat format); Map<String, TableDisplayStringFormat> getStringFormatForColumn(); void setStringFormatForColumn(String column, TableDisplayStringFormat format); void setStringFormatForColumn(String column, Object closure); Map<ColumnType, TableDisplayCellRenderer> getRendererForType(); void setRendererForType(ColumnType type, TableDisplayCellRenderer renderer); Map<String, TableDisplayCellRenderer> getRendererForColumn(); void setRendererForColumn(String column, TableDisplayCellRenderer renderer); Map<ColumnType, TableDisplayAlignmentProvider> getAlignmentForType(); void setAlignmentProviderForType(ColumnType type, TableDisplayAlignmentProvider alignmentProvider); Map<String, TableDisplayAlignmentProvider> getAlignmentForColumn(); void setAlignmentProviderForColumn(String column, TableDisplayAlignmentProvider alignmentProvider); Map<String, Boolean> getColumnsFrozen(); void setColumnFrozen(String column, boolean frozen); Map<String, Boolean> getColumnsFrozenRight(); void setColumnFrozenRight(String column, boolean frozen); Map<String, Boolean> getColumnsVisible(); void setColumnVisible(String column, boolean visible); List<String> getColumnOrder(); List<TableDisplayCellHighlighter> getCellHighlighters(); void addCellHighlighter(TableDisplayCellHighlighter cellHighlighter); void addCellHighlighter(Object closure); void removeAllCellHighlighters(); void setColumnOrder(List<String> columnOrder); void setToolTip(Object closure); List<List<String>> getTooltips(); Integer getDataFontSize(); void setDataFontSize(Integer dataFontSize); Integer getHeaderFontSize(); void setHeaderFontSize(Integer headerFontSize); List<List<Color>> getFontColor(); void setFontColorProvider(Object closure); void setRowFilter(Object closure); void setHeadersVertical(boolean headersVertical); Boolean getHeadersVertical(); void setHasIndex(String hasIndex); String getHasIndex(); void setTimeZone(String timeZone); String getTimeZone(); List<List<?>> getFilteredValues(); static List<Map<String, Object>> getValuesAsRows(List<List<?>> values, List<String> columns); static List<List<?>> getValuesAsMatrix(List<List<?>> values); static Map<String, Object> getValuesAsDictionary(List<List<?>> values); List<Map<String, Object>> getValuesAsRows(); List<List<?>> getValuesAsMatrix(); Map<String, Object> getValuesAsDictionary(); List<List<?>> getValues(); List<String> getColumnNames(); List<String> getTypes(); String getSubtype(); static final String VIEW_NAME_VALUE; static final String MODEL_NAME_VALUE; static final String TABLE_DISPLAY_SUBTYPE; static final String LIST_OF_MAPS_SUBTYPE; static final String MATRIX_SUBTYPE; static final String DICTIONARY_SUBTYPE; }### Answer:
@Test public void getValuesAsDictionaryWithParam_returnedMapIsNotEmpty() throws Exception { Map<String, Object> dictionary = TableDisplay.getValuesAsDictionary(Arrays.asList(Arrays.asList("k1", 1), Arrays.asList("k2", 2))); Assertions.assertThat(dictionary).isNotEmpty(); }
|
### Question:
TableDisplayAlignmentSerializer extends JsonSerializer<TableDisplayAlignmentProvider> { @Override public void serialize(TableDisplayAlignmentProvider value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { synchronized (value) { jgen.writeString(value.getCode()); } } @Override void serialize(TableDisplayAlignmentProvider value,
JsonGenerator jgen,
SerializerProvider provider); }### Answer:
@Test public void serializeTableDisplayLeftAligment_resultJsonHasLValue() throws IOException { serializer.serialize( TableDisplayAlignmentProvider.LEFT_ALIGNMENT, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.asText()).isEqualTo("L"); }
|
### Question:
NamespaceClient { public synchronized static NamespaceClient getBeaker() { if (currentSession!=null){ return nsClients.get(currentSession); } return null; } NamespaceClient(); synchronized void showProgressUpdate(String message, int progress); SimpleEvaluationObject getOutputObj(); synchronized void setOutputObj(SimpleEvaluationObject input); synchronized static NamespaceClient getBeaker(); synchronized static NamespaceClient getBeaker(String session); synchronized static void delBeaker(String sessionId); synchronized Object set(String name, Object value); Object setFast(String name, Object value); Object unset(String name); synchronized Object get(final String name); static SynchronousQueue<Object> getMessageQueue(String channel); List<BeakerCodeCell> getCodeCells(String tagFilter); }### Answer:
@Test public void getNamespaceClientBySessionId_returnNamespaceClient() { NamespaceClient curNamespaceClient = NamespaceClient.getBeaker(SESSION_ID); Assertions.assertThat(namespaceClient).isNotNull(); Assertions.assertThat(curNamespaceClient).isEqualTo(namespaceClient); }
@Test public void getNamespaceClientByCurrentSessionId_returnNamespaceClient() { NamespaceClient curNamespaceClient = NamespaceClient.getBeaker(); Assertions.assertThat(curNamespaceClient).isNotNull(); Assertions.assertThat(curNamespaceClient).isEqualTo(namespaceClient); }
|
### Question:
SelectMultipleSingleWidget extends ListComponent implements CommFunctionality, EasyFormWidget { @Override public void setValues(Collection<String> values) { super.setValues(values); this.widget.setOptions(values.stream().toArray(String[]::new)); } SelectMultipleSingleWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override void setSize(Integer size); @Override Integer getSize(); @Override void setValues(Collection<String> values); @Override DOMWidget getWidget(); @Override void close(); }### Answer:
@Test public void setValues() throws Exception { String newValue = "2"; SelectMultipleSingleWidget widget = new SelectMultipleSingleWidget(); widget.setValues(asList("1", "2", "3")); kernel.clearPublishedMessages(); widget.setValue(newValue); verifyMsgForProperty(kernel, SelectMultiple.VALUE, "2"); }
|
### Question:
SelectMultipleSingleWidget extends ListComponent implements CommFunctionality, EasyFormWidget { @Override public void setSize(Integer size) { this.widget.setSize(size); } SelectMultipleSingleWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override void setSize(Integer size); @Override Integer getSize(); @Override void setValues(Collection<String> values); @Override DOMWidget getWidget(); @Override void close(); }### Answer:
@Test public void setSize() throws Exception { Integer newValue = 2; SelectMultipleSingleWidget widget = new SelectMultipleSingleWidget(); widget.setValues(asList("1", "2", "3")); kernel.clearPublishedMessages(); widget.setSize(newValue); verifyMsgForProperty(kernel, SelectMultipleSingle.SIZE, 2); }
|
### Question:
CheckBoxWidget extends CheckBox implements CommFunctionality, EasyFormWidget { @Override public void setValue(String value) { this.widget.setValue(Boolean.valueOf(value)); } CheckBoxWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override DOMWidget getWidget(); @Override void close(); }### Answer:
@Test public void setValue() throws Exception { Boolean newValue = Boolean.TRUE; CheckBoxWidget widget = new CheckBoxWidget(); kernel.clearPublishedMessages(); widget.setValue(newValue.toString()); verifyValue(kernel.getPublishedMessages().get(0), newValue); }
|
### Question:
ComboBoxWidget extends ComboBox implements CommFunctionality, EasyFormWidget { @Override public void setValue(String value) { this.widget.setValue(value); } ComboBoxWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override void setValues(Collection<String> values); @Override void setEditable(Boolean editable); @Override void setValue(String value); @Override String getValue(); @Override DOMWidget getWidget(); @Override void close(); }### Answer:
@Test public void setValue() throws Exception { String newValue = "2"; ComboBoxWidget widget = new ComboBoxWidget(); widget.setValues(asList("1", "2", "3")); kernel.clearPublishedMessages(); widget.setValue(newValue); verifyValue(kernel.getPublishedMessages().get(0), newValue); }
|
### Question:
ComboBoxWidget extends ComboBox implements CommFunctionality, EasyFormWidget { @Override public void setEditable(Boolean editable) { super.setEditable(editable); this.widget.setDisabled(editable); } ComboBoxWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override void setValues(Collection<String> values); @Override void setEditable(Boolean editable); @Override void setValue(String value); @Override String getValue(); @Override DOMWidget getWidget(); @Override void close(); }### Answer:
@Test public void setEditable() throws Exception { Boolean newValue = Boolean.TRUE; ComboBoxWidget widget = new ComboBoxWidget(); kernel.clearPublishedMessages(); widget.setEditable(newValue); verifyEditable(kernel.getPublishedMessages().get(0), newValue); }
|
### Question:
TextFieldWidget extends TextField implements CommFunctionality, EasyFormWidget { @Override public void setValue(String value) { this.text.setValue(value); } TextFieldWidget(); @Override DOMWidget getWidget(); @Override String getLabel(); @Override void setLabel(String label); @Override void setValue(String value); @Override String getValue(); @Override Comm getComm(); @Override TextField setWidth(Integer width); @Override void close(); }### Answer:
@Test public void setValue() throws Exception { String newValue = "newValue"; TextFieldWidget widget = new TextFieldWidget(); kernel.clearPublishedMessages(); widget.setValue(newValue); verifyTextFieldValue(kernel.getPublishedMessages().get(0), newValue); }
|
### Question:
TextFieldWidget extends TextField implements CommFunctionality, EasyFormWidget { @Override public TextField setWidth(Integer width) { text.getLayout().setWidth(width + PX); return super.setWidth(width); } TextFieldWidget(); @Override DOMWidget getWidget(); @Override String getLabel(); @Override void setLabel(String label); @Override void setValue(String value); @Override String getValue(); @Override Comm getComm(); @Override TextField setWidth(Integer width); @Override void close(); }### Answer:
@Test public void setWidth() throws Exception { Integer newValue = 11; TextFieldWidget widget = new TextFieldWidget(); kernel.clearPublishedMessages(); widget.setWidth(newValue); verifyTextFieldWidth(kernel.getPublishedMessages().get(0), "11" + PX); }
|
### Question:
ButtonComponentWidget extends ButtonComponent implements CommFunctionality, EasyFormWidget { @Override public void setTag(String tag) { this.widget.setTag(tag); } ButtonComponentWidget(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getLabel(); @Override String getValue(); @Override void setValue(String value); @Override void setTag(String tag); @Override String getTag(); @Override DOMWidget getWidget(); @Override void close(); }### Answer:
@Test public void setTag() throws Exception { String tag = "tag1"; ButtonComponentWidget widget = new ButtonComponentWidget(); kernel.clearPublishedMessages(); widget.setTag(tag); verifyTag(kernel.getPublishedMessages().get(0), tag); }
|
### Question:
ButtonComponentWidget extends ButtonComponent implements CommFunctionality, EasyFormWidget { @Override public Comm getComm() { return widget.getComm(); } ButtonComponentWidget(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getLabel(); @Override String getValue(); @Override void setValue(String value); @Override void setTag(String tag); @Override String getTag(); @Override DOMWidget getWidget(); @Override void close(); }### Answer:
@Test public void handleActionPerformed() throws Exception { final StringBuilder result = new StringBuilder(); ButtonComponentWidget widget = new ButtonComponentWidget(); widget.actionPerformed = value -> result.append("action done 1"); widget.getComm().getMsgCallbackList().forEach(x -> x.handle(messageWithClickEvent())); assertThat(result.toString()).isEqualTo("action done 1"); }
@Test public void noHandleActionPerformed() throws Exception { final StringBuilder result = new StringBuilder().append("no action"); ButtonComponentWidget widget = new ButtonComponentWidget(); widget.actionPerformed = value -> result.append("action done 2"); widget.getComm().getMsgCallbackList().forEach(x -> x.handle(messageWithoutClickEvent())); assertThat(result.toString()).isEqualTo("no action"); }
|
### Question:
SelectMultipleWidget extends ListComponent implements CommFunctionality, EasyFormWidget { @Override public void setValues(Collection<String> values) { super.setValues(values); this.widget.setOptions(values.stream().toArray(String[]::new)); } SelectMultipleWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override void setSize(Integer size); @Override Integer getSize(); @Override void setValues(Collection<String> values); void setValue(String[] value); @Override DOMWidget getWidget(); @Override void close(); }### Answer:
@Test public void setValues() throws Exception { String[] newValue = new String[]{"1", "2"}; SelectMultipleWidget widget = new SelectMultipleWidget(); widget.setValues(asList("1", "2", "3")); kernel.clearPublishedMessages(); widget.setValue(newValue); verifyMsgForProperty(kernel, SelectMultiple.VALUE, new String[]{"1", "2"}); }
|
### Question:
SelectMultipleWidget extends ListComponent implements CommFunctionality, EasyFormWidget { @Override public void setSize(Integer size) { this.widget.setSize(size); } SelectMultipleWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override void setSize(Integer size); @Override Integer getSize(); @Override void setValues(Collection<String> values); void setValue(String[] value); @Override DOMWidget getWidget(); @Override void close(); }### Answer:
@Test public void setSize() throws Exception { Integer newValue = 3; SelectMultipleWidget widget = new SelectMultipleWidget(); widget.setValues(asList("1", "2", "3")); kernel.clearPublishedMessages(); widget.setSize(newValue); verifyMsgForProperty(kernel, SelectMultiple.SIZE, 3); }
|
### Question:
DatePickerComponentWidget extends DatePickerComponent implements CommFunctionality, EasyFormWidget { @Override public void setShowTime(Boolean showTime) { this.widget.setShowTime(showTime); } DatePickerComponentWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override DOMWidget getWidget(); @Override void setShowTime(Boolean showTime); @Override Boolean getShowTime(); @Override void close(); }### Answer:
@Test public void setShowTime() throws Exception { Boolean newValue = Boolean.TRUE; DatePickerComponentWidget widget = new DatePickerComponentWidget(); kernel.clearPublishedMessages(); widget.setShowTime(newValue); verifyShowTime(kernel.getPublishedMessages().get(0), true); }
|
### Question:
CheckBoxGroupWidget extends CheckBoxGroup implements CommFunctionality, EasyFormWidget { @Override public void setValues(Collection<String> values) { values.forEach(item -> { Checkbox checkbox = new Checkbox(); checkbox.setDescription(item); checkboxes.add(checkbox); }); } CheckBoxGroupWidget(); @Override String getLabel(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override Collection<String> getValues(); @Override void setValues(Collection<String> values); void createWidget(); @Override Comm getComm(); @Override DOMWidget getWidget(); @Override void close(); }### Answer:
@Test public void setValues() throws Exception { List<String> newValue = Arrays.asList("1", "2", "3"); CheckBoxGroupWidget widget = new CheckBoxGroupWidget(); kernel.clearPublishedMessages(); widget.setValues(newValue); assertTrue("Comm msgs should be 9", kernel.getPublishedMessages().size() == 9); Assertions.assertThat(widget.getValues()).isEqualTo(EMPTY); }
|
### Question:
GroovyCommOpenHandler extends CommOpenHandler { public Handler<Message>[] getKernelControlChanelHandlers(String targetName){ if(TargetNamesEnum.KERNEL_CONTROL_CHANNEL.getTargetName().equalsIgnoreCase(targetName)){ return (Handler<Message>[]) KERNEL_CONTROL_CHANNEL_HANDLERS; }else if(TargetNamesEnum.BEAKER_GETCODECELLS.getTargetName().equalsIgnoreCase(targetName)){ return (Handler<Message>[]) KERNEL_GET_CODECELLS_CHANNEL_HANDLER; } else{ return (Handler<Message>[]) new Handler<?>[0]; } } GroovyCommOpenHandler(KernelFunctionality kernel); Handler<Message>[] getKernelControlChanelHandlers(String targetName); }### Answer:
@Test public void getControlHandlersWithEmptyString_returnEmptyHandlersArray() throws Exception { Handler<Message>[] handlers = commOpenHandler.getKernelControlChanelHandlers(""); Assertions.assertThat(handlers).isEmpty(); }
@Test public void getControlHandlersWithTargetName_returnNotEmptyHandlersArray() throws Exception { Handler<Message>[] handlers = commOpenHandler.getKernelControlChanelHandlers(targetName); Assertions.assertThat(handlers).isNotEmpty(); }
|
### Question:
TextAreaWidget extends TextArea implements CommFunctionality, EasyFormWidget { @Override public void setValue(String value) { this.widget.setValue(value); } TextAreaWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override DOMWidget getWidget(); @Override void setWidth(Integer width); @Override void setHeight(Integer height); @Override void close(); }### Answer:
@Test public void setValue() throws Exception { String newValue = "newValue"; TextAreaWidget widget = new TextAreaWidget(); kernel.clearPublishedMessages(); widget.setValue(newValue); verifyTextAreaValue(kernel.getPublishedMessages().get(0), newValue); }
|
### Question:
TextAreaWidget extends TextArea implements CommFunctionality, EasyFormWidget { @Override public void setWidth(Integer width) { super.setWidth(width); widget.getLayout().setWidth(width + PX); } TextAreaWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override DOMWidget getWidget(); @Override void setWidth(Integer width); @Override void setHeight(Integer height); @Override void close(); }### Answer:
@Test public void setWidth() throws Exception { Integer newValue = 11; TextAreaWidget widget = new TextAreaWidget(); kernel.clearPublishedMessages(); widget.setWidth(newValue); verifyWidth(kernel.getPublishedMessages().get(0), "11" + PX); }
|
### Question:
TextAreaWidget extends TextArea implements CommFunctionality, EasyFormWidget { @Override public void setHeight(Integer height) { super.setHeight(height); widget.getLayout().setHeight(height + PX); } TextAreaWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override DOMWidget getWidget(); @Override void setWidth(Integer width); @Override void setHeight(Integer height); @Override void close(); }### Answer:
@Test public void setHeight() throws Exception { Integer newValue = 22; TextAreaWidget widget = new TextAreaWidget(); kernel.clearPublishedMessages(); widget.setHeight(newValue); verifyHeight(kernel.getPublishedMessages().get(0), "22" + PX); }
|
### Question:
RadioButtonComponentWidget extends RadioButtonComponent implements CommFunctionality, EasyFormWidget { @Override public void setValues(Collection<String> values) { this.widget.setOptions(values.stream().toArray(String[]::new)); } RadioButtonComponentWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override void setValues(Collection<String> values); @Override Collection<String> getValues(); @Override DOMWidget getWidget(); @Override void close(); }### Answer:
@Test public void setValues() throws Exception { String newValue = "2"; RadioButtonComponentWidget widget = new RadioButtonComponentWidget(); widget.setValues(asList("1", "2", "3")); kernel.clearPublishedMessages(); widget.setValue(newValue); verifyMsgForProperty(kernel, SelectMultiple.VALUE, "2"); }
|
### Question:
EasyFormView extends Box implements InternalCommWidget { public void setEasyFormName(String easyFormName) { this.easyFormName = easyFormName; sendUpdate(EASY_FORM_NAME, easyFormName); } EasyFormView(List<CommFunctionality> children); @Override void updateValue(Object value); String getEasyFormName(); void setEasyFormName(String easyFormName); String getModelNameValue(); String getViewNameValue(); static final String VIEW_NAME_VALUE; static final String MODEL_NAME_VALUE; static final String EASY_FORM_NAME; }### Answer:
@Test public void shouldSendCommMsgWhenEasyFormNameChange() throws Exception { EasyFormView widget = easyForm(); widget.setEasyFormName("title2"); verifyMsgForProperty(groovyKernel, EasyFormView.EASY_FORM_NAME, "title2"); }
|
### Question:
CsvPlotReader { public List<Map<?, ?>> readAsList(String fileName) throws IOException { return convert(Table.createFromCsv(fileName)); } List<Map<?, ?>> convert(Table table); Table read(String fileName); List<Map<?, ?>> readAsList(String fileName); }### Answer:
@Test public void shouldReturnDataAsListForPlot() throws Exception { List<Map<?, ?>> values = new CsvPlotReader().readAsList(getOsAppropriatePath("tableRowsTest.csv")); assertThat(values.get(2).get("m3")).isEqualTo(8.0f); assertThat(values.get(2).get("time")) .isEqualTo(new SimpleDateFormat("yyyy-MM-dd").parse("1990-03-31").getTime()); }
|
### Question:
ResultsDeserializer implements ObjectDeserializer { @Override public Object deserialize(JsonNode n, ObjectMapper mapper) { Object o = null; try { if (n.has("payload")) { o = parent.deserialize(n.get("payload"), mapper); } } catch (Exception e) { logger.error("exception deserializing Results ", e); } return o; } ResultsDeserializer(BeakerObjectConverter p); @Override boolean canBeUsed(JsonNode n); @Override Object deserialize(JsonNode n, ObjectMapper mapper); }### Answer:
@Test public void deserialize_resultObjectHasPayload() throws Exception { boolean payload = true; ObjectMapper mapper = new ObjectMapper(); JsonNode actualObj = mapper.readTree( "{\"type\":\"Results\",\"payload\":\"" + payload + "\"}"); ResultsDeserializer deserializer = new ResultsDeserializer(new BasicObjectSerializer()); Boolean result = (Boolean) deserializer.deserialize(actualObj, mapper); Assertions.assertThat(result).isEqualTo(payload); }
|
### Question:
MapDeserializer implements ObjectDeserializer { @Override public Object deserialize(JsonNode n, ObjectMapper mapper) { HashMap<String, Object> o = new HashMap<String,Object>(); try { logger.debug("using custom map deserializer"); Iterator<Entry<String, JsonNode>> e = n.fields(); while(e.hasNext()) { Entry<String, JsonNode> ee = e.next(); o.put(ee.getKey(), parent.deserialize(ee.getValue(),mapper)); } } catch (Exception e) { logger.error("exception deserializing Map ", e); o = null; } return o; } MapDeserializer(BeakerObjectConverter p); @Override boolean canBeUsed(JsonNode n); @Override Object deserialize(JsonNode n, ObjectMapper mapper); }### Answer:
@Test public void deserialize_resultObjectHasValues() throws Exception { ObjectMapper mapper = new ObjectMapper(); JsonNode actualObj = mapper.readTree("{\"k1\":\"1\",\"k2\":\"true\"}"); MapDeserializer deserializer = new MapDeserializer(new BasicObjectSerializer()); Map map = (Map) deserializer.deserialize(actualObj, mapper); Assertions.assertThat(map).isNotNull(); Assertions.assertThat(map.get("k2")).isEqualTo(true); }
|
### Question:
DateDeserializer implements ObjectDeserializer { @Override public Object deserialize(JsonNode n, ObjectMapper mapper) { Object o = null; try { if (n.has("timestamp")) o = new Date(n.get("timestamp").asLong()); } catch (Exception e) { logger.error("exception deserializing Date {}", e.getMessage()); } return o; } DateDeserializer(BeakerObjectConverter p); @Override boolean canBeUsed(JsonNode n); @Override Object deserialize(JsonNode n, ObjectMapper mapper); }### Answer:
@Test public void deserialize_resultObjectHasTimestamp() throws Exception { long timestamp = 1492423972082L; ObjectMapper mapper = new ObjectMapper(); JsonNode actualObj = mapper.readTree("{\"type\":\"Date\",\"timestamp\":"+ timestamp +"}"); DateDeserializer deserializer = new DateDeserializer(new BasicObjectSerializer()); Date date = (Date) deserializer.deserialize(actualObj, mapper); Assertions.assertThat(date).isNotNull(); Assertions.assertThat(date.getTime()).isEqualTo(timestamp); }
|
### Question:
BasicObjectSerializer implements BeakerObjectConverter { protected boolean isPrimitiveTypeMap(Object o) { if (!(o instanceof Map<?, ?>)) return false; Map<?, ?> m = (Map<?, ?>) o; Set<?> eset = m.entrySet(); for (Object entry : eset) { Entry<?, ?> e = (Entry<?, ?>) entry; if (e.getValue() != null && !isPrimitiveType(e.getValue().getClass().getName())) return false; } return true; } BasicObjectSerializer(); @Override String convertType(String tn); @Override boolean isPrimitiveType(String tn); @Override boolean writeObject(Object obj, JsonGenerator jgen, boolean expand); boolean runThreadSerializers(Object obj, JsonGenerator jgen, boolean expand); boolean runConfiguredSerializers(Object obj, JsonGenerator jgen, boolean expand); @Override Object deserialize(JsonNode n, ObjectMapper mapper); @Override void addTypeConversion(String from, String to); @Override void addTypeDeserializer(ObjectDeserializer o); @Override void addTypeSerializer(ObjectSerializer o); @Override void addfTypeDeserializer(ObjectDeserializer o); @Override void addfTypeSerializer(ObjectSerializer o); @Override void addThreadSpecificTypeConversion(String from, String to); @Override void addThreadSpecificTypeDeserializer(ObjectDeserializer o); @Override void addThreadSpecificTypeSerializer(ObjectSerializer o); @Override void addKnownBeakerType(String t); @Override boolean isKnownBeakerType(String t); static final String TYPE_INTEGER; static final String TYPE_LONG; static final String TYPE_BIGINT; static final String TYPE_DOUBLE; static final String TYPE_STRING; static final String TYPE_BOOLEAN; static final String TYPE_TIME; static final String TYPE_SELECT; }### Answer:
@Test public void isPrimitiveTypeMap_returnTrue() throws Exception { Map<String, String> map = new HashMap<String, String>(){ { put("key", "value"); } }; boolean result = basicObjectSerializer.isPrimitiveTypeMap(map); Assertions.assertThat(result).isTrue(); }
|
### Question:
BasicObjectSerializer implements BeakerObjectConverter { protected boolean isListOfPrimitiveTypeMaps(Object o) { if (!(o instanceof Collection<?>)) return false; Collection<?> c = (Collection<?>) o; if (c.isEmpty()) return false; for (Object obj : c) { if (obj != null && !isPrimitiveTypeMap(obj)) { return false; } } return true; } BasicObjectSerializer(); @Override String convertType(String tn); @Override boolean isPrimitiveType(String tn); @Override boolean writeObject(Object obj, JsonGenerator jgen, boolean expand); boolean runThreadSerializers(Object obj, JsonGenerator jgen, boolean expand); boolean runConfiguredSerializers(Object obj, JsonGenerator jgen, boolean expand); @Override Object deserialize(JsonNode n, ObjectMapper mapper); @Override void addTypeConversion(String from, String to); @Override void addTypeDeserializer(ObjectDeserializer o); @Override void addTypeSerializer(ObjectSerializer o); @Override void addfTypeDeserializer(ObjectDeserializer o); @Override void addfTypeSerializer(ObjectSerializer o); @Override void addThreadSpecificTypeConversion(String from, String to); @Override void addThreadSpecificTypeDeserializer(ObjectDeserializer o); @Override void addThreadSpecificTypeSerializer(ObjectSerializer o); @Override void addKnownBeakerType(String t); @Override boolean isKnownBeakerType(String t); static final String TYPE_INTEGER; static final String TYPE_LONG; static final String TYPE_BIGINT; static final String TYPE_DOUBLE; static final String TYPE_STRING; static final String TYPE_BOOLEAN; static final String TYPE_TIME; static final String TYPE_SELECT; }### Answer:
@Test public void isListOfPrimitiveTypeMaps_returnTrue() throws Exception { boolean result = basicObjectSerializer.isListOfPrimitiveTypeMaps( ObservableTableDisplayTest.getListOfMapsData()); Assertions.assertThat(result).isTrue(); }
|
### Question:
BasicObjectSerializer implements BeakerObjectConverter { protected boolean isPrimitiveTypeListOfList(Object o) { if (!(o instanceof Collection<?>)) return false; Collection<?> m = (Collection<?>) o; int max = 0; for (Object entry : m) { if (!(entry instanceof Collection<?>)) return false; Collection<?> e = (Collection<?>) entry; for (Object ei : e) { if (ei != null && !isPrimitiveType(ei.getClass().getName())) return false; } if (max < e.size()) max = e.size(); } return max >= 2 && m.size() >= 2; } BasicObjectSerializer(); @Override String convertType(String tn); @Override boolean isPrimitiveType(String tn); @Override boolean writeObject(Object obj, JsonGenerator jgen, boolean expand); boolean runThreadSerializers(Object obj, JsonGenerator jgen, boolean expand); boolean runConfiguredSerializers(Object obj, JsonGenerator jgen, boolean expand); @Override Object deserialize(JsonNode n, ObjectMapper mapper); @Override void addTypeConversion(String from, String to); @Override void addTypeDeserializer(ObjectDeserializer o); @Override void addTypeSerializer(ObjectSerializer o); @Override void addfTypeDeserializer(ObjectDeserializer o); @Override void addfTypeSerializer(ObjectSerializer o); @Override void addThreadSpecificTypeConversion(String from, String to); @Override void addThreadSpecificTypeDeserializer(ObjectDeserializer o); @Override void addThreadSpecificTypeSerializer(ObjectSerializer o); @Override void addKnownBeakerType(String t); @Override boolean isKnownBeakerType(String t); static final String TYPE_INTEGER; static final String TYPE_LONG; static final String TYPE_BIGINT; static final String TYPE_DOUBLE; static final String TYPE_STRING; static final String TYPE_BOOLEAN; static final String TYPE_TIME; static final String TYPE_SELECT; }### Answer:
@Test public void isPrimitiveTypeListOfList_returnTrue() throws Exception { boolean result = basicObjectSerializer.isPrimitiveTypeListOfList( Arrays.asList(Arrays.asList("k1", 1), Arrays.asList("k2", 2))); Assertions.assertThat(result).isTrue(); }
|
### Question:
BasicObjectSerializer implements BeakerObjectConverter { @Override public boolean writeObject(Object obj, JsonGenerator jgen, boolean expand) throws IOException { if (obj == null) { jgen.writeNull(); } else if ((obj instanceof TableDisplay) || (obj instanceof EvaluationResult) || (obj instanceof UpdatableEvaluationResult) || (obj instanceof BeakerCodeCell) || (obj instanceof ImageIcon) || (obj instanceof Date) || (obj instanceof BeakerDashboard) || (obj instanceof BufferedImage) || (obj instanceof TabbedOutputContainerLayoutManager) || (obj instanceof GridOutputContainerLayoutManager) || (obj instanceof CyclingOutputContainerLayoutManager) || (obj instanceof DashboardLayoutManager) || (obj instanceof OutputContainerCell) || (obj instanceof OutputContainer) || (obj instanceof BeakerProgressUpdate) || (obj instanceof EasyForm) || (obj instanceof Color)) { logger.debug("basic object"); jgen.writeObject(obj); } else return runThreadSerializers(obj, jgen, expand) || runConfiguredSerializers(obj, jgen, expand); return true; } BasicObjectSerializer(); @Override String convertType(String tn); @Override boolean isPrimitiveType(String tn); @Override boolean writeObject(Object obj, JsonGenerator jgen, boolean expand); boolean runThreadSerializers(Object obj, JsonGenerator jgen, boolean expand); boolean runConfiguredSerializers(Object obj, JsonGenerator jgen, boolean expand); @Override Object deserialize(JsonNode n, ObjectMapper mapper); @Override void addTypeConversion(String from, String to); @Override void addTypeDeserializer(ObjectDeserializer o); @Override void addTypeSerializer(ObjectSerializer o); @Override void addfTypeDeserializer(ObjectDeserializer o); @Override void addfTypeSerializer(ObjectSerializer o); @Override void addThreadSpecificTypeConversion(String from, String to); @Override void addThreadSpecificTypeDeserializer(ObjectDeserializer o); @Override void addThreadSpecificTypeSerializer(ObjectSerializer o); @Override void addKnownBeakerType(String t); @Override boolean isKnownBeakerType(String t); static final String TYPE_INTEGER; static final String TYPE_LONG; static final String TYPE_BIGINT; static final String TYPE_DOUBLE; static final String TYPE_STRING; static final String TYPE_BOOLEAN; static final String TYPE_TIME; static final String TYPE_SELECT; }### Answer:
@Test public void serializeMap_returnTrue() throws Exception { Map<String, String> map = new HashMap<String, String>(){ { put("key", "value"); } }; boolean result = basicObjectSerializer.writeObject(map, jgen, true); Assertions.assertThat(result).isTrue(); }
@Test public void serializeArray_returnTrue() throws Exception { boolean result = basicObjectSerializer.writeObject( Arrays.asList("v1", "v2"), jgen, true); Assertions.assertThat(result).isTrue(); }
@Test public void serializeListOfList_returnTrue() throws Exception { boolean result = basicObjectSerializer.writeObject( Arrays.asList(Arrays.asList("k1", 1), Arrays.asList("k2", 2)), jgen, true); Assertions.assertThat(result).isTrue(); }
|
### Question:
CollectionDeserializer implements ObjectDeserializer { @Override public Object deserialize(JsonNode n, ObjectMapper mapper) { List<Object> o = new ArrayList<Object>(); try { logger.debug("using custom array deserializer"); for(int i=0; i<n.size(); i++) { o.add(parent.deserialize(n.get(i), mapper)); } } catch (Exception e) { logger.error("exception deserializing Collection ", e); o = null; } return o; } CollectionDeserializer(BeakerObjectConverter p); @Override boolean canBeUsed(JsonNode n); @Override Object deserialize(JsonNode n, ObjectMapper mapper); }### Answer:
@Test public void deserialize_resultObjectHasValues() throws Exception { ObjectMapper mapper = new ObjectMapper(); JsonNode actualObj = mapper.readTree("[\"1\",\"2\",\"3\"]"); CollectionDeserializer deserializer = new CollectionDeserializer(new BasicObjectSerializer()); List list = (List) deserializer.deserialize(actualObj, mapper); Assertions.assertThat(list).isNotNull(); Assertions.assertThat(list.size()).isEqualTo(3); }
|
### Question:
ColorDeserializer implements ObjectDeserializer { @Override public Object deserialize(JsonNode n, ObjectMapper mapper) { Object o = null; try { long i = Long.parseLong(n.asText().substring(1), 16); o = new Color((int)((i >> 16) & 0xFF), (int)((i >> 8) & 0xFF), (int)( i & 0xFF), (int)((i >> 24) & 0xFF)); } catch (Exception e) { logger.error("exception deserializing Color {}", e.getMessage()); } return o; } ColorDeserializer(BeakerObjectConverter p); @Override boolean canBeUsed(JsonNode n); @Override Object deserialize(JsonNode n, ObjectMapper mapper); }### Answer:
@Test public void deserialize_resultObjectHasColor() throws Exception { ObjectMapper mapper = new ObjectMapper(); JsonNode actualObj = mapper.readTree("\"#FF00FF00\""); ColorDeserializer deserializer = new ColorDeserializer(new BasicObjectSerializer()); Color color = (Color) deserializer.deserialize(actualObj, mapper); Assertions.assertThat(color).isNotNull(); Assertions.assertThat(color.getRGB()).isEqualTo(Color.GREEN.getRGB()); }
|
### Question:
UpdatableEvaluationResult extends Observable { public void setValue(Object o) { value = o; setChanged(); notifyObservers(); } UpdatableEvaluationResult(Object value); Object getValue(); void setValue(Object o); }### Answer:
@Test public void setValue_shouldNotifyObserver() throws Exception { UpdatableEvaluationResult result = new UpdatableEvaluationResult("test"); ObserverObjectTest observer = new ObserverObjectTest(); result.addObserver(observer); result.setValue("test"); Assertions.assertThat(observer.getObjectList().get(0)).isEqualTo(result); }
|
### Question:
SimpleEvaluationObject extends Observable { public synchronized void started() { setOutputHandler(); this.status = EvaluationStatus.RUNNING; setChanged(); notifyObservers(); } SimpleEvaluationObject(String e, final KernelFunctionality.ExecuteCodeCallback executeCodeCallback); void executeCodeCallback(); synchronized void started(); synchronized void finished(Object r); synchronized void error(Object r); synchronized void update(Object r); String getExpression(); synchronized EvaluationStatus getStatus(); synchronized Object getPayload(); void structuredUpdate(String message, int progress); synchronized BeakerOutputHandler getStdOutputHandler(); synchronized BeakerOutputHandler getStdErrorHandler(); void setOutputHandler(); void clrOutputHandler(); Message getJupyterMessage(); void setJupyterMessage(Message jupyterMessage); int getExecutionCount(); void setExecutionCount(int executionCount); Queue<ConsoleOutput> getConsoleOutput(); @Override String toString(); List<Object> getOutputdata(); void appendOutput(String s); void appendError(String s); }### Answer:
@Test public void seoStarted_shouldNotifyObserver() throws Exception { seo.started(); Assertions.assertThat(observer.getObjectList().get(0)).isEqualTo(seo); }
|
### Question:
SimpleEvaluationObject extends Observable { public synchronized void finished(Object r) { clrOutputHandler(); this.status = EvaluationStatus.FINISHED; payload = r; setChanged(); notifyObservers(); } SimpleEvaluationObject(String e, final KernelFunctionality.ExecuteCodeCallback executeCodeCallback); void executeCodeCallback(); synchronized void started(); synchronized void finished(Object r); synchronized void error(Object r); synchronized void update(Object r); String getExpression(); synchronized EvaluationStatus getStatus(); synchronized Object getPayload(); void structuredUpdate(String message, int progress); synchronized BeakerOutputHandler getStdOutputHandler(); synchronized BeakerOutputHandler getStdErrorHandler(); void setOutputHandler(); void clrOutputHandler(); Message getJupyterMessage(); void setJupyterMessage(Message jupyterMessage); int getExecutionCount(); void setExecutionCount(int executionCount); Queue<ConsoleOutput> getConsoleOutput(); @Override String toString(); List<Object> getOutputdata(); void appendOutput(String s); void appendError(String s); }### Answer:
@Test public void seoFinished_shouldNotifyObserver() throws Exception { seo.finished(new Object()); Assertions.assertThat(observer.getObjectList().get(0)).isEqualTo(seo); }
|
### Question:
GroovyKernelInfoHandler extends KernelHandler<Message> { @Override public void handle(Message message) { wrapBusyIdle(kernel, message, () -> { handleMsg(message); }); } GroovyKernelInfoHandler(KernelFunctionality kernel); @Override void handle(Message message); }### Answer:
@Test public void handle_shouldSendMessage() throws Exception { handler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); }
@Test public void handle_sentMessageHasContent() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sentMessage.getContent()).isNotEmpty(); }
@Test public void handle_sentMessageHasHeaderTypeIsKernelInfoReply() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Header header = sentMessage.getHeader(); Assertions.assertThat(header).isNotNull(); Assertions.assertThat(header.getType()).isEqualTo(KERNEL_INFO_REPLY.getName()); }
@Test public void handle_sentMessageHasLanguageInfo() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Map<String, Serializable> map = sentMessage.getContent(); Assertions.assertThat(map).isNotNull(); Assertions.assertThat(map.get("language_info")).isNotNull(); }
@Test public void handle_messageContentHasGroovyLabel() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Map<String, Serializable> map = sentMessage.getContent(); Assertions.assertThat(map).isNotNull(); Assertions.assertThat(map.get("implementation")).isEqualTo("groovy"); }
|
### Question:
SimpleEvaluationObject extends Observable { public synchronized void error(Object r) { clrOutputHandler(); this.status = EvaluationStatus.ERROR; payload = r; setChanged(); notifyObservers(); } SimpleEvaluationObject(String e, final KernelFunctionality.ExecuteCodeCallback executeCodeCallback); void executeCodeCallback(); synchronized void started(); synchronized void finished(Object r); synchronized void error(Object r); synchronized void update(Object r); String getExpression(); synchronized EvaluationStatus getStatus(); synchronized Object getPayload(); void structuredUpdate(String message, int progress); synchronized BeakerOutputHandler getStdOutputHandler(); synchronized BeakerOutputHandler getStdErrorHandler(); void setOutputHandler(); void clrOutputHandler(); Message getJupyterMessage(); void setJupyterMessage(Message jupyterMessage); int getExecutionCount(); void setExecutionCount(int executionCount); Queue<ConsoleOutput> getConsoleOutput(); @Override String toString(); List<Object> getOutputdata(); void appendOutput(String s); void appendError(String s); }### Answer:
@Test public void seoError_shouldNotifyObserver() throws Exception { seo.error(new Object()); Assertions.assertThat(observer.getObjectList().get(0)).isEqualTo(seo); }
|
### Question:
SimpleEvaluationObject extends Observable { public synchronized void update(Object r) { this.status = EvaluationStatus.RUNNING; payload = r; setChanged(); notifyObservers(); } SimpleEvaluationObject(String e, final KernelFunctionality.ExecuteCodeCallback executeCodeCallback); void executeCodeCallback(); synchronized void started(); synchronized void finished(Object r); synchronized void error(Object r); synchronized void update(Object r); String getExpression(); synchronized EvaluationStatus getStatus(); synchronized Object getPayload(); void structuredUpdate(String message, int progress); synchronized BeakerOutputHandler getStdOutputHandler(); synchronized BeakerOutputHandler getStdErrorHandler(); void setOutputHandler(); void clrOutputHandler(); Message getJupyterMessage(); void setJupyterMessage(Message jupyterMessage); int getExecutionCount(); void setExecutionCount(int executionCount); Queue<ConsoleOutput> getConsoleOutput(); @Override String toString(); List<Object> getOutputdata(); void appendOutput(String s); void appendError(String s); }### Answer:
@Test public void seoUpdate_shouldNotifyObserver() throws Exception { seo.update(new Object()); Assertions.assertThat(observer.getObjectList().get(0)).isEqualTo(seo); }
|
### Question:
SimpleEvaluationObject extends Observable { public synchronized BeakerOutputHandler getStdOutputHandler() { if (stdout == null) stdout = new SimpleOutputHandler(false); return stdout; } SimpleEvaluationObject(String e, final KernelFunctionality.ExecuteCodeCallback executeCodeCallback); void executeCodeCallback(); synchronized void started(); synchronized void finished(Object r); synchronized void error(Object r); synchronized void update(Object r); String getExpression(); synchronized EvaluationStatus getStatus(); synchronized Object getPayload(); void structuredUpdate(String message, int progress); synchronized BeakerOutputHandler getStdOutputHandler(); synchronized BeakerOutputHandler getStdErrorHandler(); void setOutputHandler(); void clrOutputHandler(); Message getJupyterMessage(); void setJupyterMessage(Message jupyterMessage); int getExecutionCount(); void setExecutionCount(int executionCount); Queue<ConsoleOutput> getConsoleOutput(); @Override String toString(); List<Object> getOutputdata(); void appendOutput(String s); void appendError(String s); }### Answer:
@Test public void beakerOutputHandlerWriteBytesWithLength_shouldNotifyObserver() throws Exception { BeakerOutputHandler handler = seo.getStdOutputHandler(); handler.write("test".getBytes(), 0, 2); Assertions.assertThat(observer.getObjectList().get(0)).isEqualTo(seo); }
@Test public void beakerOutputHandlerWriteInt_shouldNotifyObserver() throws Exception { BeakerOutputHandler handler = seo.getStdOutputHandler(); handler.write('t'); Assertions.assertThat(observer.getObjectList().get(0)).isEqualTo(seo); }
@Test public void beakerOutputHandlerWriteBytes_shouldNotifyObserver() throws Exception { BeakerOutputHandler handler = seo.getStdOutputHandler(); handler.write("test".getBytes()); Assertions.assertThat(observer.getObjectList().get(0)).isEqualTo(seo); }
|
### Question:
AbstractGridLayoutManager extends OutputContainerLayoutManager { public int getColumns() { return columns; } AbstractGridLayoutManager(int columns); int getColumns(); int getPaddingTop(); void setPaddingTop(int paddingTop); int getPaddingBottom(); void setPaddingBottom(int paddingBottom); int getPaddingLeft(); void setPaddingLeft(int paddingLeft); int getPaddingRight(); void setPaddingRight(int paddingRight); }### Answer:
@Test public void createManagerWithParam_columnsEqualsParam() throws Exception { int columns = 5; AbstractGridLayoutManager manager = new AbstractGridLayoutManager(columns); Assertions.assertThat(manager.getColumns()).isEqualTo(columns); }
|
### Question:
BeakerDashboard extends Observable { public dashRow newRow() { return new dashRow(); } BeakerDashboard(); String getTheStyle(); String getTheClass(); void setTheStyle(String s); void setTheClass(String s); List<dashRow> getRows(); void addRow(dashRow o); dashRow newRow(); dashColumn newColumn(int w); void clear(); void redraw(); final List<dashRow> content; }### Answer:
@Test public void newRow_createNewDashRow() throws Exception { BeakerDashboard.dashRow row = dashboard.newRow(); Assertions.assertThat(row).isNotNull(); }
|
### Question:
BeakerDashboard extends Observable { public dashColumn newColumn(int w) { return new dashColumn(w); } BeakerDashboard(); String getTheStyle(); String getTheClass(); void setTheStyle(String s); void setTheClass(String s); List<dashRow> getRows(); void addRow(dashRow o); dashRow newRow(); dashColumn newColumn(int w); void clear(); void redraw(); final List<dashRow> content; }### Answer:
@Test public void newColumn_createNewColumnWithWidth() throws Exception { int width = 5; BeakerDashboard.dashColumn dashColumn = dashboard.newColumn(width); Assertions.assertThat(dashColumn).isNotNull(); Assertions.assertThat(dashColumn.getWidth()).isEqualTo(width); }
|
### Question:
BeakerDashboard extends Observable { public void redraw() { setChanged(); notifyObservers(); } BeakerDashboard(); String getTheStyle(); String getTheClass(); void setTheStyle(String s); void setTheClass(String s); List<dashRow> getRows(); void addRow(dashRow o); dashRow newRow(); dashColumn newColumn(int w); void clear(); void redraw(); final List<dashRow> content; }### Answer:
@Test public void redraw_shouldUpdateObservers() throws Exception { ObserverObjectTest observer = new ObserverObjectTest(); dashboard.addObserver(observer); dashboard.redraw(); Assertions.assertThat(observer.getObjectList()).isNotEmpty(); Assertions.assertThat(observer.getObjectList().get(0)).isEqualTo(dashboard); }
|
### Question:
OutputContainer { public List<Object> getItems() { return items; } OutputContainer(); OutputContainer(List<Object> items); OutputContainer(List<Object> items, List<String> labels); void addItem(java.lang.Object item); void addItem(java.lang.Object item, int index); void addItem(java.lang.Object item, int index, java.lang.String label); void addItem(Object item, String label); void removeItem(int index); OutputContainer leftShift(Object item); void removeItem(Object itemToRemove); List<Object> getItems(); List<String> getLabels(); void visit(CellVisitor visitor); OutputContainerLayoutManager getLayoutManager(); void setLayoutManager(OutputContainerLayoutManager layoutManager); final static Logger LOGGER; }### Answer:
@Test public void createWithItemsParam_hasThoseItems() throws Exception { List<Object> items = Arrays.asList(Boolean.FALSE, Integer.MAX_VALUE); OutputContainer container = new OutputContainer(items); Assertions.assertThat(container.getItems()).isEqualTo(items); }
|
### Question:
ProgressReporting { public void structuredUpdate(String message, int progress) { if (progressBar == null) { progressBar = new IntProgress(); progressBar.display(); } progressBar.setValue(progress); progressBar.setDescription(message); } void structuredUpdate(String message, int progress); void close(); }### Answer:
@Test public void structuredUpdate_shouldPublishMessages() throws Exception { progress.structuredUpdate("msg", 5); Assertions.assertThat(groovyKernel.getPublishedMessages()).isNotEmpty(); }
|
### Question:
EvaluationResult { public Object getValue() { return value; } EvaluationResult(Object v); Object getValue(); }### Answer:
@Test public void createManagerWithParam_valueEqualsThatParam() throws Exception { EvaluationResult result = new EvaluationResult(new Integer(123)); Assertions.assertThat(result.getValue()).isEqualTo(123); }
|
### Question:
DynamicClassLoaderSimple extends ClassLoader { public Class<?> loadClass(String name) throws ClassNotFoundException { try { return getParent().loadClass(name); } catch (ClassNotFoundException cnfe) { } if(!name.startsWith("java")) { String cname = formatClassName(name); String fname = outDir + cname; File f = new File(fname); if (f.exists() && f.isFile()) { FileInputStream fis; try { fis = new FileInputStream(f); byte[] bytes = ByteStreams.toByteArray(fis); Class<?> result = getClass(name, bytes, true); if (result != null) { return result; } } catch (Exception e) { e.printStackTrace(); } } if (myloader != null) { Class<?> result = classes.get( name ); if (result != null) { return result; } InputStream is = myloader.getResourceAsStream(cname); if (is != null) { try { byte[] bytes = ByteStreams.toByteArray(is); result = getClass(name, bytes, true); if (result != null) { classes.put( name, result ); return result; } } catch (Exception e) { e.printStackTrace(); } } } } throw new ClassNotFoundException(); } DynamicClassLoaderSimple(ClassLoader classLoader); void addJars(List<String> dirs); void addDynamicDir(String o); Class<?> loadClass(String name); URL getResource(String name); InputStream getResourceAsStream(String name); Enumeration<URL> getResources(String name); }### Answer:
@Test public void loadClassWithNameParam_returnClass() throws Exception { Class clazz = loader.loadClass(className); Assertions.assertThat(clazz).isNotNull(); }
|
### Question:
DynamicClassLoaderSimple extends ClassLoader { public URL getResource(String name) { URL c; c = getParent().getResource(name); if (c == null && myloader != null) { c = myloader.getResource(name); } return c; } DynamicClassLoaderSimple(ClassLoader classLoader); void addJars(List<String> dirs); void addDynamicDir(String o); Class<?> loadClass(String name); URL getResource(String name); InputStream getResourceAsStream(String name); Enumeration<URL> getResources(String name); }### Answer:
@Test public void getResourceWithNameParam_returnURL() throws Exception { URL url = loader.getResource(fileName); Assertions.assertThat(url).isNotNull(); }
|
### Question:
DynamicClassLoaderSimple extends ClassLoader { public InputStream getResourceAsStream(String name) { InputStream c; c = getParent().getResourceAsStream(name); if (c == null && myloader != null) { c = myloader.getResourceAsStream(name); } return c; } DynamicClassLoaderSimple(ClassLoader classLoader); void addJars(List<String> dirs); void addDynamicDir(String o); Class<?> loadClass(String name); URL getResource(String name); InputStream getResourceAsStream(String name); Enumeration<URL> getResources(String name); }### Answer:
@Test public void getResourceAsStreamWithNameParam_returnInputStream() throws Exception { InputStream is = loader.getResourceAsStream(fileName); Assertions.assertThat(is).isNotNull(); }
|
### Question:
DynamicClassLoaderSimple extends ClassLoader { public Enumeration<URL> getResources(String name) throws IOException { Enumeration<URL> c; c = getParent().getResources(name); if ((c == null || !c.hasMoreElements()) && myloader != null) { try { c = myloader.getResources(name); } catch(IOException e) { } } return c; } DynamicClassLoaderSimple(ClassLoader classLoader); void addJars(List<String> dirs); void addDynamicDir(String o); Class<?> loadClass(String name); URL getResource(String name); InputStream getResourceAsStream(String name); Enumeration<URL> getResources(String name); }### Answer:
@Test public void getResourcesWithNameParam_returnURLs() throws Exception { Enumeration<URL> urls = loader.getResources(fileName); Assertions.assertThat(urls).isNotNull(); }
|
### Question:
ClassUtils { protected Class<?> getClass(String name) throws ClassNotFoundException { try { if(loader!=null) return loader.loadClass(name); return Class.forName(name); } catch(Exception e) { return null; } } ClassUtils(ClassLoader l); ClassUtils(); void clear(); void defineVariable(String name, String type); String getVariableType(String name); void defineClassShortName(String name, String fqname); AutocompleteCandidate expandExpression(String txt, AutocompleteRegistry registry, int type); final int DO_STATIC; final int DO_NON_STATIC; final int DO_ALL; }### Answer:
@Test public void getClass_returnClass() throws ClassNotFoundException { ClassUtils classUtils = new ClassUtils(); Assertions.assertThat(classUtils.getClass("java.lang.Boolean")).isNotNull(); }
@Test public void getClassByLoader_returnClass() throws ClassNotFoundException { ClassLoader classLoader = getClass().getClassLoader(); ClassUtils classUtils = new ClassUtils(classLoader); Assertions.assertThat(classUtils.getClass("java.lang.Boolean")).isNotNull(); }
|
### Question:
AutocompleteCandidate { public List<AutocompleteCandidate> getChildrens() { return children; } AutocompleteCandidate(int t, String k); AutocompleteCandidate(int t, String [] k); AutocompleteCandidate(int t, String[] k, int max); AutocompleteCandidate clone(); void addChildren(AutocompleteCandidate a); int getType(); String getKey(); boolean hasChildren(); List<AutocompleteCandidate> getChildrens(); void addChildrens(List<AutocompleteCandidate> chs); void searchCandidates(List<String> ret, AutocompleteCandidate a); AutocompleteCandidate findLeaf(); }### Answer:
@Test public void createWithTypeAndKey_hasChildrenIsNull(){ AutocompleteCandidate aCandidate = new AutocompleteCandidate(1, "key"); Assertions.assertThat(aCandidate.getChildrens()).isNull(); }
@Test public void createWithMaxNumKeysIsTwo_hasOneElementOfChildrens(){ AutocompleteCandidate aCandidate = new AutocompleteCandidate(1, keys, 2); Assertions.assertThat(aCandidate.getChildrens()).isNotEmpty(); AutocompleteCandidate child = aCandidate.getChildrens().get(0); Assertions.assertThat(child.getChildrens()).isNull(); }
|
### Question:
EvaluatorManager { public synchronized void setShellOptions(final KernelParameters kernelParameters) { try { evaluator.setShellOptions(kernelParameters); } catch (IOException e) { logger.error("Error while setting Shell Options", e); } evaluator.startWorker(); } EvaluatorManager(KernelFunctionality kernel, Evaluator evaluator); synchronized void setShellOptions(final KernelParameters kernelParameters); AutocompleteResult autocomplete(String code, int caretPosition); synchronized void killAllThreads(); synchronized SimpleEvaluationObject executeCode(String code, Message message, int executionCount, KernelFunctionality.ExecuteCodeCallback executeCodeCallback); void exit(); static Logger logger; }### Answer:
@Test public void setShellOptions_callEvaluatorToStartWorker() throws Exception { evaluator.clearStartWorkerFlag(); evaluatorManager.setShellOptions(new KernelParameters(new HashedMap())); Assertions.assertThat(evaluator.isCallStartWorker()).isTrue(); }
|
### Question:
EvaluatorManager { public synchronized void killAllThreads() { evaluator.killAllThreads(); } EvaluatorManager(KernelFunctionality kernel, Evaluator evaluator); synchronized void setShellOptions(final KernelParameters kernelParameters); AutocompleteResult autocomplete(String code, int caretPosition); synchronized void killAllThreads(); synchronized SimpleEvaluationObject executeCode(String code, Message message, int executionCount, KernelFunctionality.ExecuteCodeCallback executeCodeCallback); void exit(); static Logger logger; }### Answer:
@Test public void killAllThreads_callEvaluatorToKillAllThreads() throws Exception { evaluatorManager.killAllThreads(); Assertions.assertThat(evaluator.isCallKillAllThreads()).isTrue(); }
|
### Question:
EvaluatorManager { public void exit() { evaluator.exit(); } EvaluatorManager(KernelFunctionality kernel, Evaluator evaluator); synchronized void setShellOptions(final KernelParameters kernelParameters); AutocompleteResult autocomplete(String code, int caretPosition); synchronized void killAllThreads(); synchronized SimpleEvaluationObject executeCode(String code, Message message, int executionCount, KernelFunctionality.ExecuteCodeCallback executeCodeCallback); void exit(); static Logger logger; }### Answer:
@Test public void exit_callEvaluatorToExit() throws Exception { evaluatorManager.exit(); Assertions.assertThat(evaluator.isCallExit()).isTrue(); }
|
### Question:
EvaluatorManager { public synchronized SimpleEvaluationObject executeCode(String code, Message message, int executionCount, KernelFunctionality.ExecuteCodeCallback executeCodeCallback) { SimpleEvaluationObject seo = new SimpleEvaluationObject(code, executeCodeCallback); seo.setJupyterMessage(message); seo.setExecutionCount(executionCount); seo.addObserver(kernel.getExecutionResultSender()); evaluator.evaluate(seo, code); return seo; } EvaluatorManager(KernelFunctionality kernel, Evaluator evaluator); synchronized void setShellOptions(final KernelParameters kernelParameters); AutocompleteResult autocomplete(String code, int caretPosition); synchronized void killAllThreads(); synchronized SimpleEvaluationObject executeCode(String code, Message message, int executionCount, KernelFunctionality.ExecuteCodeCallback executeCodeCallback); void exit(); static Logger logger; }### Answer:
@Test public void executeCode_callEvaluatorToEvaluate(){ String code = "test code"; evaluatorManager.executeCode(code, new Message(), 5, new ExecuteCodeCallbackTest()); Assertions.assertThat(evaluator.getCode()).isEqualTo(code); }
|
### Question:
LegendPosition implements java.io.Serializable { public Position getPosition() { return position; } LegendPosition(); LegendPosition(Position position); LegendPosition(int[] coordinates); Position getPosition(); void setPosition(Position position); int getX(); void setX(int x); int getY(); void setY(int y); final static LegendPosition TOP; final static LegendPosition LEFT; final static LegendPosition BOTTOM; final static LegendPosition RIGHT; final static LegendPosition TOP_LEFT; final static LegendPosition TOP_RIGHT; final static LegendPosition BOTTOM_LEFT; final static LegendPosition BOTTOM_RIGHT; }### Answer:
@Test public void createLegendPositionByEmptyConstructor_hasPositionIsNotNull() { LegendPosition legendPosition = new LegendPosition(); Assertions.assertThat(legendPosition.getPosition()).isNotNull(); }
@Test public void createLegendPositionWithLeftPositionParam_hasLeftPosition() { LegendPosition legendPosition = new LegendPosition(LegendPosition.Position.LEFT); Assertions.assertThat(legendPosition.getPosition()).isEqualTo(LegendPosition.Position.LEFT); }
|
### Question:
ChartUtils { public static List<Object> convertColors(List colors, String errorMsg) { List<Object> clist = new ArrayList<>(colors.size()); for(Object c : colors){ if (c instanceof Color) { clist.add(c); } else if (c instanceof java.awt.Color) { clist.add(new Color((java.awt.Color) c)); } else if (c instanceof List) { clist.add(convertColors((List)c, errorMsg)); } else { throw new IllegalArgumentException(errorMsg); } } return clist; } static List<Object> convertColors(List colors, String errorMsg); }### Answer:
@Test public void callConvertColorsWithAwtColorListParam_shouldReturnBeakerChartColorList() { List<Object> outlineColors = ChartUtils.convertColors( Arrays.asList(java.awt.Color.BLACK, java.awt.Color.GREEN), "takes Color or List of Color"); Assertions.assertThat(outlineColors.get(0) instanceof Color).isTrue(); Assertions.assertThat(outlineColors.get(1) instanceof Color).isTrue(); }
@Test(expected = IllegalArgumentException.class) public void callConvertColorsWithNumberListParam_throwIllegalArgumentException() { ChartUtils.convertColors(Arrays.asList(100, 200), "takes Color or List of Color"); }
|
### Question:
AreaSerializer extends BasedXYGraphicsSerializer<Area> { @Override public void serialize(Area area, JsonGenerator jgen, SerializerProvider sp) throws IOException, JsonProcessingException { jgen.writeStartObject(); super.serialize(area, jgen, sp); if (area.getColor() instanceof Color) { jgen.writeObjectField("color", area.getColor()); } if (area.getInterpolation() != null) { jgen.writeObjectField("interpolation", area.getInterpolation()); } jgen.writeEndObject(); } @Override void serialize(Area area, JsonGenerator jgen, SerializerProvider sp); }### Answer:
@Test public void serializeInterpolationArea_resultJsonHasInterpolation() throws IOException { Area area = new Area(); area.setInterpolation(1); areaSerializer.serialize(area, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("interpolation")).isTrue(); Assertions.assertThat(actualObj.get("interpolation").asInt()).isEqualTo(1); }
@Test public void serializeColorArea_resultJsonHasColor() throws IOException { Area area = new Area(); area.setColor(Color.GREEN); areaSerializer.serialize(area, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("color")).isTrue(); Assertions.assertThat(actualObj.get("color").get("rgb").asInt()) .isEqualTo(Color.GREEN.getRGB()); }
|
### Question:
StemsSerializer extends BasedXYGraphicsSerializer<Stems> { @Override public void serialize(Stems stems, JsonGenerator jgen, SerializerProvider sp) throws IOException, JsonProcessingException { jgen.writeStartObject(); super.serialize(stems, jgen, sp); if (stems.getColors() != null) { jgen.writeObjectField("colors", stems.getColors()); } else { jgen.writeObjectField("color", stems.getColor()); } if (stems.getWidth() != null) { jgen.writeObjectField("width", stems.getWidth()); } if (stems.getStyles() != null) { jgen.writeObjectField("styles", stems.getStyles()); } else { jgen.writeObjectField("style", stems.getStyle().toString()); } jgen.writeEndObject(); } @Override void serialize(Stems stems, JsonGenerator jgen, SerializerProvider sp); }### Answer:
@Test public void serializeColorsStems_resultJsonHasColors() throws IOException { Stems stems = new Stems(); stems.setColor(Arrays.asList(Color.BLUE, Color.GREEN, Color.BLACK)); stemsSerializer.serialize(stems, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("colors")).isTrue(); ArrayNode arrayNode = (ArrayNode) actualObj.get("colors"); Assertions.assertThat(arrayNode.get(1).get("rgb").asInt()).isEqualTo(Color.GREEN.getRGB()); }
@Test public void serializeColorStems_resultJsonHasColor() throws IOException { Stems stems = new Stems(); stems.setColor(Color.GREEN); stemsSerializer.serialize(stems, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("color")).isTrue(); Assertions.assertThat(actualObj.get("color").get("rgb").asInt()) .isEqualTo(Color.GREEN.getRGB()); }
@Test public void serializeWidthStems_resultJsonHasWidth() throws IOException { Stems stems = new Stems(); stems.setWidth(11f); stemsSerializer.serialize(stems, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("width")).isTrue(); Assertions.assertThat(actualObj.get("width").asInt()).isEqualTo(11); }
@Test public void serializeStrokeTypeStems_resultJsonHasStyle() throws IOException { Stems stems = new Stems(); stems.setStyle(StrokeType.SOLID); stemsSerializer.serialize(stems, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("style")).isTrue(); Assertions.assertThat(actualObj.get("style").asText()).isEqualTo("SOLID"); }
@Test public void serializeStrokeTypeListStems_resultJsonHasStyles() throws IOException { Stems stems = new Stems(); stems.setStyle(Arrays.asList(StrokeType.SOLID, StrokeType.DASHDOT)); stemsSerializer.serialize(stems, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("styles")).isTrue(); ArrayNode arrayNode = (ArrayNode) actualObj.get("styles"); Assertions.assertThat(arrayNode.get(1).asText()).isEqualTo("DASHDOT"); }
|
### Question:
CategoryStemsSerializer extends CategoryGraphicsSerializer<CategoryStems> { @Override public void serialize(CategoryStems categoryStems, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { jgen.writeStartObject(); super.serialize(categoryStems, jgen, provider); if (categoryStems.getBases() != null) { jgen.writeObjectField("bases", categoryStems.getBases()); } else { jgen.writeObjectField("base", categoryStems.getBase()); } if (categoryStems.getWidth() != null) { jgen.writeObjectField("width", categoryStems.getWidth()); } if (categoryStems.getStyles() != null) { jgen.writeObjectField("styles", categoryStems.getStyles()); } else { jgen.writeObjectField("style", categoryStems.getStyle().toString()); } jgen.writeEndObject(); } @Override void serialize(CategoryStems categoryStems,
JsonGenerator jgen,
SerializerProvider provider); }### Answer:
@Test public void serializeBasesCategoryStems_resultJsonHasBases() throws IOException { CategoryStems categoryStems = new CategoryStems(); categoryStems.setBase(Arrays.asList(11, 22, 33)); categoryStemsSerializer.serialize(categoryStems, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("bases")).isTrue(); ArrayNode arrayNode = (ArrayNode) actualObj.get("bases"); Assertions.assertThat(arrayNode.get(1).asInt()).isEqualTo(22); }
@Test public void serializeBaseCategoryStems_resultJsonHasBase() throws IOException { CategoryStems categoryStems = new CategoryStems(); categoryStems.setBase(11); categoryStemsSerializer.serialize(categoryStems, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("base")).isTrue(); Assertions.assertThat(actualObj.get("base").asInt()).isEqualTo(11); }
@Test public void serializeWidthCategoryStems_resultJsonHasWidth() throws IOException { CategoryStems categoryStems = new CategoryStems(); categoryStems.setWidth(11f); categoryStemsSerializer.serialize(categoryStems, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("width")).isTrue(); Assertions.assertThat(actualObj.get("width").asInt()).isEqualTo(11); }
@Test public void serializeStrokeTypeCategoryStems_resultJsonHasStyle() throws IOException { CategoryStems categoryStems = new CategoryStems(); categoryStems.setStyle(StrokeType.SOLID); categoryStemsSerializer.serialize(categoryStems, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("style")).isTrue(); Assertions.assertThat(actualObj.get("style").asText()).isEqualTo("SOLID"); }
@Test public void serializeStrokeTypeListCategoryStems_resultJsonHasStyles() throws IOException { CategoryStems categoryStems = new CategoryStems(); categoryStems.setStyle(Arrays.asList(StrokeType.SOLID, StrokeType.DASHDOT)); categoryStemsSerializer.serialize(categoryStems, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("styles")).isTrue(); ArrayNode arrayNode = (ArrayNode) actualObj.get("styles"); Assertions.assertThat(arrayNode.get(1).asText()).isEqualTo("DASHDOT"); }
|
### Question:
LineSerializer extends XYGraphicsSerializer<Line> { @Override public void serialize(Line line, JsonGenerator jgen, SerializerProvider sp) throws IOException, JsonProcessingException { jgen.writeStartObject(); super.serialize(line, jgen, sp); if (line.getLodFilter() != null) jgen.writeObjectField("lod_filter", line.getLodFilter().getText()); if (line.getColor() instanceof Color) { jgen.writeObjectField("color", line.getColor()); } if (line.getWidth() != null) { jgen.writeObjectField("width", line.getWidth()); } if (line.getStyle() != null) { jgen.writeObjectField("style", line.getStyle().toString()); } if (line.getInterpolation() != null) { jgen.writeObjectField("interpolation", line.getInterpolation()); } jgen.writeEndObject(); } @Override void serialize(Line line, JsonGenerator jgen, SerializerProvider sp); }### Answer:
@Test public void serializeWidthLine_resultJsonHasWidth() throws IOException { Line line = new Line(); line.setWidth(1f); lineSerializer.serialize(line, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("width")).isTrue(); Assertions.assertThat(actualObj.get("width").asDouble()).isEqualTo(1.0); }
@Test public void serializeColorLine_resultJsonHasColor() throws IOException { Line line = new Line(); line.setColor(Color.GREEN); lineSerializer.serialize(line, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("color")).isTrue(); Assertions.assertThat(actualObj.get("color").get("rgb").asInt()) .isEqualTo(Color.GREEN.getRGB()); }
@Test public void serializeStrokeTypeLine_resultJsonHasStyle() throws IOException { Line line = new Line(); line.setStyle(StrokeType.SOLID); lineSerializer.serialize(line, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("style")).isTrue(); Assertions.assertThat(actualObj.get("style").asText()).isEqualTo("SOLID"); }
@Test public void serializeInterpolationLine_resultJsonHasInterpolation() throws IOException { Line line = new Line(); line.setInterpolation(1); lineSerializer.serialize(line, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("interpolation")).isTrue(); Assertions.assertThat(actualObj.get("interpolation").asInt()).isEqualTo(1); }
@Test public void serializeLodFilterLine_resultJsonHasLodFilter() throws IOException { Line line = new Line(); line.setLodFilter(Filter.LINE); lineSerializer.serialize(line, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("lod_filter")).isTrue(); Assertions.assertThat(actualObj.get("lod_filter").asText()).isEqualTo("line"); }
|
### Question:
BasedXYGraphicsSerializer extends XYGraphicsSerializer<T> { @Override public void serialize(T basedXYGraphics, JsonGenerator jgen, SerializerProvider sp) throws IOException, JsonProcessingException { super.serialize(basedXYGraphics, jgen, sp); if (basedXYGraphics.getBases() != null) { jgen.writeObjectField("bases", basedXYGraphics.getBases()); } else { jgen.writeObjectField("base", basedXYGraphics.getBase()); } } @Override void serialize(T basedXYGraphics, JsonGenerator jgen, SerializerProvider sp); }### Answer:
@Test public void serializeBasesOfBasedXYGraphics_resultJsonHasBases() throws IOException { Area area = new Area(); area.setBase(Arrays.asList(11, 22, 33)); basedXYGraphicsSerializer.serialize(area, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("bases")).isTrue(); ArrayNode arrayNode = (ArrayNode) actualObj.get("bases"); Assertions.assertThat(arrayNode.get(1).asInt()).isEqualTo(22); }
@Test public void serializeBaseOfBasedXYGraphics_resultJsonHasBase() throws IOException { Area area = new Area(); area.setBase(11); basedXYGraphicsSerializer.serialize(area, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("base")).isTrue(); Assertions.assertThat(actualObj.get("base").asInt()).isEqualTo(11); }
|
### Question:
SQLEvaluator implements Evaluator { public void evaluate(SimpleEvaluationObject seo, String code) { jobQueue.add(new JobDescriptor(code, seo)); syncObject.release(); } SQLEvaluator(String id, String sId); void evaluate(SimpleEvaluationObject seo, String code); @Override void startWorker(); void exit(); void killAllThreads(); @Override AutocompleteResult autocomplete(String code, int caretPosition); @Override void setShellOptions(final KernelParameters kernelParameters); void setShellUserPassword(String namedConnection, String user, String password); List<ConnectionStringBean> getListOfConnectiononWhoNeedDialog(); }### Answer:
@Test public void evaluateSql() throws Exception { SimpleEvaluationObject seo = new SimpleEvaluationObject(CREATE_AND_SELECT_ALL, new ExecuteCodeCallbackTest()); sqlEvaluator.evaluate(seo, CREATE_AND_SELECT_ALL); waitForResult(seo); verifyResult(seo); }
|
### Question:
CppKernelInfoHandler extends KernelHandler<Message> { @Override public void handle(Message message) { logger.debug("Processing Cpp kernel info request"); Message reply = new Message(); HashMap<String, Serializable> map = new HashMap<>(6); map.put("protocol_version", "5.0"); map.put("implementation", "cpp"); map.put("implementation_version", "1.0.0"); HashMap<String, Serializable> map1 = new HashMap<String, Serializable>(7); map1.put("name", "cpp"); map1.put("version", ""); map1.put("mimetype", ""); map1.put("file_extension", ".cpp"); map1.put("codemirror_mode", "C++"); map1.put("nbconverter_exporter", ""); map.put("language_info", map1); map.put("banner", "BeakerX kernel for C++"); map.put("beakerx", true); map.put("help_links", new ArrayList<String>()); reply.setContent(map); reply.setHeader(new Header(KERNEL_INFO_REPLY, message.getHeader().getSession())); reply.setParentHeader(message.getHeader()); reply.setIdentities(message.getIdentities()); send(reply); } CppKernelInfoHandler(KernelFunctionality kernel); @Override void handle(Message message); }### Answer:
@Test public void handle_shouldSendMessage() throws Exception { handler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); }
@Test public void handle_sentMessageHasContent() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sentMessage.getContent()).isNotEmpty(); }
@Test public void handle_sentMessageHasHeaderTypeIsKernelInfoReply() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Header header = sentMessage.getHeader(); Assertions.assertThat(header).isNotNull(); Assertions.assertThat(header.getType()).isEqualTo(KERNEL_INFO_REPLY.getName()); }
@Test public void handle_sentMessageHasLanguageInfo() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Map<String, Serializable> map = sentMessage.getContent(); Assertions.assertThat(map).isNotNull(); Assertions.assertThat(map.get("language_info")).isNotNull(); }
@Test public void handle_messageContentHasCppLabel() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Map<String, Serializable> map = sentMessage.getContent(); Assertions.assertThat(map).isNotNull(); Assertions.assertThat(map.get("implementation")).isEqualTo("cpp"); }
|
### Question:
ColorSerializer extends JsonSerializer<Color> { @Override public void serialize(Color color, JsonGenerator jgen, SerializerProvider sp) throws IOException, JsonProcessingException { synchronized(color) { jgen.writeString(String.format("#%x", color.getRGB()).toUpperCase()); } } @Override void serialize(Color color, JsonGenerator jgen, SerializerProvider sp); }### Answer:
@Test public void serializeColor_resultJsonHasColor() throws IOException { colorSerializer.serialize(Color.GREEN, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.asText()).isEqualTo("#FF00FF00"); }
|
### Question:
JavaKernelInfoHandler extends KernelHandler<Message> { @Override public void handle(Message message) { logger.debug("Processing kernel info request"); Message reply = new Message(); HashMap<String, Serializable> map = new HashMap<>(6); map.put("protocol_version", "5.0"); map.put("implementation", "java"); map.put("implementation_version", "1.0.0"); HashMap<String, Serializable> map1 = new HashMap<String, Serializable>(7); map1.put("name", "Java"); map1.put("version", System.getProperty("java.version")); map1.put("mimetype", ""); map1.put("file_extension", ".java"); map1.put("codemirror_mode", "text/x-java"); map1.put("nbconverter_exporter", ""); map.put("language_info", map1); map.put("banner", "BeakerX kernel for Java"); map.put("beakerx", true); map.put("help_links", new ArrayList<String>()); reply.setContent(map); reply.setHeader(new Header(KERNEL_INFO_REPLY, message.getHeader().getSession())); reply.setParentHeader(message.getHeader()); reply.setIdentities(message.getIdentities()); send(reply); } JavaKernelInfoHandler(KernelFunctionality kernel); @Override void handle(Message message); }### Answer:
@Test public void handle_shouldSendMessage() throws Exception { handler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); }
@Test public void handle_sentMessageHasContent() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sentMessage.getContent()).isNotEmpty(); }
@Test public void handle_sentMessageHasHeaderTypeIsKernelInfoReply() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Header header = sentMessage.getHeader(); Assertions.assertThat(header).isNotNull(); Assertions.assertThat(header.getType()).isEqualTo(KERNEL_INFO_REPLY.getName()); }
@Test public void handle_sentMessageHasLanguageInfo() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Map<String, Serializable> map = sentMessage.getContent(); Assertions.assertThat(map).isNotNull(); Assertions.assertThat(map.get("language_info")).isNotNull(); }
@Test public void handle_messageContentHasJavaLabel() throws Exception { handler.handle(message); Message sentMessage = kernel.getSentMessages().get(0); Map<String, Serializable> map = sentMessage.getContent(); Assertions.assertThat(map).isNotNull(); Assertions.assertThat(map.get("implementation")).isEqualTo("java"); }
|
### Question:
CategoryPlotSerializer extends AbstractChartSerializer<CategoryPlot> { @Override public void serialize(CategoryPlot categoryPlot, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { jgen.writeStartObject(); serialize(categoryPlot, jgen); List<String> categoryNames = categoryPlot.getCategoryNames(); if (categoryNames != null) { jgen.writeObjectField("categoryNames", categoryNames); } List<CategoryGraphics> categoryGraphicsList = categoryPlot.getGraphics(); if (categoryGraphicsList != null) { for (CategoryGraphics categoryGraphics : categoryGraphicsList) { categoryGraphics.createItemLabels(categoryPlot); } jgen.writeObjectField(GRAPHICS_LIST, categoryGraphicsList); } jgen.writeObjectField("orientation", categoryPlot.getOrientation()); jgen.writeObjectField("category_margin", categoryPlot.getCategoryMargin()); jgen.writeObjectField("categoryNamesLabelAngle", categoryPlot.getCategoryNamesLabelAngle()); jgen.writeEndObject(); } @Override void serialize(CategoryPlot categoryPlot, JsonGenerator jgen, SerializerProvider provider); static final String GRAPHICS_LIST; }### Answer:
@Test public void serializeCategoryNamesOfCategoryPlot_resultJsonHasCategoryNames() throws IOException { CategoryPlot categoryPlot = new CategoryPlot(); categoryPlot.setCategoryNames(Arrays.asList("name1", "name2")); categoryPlotSerializer.serialize(categoryPlot, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("categoryNames")).isTrue(); ArrayNode arrayNode = (ArrayNode) actualObj.get("categoryNames"); Assertions.assertThat(arrayNode.get(1).asText()).isEqualTo("name2"); }
@Test public void serializeGraphicsListCategoryPlot_resultJsonHasGraphicsList() throws IOException { CategoryPlot categoryPlot = new CategoryPlot(); categoryPlot.add(Arrays.asList(new CategoryBars(), new CategoryPoints())); categoryPlotSerializer.serialize(categoryPlot, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("graphics_list")).isTrue(); ArrayNode arrayNode = (ArrayNode) actualObj.get("graphics_list"); Assertions.assertThat(arrayNode.size()).isEqualTo(2); }
@Test public void serializeOrientationCategoryPlot_resultJsonHasOrientation() throws IOException { CategoryPlot categoryPlot = new CategoryPlot(); categoryPlot.setOrientation(PlotOrientationType.VERTICAL); categoryPlotSerializer.serialize(categoryPlot, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("orientation")).isTrue(); Assertions.assertThat(actualObj.get("orientation").asText()).isEqualTo("VERTICAL"); }
@Test public void serializeCategoryMarginOfCategoryPlot_resultJsonHasCategoryMargin() throws IOException { CategoryPlot categoryPlot = new CategoryPlot(); categoryPlot.setCategoryMargin(0.5); categoryPlotSerializer.serialize(categoryPlot, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("category_margin")).isTrue(); Assertions.assertThat(actualObj.get("category_margin").asDouble()).isEqualTo(0.5); }
@Test public void serializeCategoryNamesLabelAngleOfCategoryPlot_resultJsonHasCategoryNamesLabelAngle() throws IOException { CategoryPlot categoryPlot = new CategoryPlot(); categoryPlot.setCategoryNamesLabelAngle(0.5); categoryPlotSerializer.serialize(categoryPlot, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("categoryNamesLabelAngle")).isTrue(); Assertions.assertThat(actualObj.get("categoryNamesLabelAngle").asDouble()).isEqualTo(0.5); }
|
### Question:
CrosshairSerializer extends JsonSerializer<Crosshair> { @Override public void serialize(Crosshair crosshair, JsonGenerator jgen, SerializerProvider sp) throws IOException, JsonProcessingException { jgen.writeStartObject(); jgen.writeObjectField("type", crosshair.getClass().getSimpleName()); if (crosshair.getColor() instanceof Color) { jgen.writeObjectField("color", crosshair.getColor()); } if (crosshair.getStyle() != null) { jgen.writeObjectField("style", crosshair.getStyle().toString()); } if (crosshair.getWidth() != null) { jgen.writeObjectField("width", crosshair.getWidth()); } jgen.writeEndObject(); } @Override void serialize(Crosshair crosshair, JsonGenerator jgen, SerializerProvider sp); }### Answer:
@Test public void serializeCrosshair_resultJsonHasType() throws IOException { Crosshair crosshair = new Crosshair(); crosshairSerializer.serialize(crosshair, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("type")).isTrue(); Assertions.assertThat(actualObj.get("type").asText()).isEqualTo("Crosshair"); }
@Test public void serializeColorCrosshair_resultJsonHasColor() throws IOException { Crosshair crosshair = new Crosshair(); crosshair.setColor(Color.GREEN); crosshairSerializer.serialize(crosshair, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("color")).isTrue(); Assertions.assertThat(actualObj.get("color").get("rgb").asInt()) .isEqualTo(Color.GREEN.getRGB()); }
@Test public void serializeStyleCrosshair_resultJsonHasStyle() throws IOException { Crosshair crosshair = new Crosshair(); crosshair.setStyle(StrokeType.DASH); crosshairSerializer.serialize(crosshair, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("style")).isTrue(); Assertions.assertThat(actualObj.get("style").asText()).isEqualTo("DASH"); }
@Test public void serializeWidthCrosshair_resultJsonHasWidth() throws IOException { Crosshair crosshair = new Crosshair(); crosshair.setWidth(2f); crosshairSerializer.serialize(crosshair, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("width")).isTrue(); Assertions.assertThat(actualObj.get("width").asDouble()).isEqualTo(2.0); }
|
### Question:
HeatMapSerializer extends AbstractChartSerializer<HeatMap> { @Override public void serialize(HeatMap heatmap, JsonGenerator jgen, SerializerProvider sp) throws IOException, JsonProcessingException { jgen.writeStartObject(); serialize(heatmap, jgen); jgen.writeObjectField(GRAPHICS_LIST, heatmap.getData()); jgen.writeObjectField(COLOR, heatmap.getColor()); jgen.writeEndObject(); } @Override void serialize(HeatMap heatmap, JsonGenerator jgen, SerializerProvider sp); static final String GRAPHICS_LIST; static final String COLOR; }### Answer:
@Test public void serializeDataOfHeatMap_resultJsonHasGraphicsList() throws IOException { HeatMap heatMap = new HeatMap(); heatMap.setData( new Integer[][] { new Integer[] {new Integer(1), new Integer(2)}, new Integer[] {new Integer(3), new Integer(4)} }); heatMapSerializer.serialize(heatMap, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("graphics_list")).isTrue(); Assertions.assertThat(actualObj.get("graphics_list")).isNotEmpty(); }
@Test public void serializeColorOfHeatMap_resultJsonHasColor() throws IOException { HeatMap heatMap = new HeatMap(); heatMap.setColor(new GradientColor(Arrays.asList(Color.GREEN, Color.BLUE))); heatMapSerializer.serialize(heatMap, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("color")).isTrue(); Assertions.assertThat(actualObj.get("color").get("colors")).isNotEmpty(); }
|
### Question:
CppCommOpenHandler extends CommOpenHandler { public Handler<Message>[] getKernelControlChanelHandlers(String targetName){ if(TargetNamesEnum.KERNEL_CONTROL_CHANNEL.getTargetName().equalsIgnoreCase(targetName)){ return (Handler<Message>[]) KERNEL_CONTROL_CHANNEL_HANDLERS; }else{ return (Handler<Message>[]) new Handler<?>[0]; } } CppCommOpenHandler(KernelFunctionality kernel); Handler<Message>[] getKernelControlChanelHandlers(String targetName); }### Answer:
@Test public void getControlHandlersWithEmptyString_returnEmptyHandlersArray() throws Exception { Handler<Message>[] handlers = commOpenHandler.getKernelControlChanelHandlers(""); Assertions.assertThat(handlers).isEmpty(); }
@Test public void getControlHandlersWithTargetName_returnNotEmptyHandlersArray() throws Exception { Handler<Message>[] handlers = commOpenHandler.getKernelControlChanelHandlers(targetName); Assertions.assertThat(handlers).isNotEmpty(); }
|
### Question:
Message { public Header getHeader() { return header; } Message(); JupyterMessages type(); List<byte[]> getIdentities(); void setIdentities(List<byte[]> identities); Header getHeader(); void setHeader(Header header); Header getParentHeader(); void setParentHeader(Header parentHeader); Map<String, Serializable> getMetadata(); void setMetadata(Map<String, Serializable> metadata); Map<String, Serializable> getContent(); void setContent(Map<String, Serializable> content); @Override String toString(); }### Answer:
@Test public void createMessageWithEmptyConstructor_messageHasHeaderIsNotNull() { Message message = new Message(); Assertions.assertThat(message.getHeader()).isNotNull(); }
|
### Question:
CompleteHandler extends KernelHandler<Message> { @Override public void handle(Message message) { wrapBusyIdle(kernel, message, () -> { handleMsg(message); }); } CompleteHandler(KernelFunctionality kernel); @Override void handle(Message message); static final String STATUS; static final String MATCHES; static final String CURSOR_END; static final String CURSOR_START; static final String CODE; static final String CURSOR_POS; }### Answer:
@Test public void handle_shouldSendMessage() throws Exception { completeHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Assertions.assertThat(kernel.getSentMessages().get(0)).isNotNull(); }
@Test public void handle_sentMessageHasHeaderTypeIsCompleteReply() throws Exception { completeHandler.handle(message); Header header = kernel.getSentMessages().get(0).getHeader(); Assertions.assertThat(header).isNotNull(); Assertions.assertThat(header.getType()).isEqualTo(COMPLETE_REPLY.getName()); }
@Test public void handle_messageContentHasCursorStartAndEndFields() throws Exception { completeHandler.handle(message); Map<String, Serializable> content = kernel.getSentMessages().get(0).getContent(); Assertions.assertThat(content.get(CompleteHandler.CURSOR_START)).isNotNull(); Assertions.assertThat(content.get(CompleteHandler.CURSOR_END)).isNotNull(); }
@Test public void handle_messageContentHasMatchesField() throws Exception { completeHandler.handle(message); Map<String, Serializable> content = kernel.getSentMessages().get(0).getContent(); Assertions.assertThat(content.get(CompleteHandler.MATCHES)).isNotNull(); }
@Test public void handle_messageContentHasStatus() throws Exception { completeHandler.handle(message); Map<String, Serializable> content = kernel.getSentMessages().get(0).getContent(); Assertions.assertThat(content.get(CompleteHandler.STATUS)).isNotNull(); }
|
### Question:
CategoryLinesSerializer extends CategoryGraphicsSerializer<CategoryLines> { @Override public void serialize(CategoryLines categoryLines, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { jgen.writeStartObject(); super.serialize(categoryLines, jgen, provider); if (categoryLines.getWidth() != null) { jgen.writeObjectField("width", categoryLines.getWidth()); } if (categoryLines.getStyles() != null) { jgen.writeObjectField("styles", categoryLines.getStyles()); } else { jgen.writeObjectField("style", categoryLines.getStyle().toString()); } if (categoryLines.getInterpolation() != null) { jgen.writeObjectField("interpolation", categoryLines.getInterpolation()); } jgen.writeEndObject(); } @Override void serialize(CategoryLines categoryLines,
JsonGenerator jgen,
SerializerProvider provider); }### Answer:
@Test public void serializeWidthCategoryLines_resultJsonHasWidth() throws IOException { CategoryLines categoryLines = new CategoryLines(); categoryLines.setWidth(11f); categoryLinesSerializer.serialize(categoryLines, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("width")).isTrue(); Assertions.assertThat(actualObj.get("width").asInt()).isEqualTo(11); }
@Test public void serializeStrokeTypeStems_resultJsonHasStyle() throws IOException { CategoryLines categoryLines = new CategoryLines(); categoryLines.setStyle(StrokeType.SOLID); categoryLinesSerializer.serialize(categoryLines, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("style")).isTrue(); Assertions.assertThat(actualObj.get("style").asText()).isEqualTo("SOLID"); }
@Test public void serializeStrokeTypeListStems_resultJsonHasStyles() throws IOException { CategoryLines categoryLines = new CategoryLines(); categoryLines.setStyle(Arrays.asList(StrokeType.SOLID, StrokeType.DASHDOT)); categoryLinesSerializer.serialize(categoryLines, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("styles")).isTrue(); ArrayNode arrayNode = (ArrayNode) actualObj.get("styles"); Assertions.assertThat(arrayNode.get(1).asText()).isEqualTo("DASHDOT"); }
@Test public void serializeInterpolationCategoryLines_resultJsonHasInterpolation() throws IOException { CategoryLines categoryLines = new CategoryLines(); categoryLines.setInterpolation(1); categoryLinesSerializer.serialize(categoryLines, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("interpolation")).isTrue(); Assertions.assertThat(actualObj.get("interpolation").asInt()).isEqualTo(1); }
|
### Question:
DisplayOutputContainer { public static void display(OutputContainer container) { if (container.getLayoutManager() instanceof TabbedOutputContainerLayoutManager) { List<CommFunctionality> items = container.getItems().stream().map(x -> toCommFunctionality(x)).collect(Collectors.toList()); Tab tab = new Tab(items, container.getLabels()); tab.display(); } else { container.getItems().forEach(item -> toCommFunctionality(item).display()); } } static void display(OutputContainer container); }### Answer:
@Test public void shouldAddMapToOutputContainerTest() throws Exception { List<Map<String, Object>> values = ResourceLoaderTest.readAsList("tableRowsTest.csv"); OutputContainer oc = new OutputContainer(); oc.leftShift(values.get(0)); DisplayOutputContainer.display(oc); verifyMap(groovyKernel.getPublishedMessages()); }
@Test public void shouldDisplayOutputContainerWithTabLayoutTest() throws Exception { List<Map<String, Object>> values = ResourceLoaderTest.readAsList("tableRowsTest.csv"); OutputContainer oc = new OutputContainer(); SimpleTimePlot simpleTimePlot = new SimpleTimePlot(values, Arrays.asList("m3", "y1")); oc.setLayoutManager(new TabbedOutputContainerLayoutManager()); oc.addItem(simpleTimePlot, "Scatter with History"); DisplayOutputContainer.display(oc); verifyTabLayout(groovyKernel.getPublishedMessages()); }
|
### Question:
GradientColorSerializer extends JsonSerializer<GradientColor> { @Override public void serialize(GradientColor gradientColor, JsonGenerator jgen, SerializerProvider sp) throws IOException, JsonProcessingException { jgen.writeObject(gradientColor.getColors()); } @Override void serialize(GradientColor gradientColor, JsonGenerator jgen, SerializerProvider sp); }### Answer:
@Test public void serializeGradientColor_resultJsonHasGradientColor() throws IOException { GradientColor gradientColor = new GradientColor(Arrays.asList(Color.GREEN, Color.BLUE)); gradientColorSerializer.serialize(gradientColor, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); ArrayNode arrayNode = (ArrayNode) mapper.readTree(sw.toString()); Assertions.assertThat(arrayNode).isNotEmpty(); Assertions.assertThat(arrayNode.get(0).get("rgb").asInt()).isEqualTo(Color.GREEN.getRGB()); }
|
### Question:
LegendPositionSerializer extends JsonSerializer<LegendPosition> { @Override public void serialize(LegendPosition legendPosition, JsonGenerator jgen, SerializerProvider sp) throws IOException, JsonProcessingException { jgen.writeStartObject(); jgen.writeObjectField("type", legendPosition.getClass().getSimpleName()); if (legendPosition.getPosition() != null) { jgen.writeObjectField("position", legendPosition.getPosition().name()); }else{ jgen.writeObjectField("x", legendPosition.getX()); jgen.writeObjectField("y", legendPosition.getY()); } jgen.writeEndObject(); } @Override void serialize(LegendPosition legendPosition, JsonGenerator jgen, SerializerProvider sp); }### Answer:
@Test public void serializeLegendPosition_resultJsonHasType() throws IOException { legendPositionSerializer.serialize(legendPosition, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("type")).isTrue(); Assertions.assertThat(actualObj.get("type").asText()).isEqualTo("LegendPosition"); }
@Test public void serializePositionOfLegendPosition_resultJsonHasPosition() throws IOException { legendPosition.setPosition(LegendPosition.Position.LEFT); legendPositionSerializer.serialize(legendPosition, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("position")).isTrue(); Assertions.assertThat(actualObj.get("position").asText()).isEqualTo("LEFT"); }
@Test public void serializeXLegendPosition_resultJsonHasX() throws IOException { LegendPosition legendPositionX = new LegendPosition(new int[] {11, 22}); legendPositionSerializer.serialize(legendPositionX, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("x")).isTrue(); Assertions.assertThat(actualObj.get("x").asInt()).isEqualTo(11); }
@Test public void serializeYLegendPosition_resultJsonHasY() throws IOException { LegendPosition legendPositionY = new LegendPosition(new int[] {11, 22}); legendPositionSerializer.serialize(legendPositionY, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.has("y")).isTrue(); Assertions.assertThat(actualObj.get("y").asInt()).isEqualTo(22); }
|
### Question:
GradientColor implements Serializable { public Color[] getColors() { return colors; } protected GradientColor(Color[] colors); GradientColor(List<Object> colors); Color[] getColors(); final static GradientColor BROWN_RED_YELLOW; final static GradientColor GREEN_YELLOW_WHITE; final static GradientColor WHITE_BLUE; }### Answer:
@Test public void createGradientColorWithArrayBeakerColorParam_hasArrayBeakerColorsIsNotEmpty() { GradientColor gradientColor = new GradientColor(new Color[] {Color.black, Color.blue}); Assertions.assertThat(gradientColor.getColors()[0] instanceof Color).isTrue(); Assertions.assertThat(gradientColor.getColors()[1] instanceof Color).isTrue(); }
@Test public void createGradientColorWithArraylistAwtColorParam_hasArrayBeakerColorsIsNotEmpty() { GradientColor gradientColor = new GradientColor(Arrays.asList(java.awt.Color.GREEN, java.awt.Color.BLUE)); Assertions.assertThat(gradientColor.getColors()[0] instanceof Color).isTrue(); Assertions.assertThat(gradientColor.getColors()[1] instanceof Color).isTrue(); }
|
### Question:
CategoryPlot extends AbstractChart implements InternalCommWidget, InternalPlot { public PlotOrientationType getOrientation() { return orientation; } CategoryPlot(); @Override String getModelNameValue(); @Override String getViewNameValue(); @Override Comm getComm(); @Override void close(); CategoryPlot leftShift(CategoryGraphics graphics); List<CategoryGraphics> getGraphics(); CategoryPlot add(CategoryGraphics graphics); CategoryPlot add(List items); List<String> getCategoryNames(); CategoryPlot setCategoryNames(List<String> categoryNames); List<CategoryGraphics> getCategoryGraphics(); PlotOrientationType getOrientation(); void setOrientation(PlotOrientationType orientation); double getCategoryMargin(); void setCategoryMargin(double categoryMargin); double getCategoryNamesLabelAngle(); void setCategoryNamesLabelAngle(double categoryNamesLabelAngle); }### Answer:
@Test public void createCategoryPlotByEmptyConstructor_hasVerticalOrientation() { CategoryPlot categoryPlot = new CategoryPlot(); Assertions.assertThat(categoryPlot.getOrientation()).isEqualTo(PlotOrientationType.VERTICAL); }
|
### Question:
CategoryLines extends CategoryGraphics { public Float getWidth() { return this.width; } void setWidth(Float width); Float getWidth(); void setStyle(Object style); StrokeType getStyle(); List<StrokeType> getStyles(); void setInterpolation(Integer interpolation); Integer getInterpolation(); }### Answer:
@Test public void createCategoryLinesByEmptyConstructor_hasWidthIsNotNull() { CategoryLines categoryLines = new CategoryLines(); Assertions.assertThat(categoryLines.getWidth()).isNotNull(); }
|
### Question:
CategoryPoints extends CategoryGraphics { public float getSize() { return this.baseSize; } void setSize(Object size); float getSize(); List<Number> getSizes(); void setShape(Object shape); ShapeType getShape(); List<ShapeType> getShapes(); void setFill(Object fill); Boolean getFill(); List<Boolean> getFills(); void setOutlineColor(Object color); Color getOutlineColor(); List<Object> getOutlineColors(); }### Answer:
@Test public void createCategoryPointsByEmptyConstructor_hasSizeGreaterThanZero() { CategoryPoints categoryPoints = new CategoryPoints(); Assertions.assertThat(categoryPoints.getSize()).isGreaterThan(0); }
|
### Question:
CategoryStems extends CategoryGraphics { public Float getWidth() { return this.width; } void setBase(Object base); Number getBase(); List<Number> getBases(); void setWidth(Float width); Float getWidth(); void setStyle(Object style); StrokeType getStyle(); List<StrokeType> getStyles(); }### Answer:
@Test public void createCategoryStemsByEmptyConstructor_hasWidthGreaterThanZero() { CategoryStems categoryStems = new CategoryStems(); Assertions.assertThat(categoryStems.getWidth()).isGreaterThan(0); }
|
### Question:
CategoryBars extends CategoryGraphics { public Number getBase() { return this.baseBase; } void setBase(Object base); Number getBase(); List<Number> getBases(); void setWidth(Object width); Number getWidth(); List<Number> getWidths(); void setOutlineColor(Object color); Color getOutlineColor(); List<Object> getOutlineColors(); void setFill(Object fill); Boolean getFill(); List<Boolean> getFills(); void setDrawOutline(Object outline); List<Boolean> getDrawOutlines(); Boolean getDrawOutline(); LabelPositionType getLabelPosition(); void setLabelPosition(LabelPositionType labelPosition); }### Answer:
@Test public void createCategoryBarsByEmptyConstructor_hasBaseBaseEqualsZero() { CategoryBars categoryBars = new CategoryBars(); Assertions.assertThat(categoryBars.getBase()).isEqualTo(0.0); }
|
### Question:
XYStacker { public static List<BasedXYGraphics> stack(List<BasedXYGraphics> graphicsList) { return transformGraphicsList(graphicsList); } static List<BasedXYGraphics> stack(List<BasedXYGraphics> graphicsList); }### Answer:
@Test public void callStackWithMaxSizeAreasIsThree_returnAllAreasWithSizeIsThree() { List<BasedXYGraphics> list = XYStacker.stack(Arrays.asList(area1, area2, area3)); Assertions.assertThat(list.get(0).getX().size()).isEqualTo(3); Assertions.assertThat(list.get(0).getY().size()).isEqualTo(3); Assertions.assertThat(list.get(1).getX().size()).isEqualTo(3); Assertions.assertThat(list.get(1).getY().size()).isEqualTo(3); Assertions.assertThat(list.get(2).getX().size()).isEqualTo(3); Assertions.assertThat(list.get(2).getY().size()).isEqualTo(3); }
@Test public void callStackWithOneAndThreeElementsArea_returnFirstAreaWithTheSameYs() { List<BasedXYGraphics> list = XYStacker.stack(Arrays.asList(area1, area3)); List<Number> firstAreaYs = list.get(0).getY(); Assertions.assertThat(firstAreaYs.get(0)) .isEqualTo(firstAreaYs.get(1)) .isEqualTo(firstAreaYs.get(2)); }
@Test public void callStackWithAreas_returnFirstAreaYsEqualsSecondAreaBases() { List<BasedXYGraphics> list = XYStacker.stack(Arrays.asList(area3, area1)); List<Number> firstAreaYs = list.get(0).getY(); List<Number> secondAreaBases = list.get(1).getBases(); Assertions.assertThat(firstAreaYs.get(0)).isEqualTo(secondAreaBases.get(0)); Assertions.assertThat(firstAreaYs.get(1)).isEqualTo(secondAreaBases.get(1)); Assertions.assertThat(firstAreaYs.get(2)).isEqualTo(secondAreaBases.get(2)); }
|
### Question:
SelectMultiple extends MultipleSelectionWidget { public SelectMultiple() { super(); openComm(); } SelectMultiple(); @Override String getModelNameValue(); @Override String getViewNameValue(); static String VIEW_NAME_VALUE; static String MODEL_NAME_VALUE; }### Answer:
@Test public void shouldSendCommMsgWhenValueChange() throws Exception { SelectMultiple widget = selectMultiple(); widget.setOptions(new String[]{"1","2", "3"}); kernel.clearPublishedMessages(); widget.setValue(new String[]{"2", "3"}); verifyMsgForProperty(kernel, SelectMultiple.VALUE, new String[]{"2", "3"}); }
@Test public void shouldSendCommMsgWhenOptionsChange() throws Exception { SelectMultiple widget = selectMultiple(); widget.setOptions(new String[]{"2", "3"}); verifyMsgForProperty(kernel, SelectMultiple.OPTIONS_LABELS, new String[]{"2", "3"}); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.