Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### 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: 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: 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: 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: 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: 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: 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: 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"}); }
### Question: Crosshair implements Serializable { public StrokeType getStyle() { return this.style; } Crosshair setStyle(StrokeType style); StrokeType getStyle(); Crosshair setWidth(float width); Float getWidth(); Crosshair setColor(Object color); Color getColor(); @Override Object clone(); }### Answer: @Test public void createCrosshairByEmptyConstructor_hasStrokeTypeIsNull() { Crosshair crosshair = new Crosshair(); Assertions.assertThat(crosshair.getStyle()).isNull(); }
### Question: Area extends BasedXYGraphics { public Integer getInterpolation() { return this.interpolation; } void setInterpolation(Integer interpolation); Integer getInterpolation(); }### Answer: @Test public void createAreaByEmptyConstructor_hasInterpolationIsNull() { Area area = new Area(); Assertions.assertThat(area.getInterpolation()).isNull(); }
### Question: Area extends BasedXYGraphics { public void setInterpolation(Integer interpolation) { if (interpolation.intValue() < 0 \|\| interpolation.intValue() > 1) { throw new IllegalArgumentException( "Area interpolation is limited to 0, 1"); } this.interpolation = interpolation; } void setInterpolation(Integer interpolation); Integer getInterpolation(); }### Answer: @Test(expected = IllegalArgumentException.class) public void setInterpolationWithPositive2_throwIllegalArgumentException() { Area area = new Area(); area.setInterpolation(new Integer(-2)); } @Test(expected = IllegalArgumentException.class) public void setInterpolationWithNegative2_throwIllegalArgumentException() { Area area = new Area(); area.setInterpolation(new Integer(2)); }
### Question: Text implements Serializable, Cloneable { public int getSize() { return size; } Number getX(); void setX(Object x); Number getY(); void setY(Number y); Boolean getShowPointer(); void setShowPointer(boolean showPointer); String getText(); void setText(String text); Double getPointerAngle(); void setPointerAngle(Double pointerAngle); Color getColor(); void setColor(Color color); int getSize(); void setSize(int size); Class getPlotType(); void setPlotType(Class plotType); @Override Object clone(); }### Answer: @Test public void createTextByEmptyConstructor_hasSizeValueGreaterThanZero() { Text text = new Text(); Assertions.assertThat(text.getSize()).isGreaterThan(0); }
### Question: Stems extends BasedXYGraphics { public void setStyle(Object style) { if (style instanceof StrokeType) { this.baseStyle = (StrokeType) style; } else if (style instanceof List) { @SuppressWarnings("unchecked") List<StrokeType> ss = (List<StrokeType>) style; setStyles(ss); } else { throw new IllegalArgumentException( "setStyle takes ShapeType or List of ShapeType"); } } void setWidth(Float width); Float getWidth(); void setStyle(Object style); StrokeType getStyle(); List<StrokeType> getStyles(); }### Answer: @Test(expected = IllegalArgumentException.class) public void setStyleWithShapeTypeParam_throwIllegalArgumentException() { Stems stems = new Stems(); stems.setStyle(ShapeType.DEFAULT); }
### Question: Line extends XYGraphics { public StrokeType getStyle() { return this.style; } Line(); Line(List<Number> ys); Line(List<Object> xs, List<Number> ys); void setWidth(Float width); Float getWidth(); void setStyle(StrokeType style); StrokeType getStyle(); void setInterpolation(Integer interpolation); Integer getInterpolation(); }### Answer: @Test public void createLineByEmptyConstructor_lineHasStyleIsNull() { Line line = new Line(); Assertions.assertThat(line.getStyle()).isNull(); }
### Question: TimePlot extends XYChart implements InternalCommWidget, InternalPlot { public XYChart setXBound(Date lower, Date upper) { setXBound((double) lower.getTime(), (double) upper.getTime()); return this; } TimePlot(); @Override String getModelNameValue(); @Override String getViewNameValue(); @Override Comm getComm(); @Override void close(); XYChart setXBound(Date lower, Date upper); @Override XYChart setXBound(List bound); }### Answer: @Test public void setXBoundWithTwoDatesParams_shouldSetXBoundParams() { TimePlot timePlot = new TimePlot(); timePlot.setXBound(lowerBound, upperBound); Assertions.assertThat(timePlot.getXLowerBound()).isGreaterThan(0); Assertions.assertThat(timePlot.getXUpperBound()).isGreaterThan(0); Assertions.assertThat(timePlot.getXAutoRange()).isFalse(); } @Test public void setXBoundWithListParam_shouldSetXBoundParams() { TimePlot timePlot = new TimePlot(); timePlot.setXBound(Arrays.asList(lowerBound, upperBound)); Assertions.assertThat(timePlot.getXLowerBound()).isGreaterThan(0); Assertions.assertThat(timePlot.getXUpperBound()).isGreaterThan(0); Assertions.assertThat(timePlot.getXAutoRange()).isFalse(); }
### Question: Histogram extends AbstractChart implements InternalCommWidget, InternalPlot { public DisplayMode getDisplayMode() { return displayMode; } Histogram(); @Override String getModelNameValue(); @Override String getViewNameValue(); @Override Comm getComm(); @Override void close(); Integer getRangeMin(); void setRangeMin(Integer rangeMin); Integer getRangeMax(); void setRangeMax(Integer rangeMax); int getBinCount(); void setBinCount(int binCount); boolean getRightClose(); void setRightClose(boolean rightClose); boolean getCumulative(); void setCumulative(boolean cumulative); boolean getNormed(); void setNormed(boolean normed); DisplayMode getDisplayMode(); void setDisplayMode(DisplayMode displayMode); boolean getLog(); void setLog(boolean log); @SuppressWarnings("unchecked") void setColor(Object color); List<Color> getColors(); Color getColor(); @SuppressWarnings("unchecked") void setData(Object data); List<Number> getData(); List<List<Number>> getListData(); List<String> getNames(); void setNames(List<String> names); }### Answer: @Test public void createHistogramByEmptyConstructor_hasDisplayModeIsNotNull() { Histogram histogram = new Histogram(); Assertions.assertThat(histogram.getDisplayMode()).isNotNull(); }
### Question: GradientColorProvider extends ColorProvider { @Override public Color getColor(TreeMapNode node) { double value = getValue(node); float result = (float) ((value - minValue) / (maxValue - minValue)); return ColorUtils.interpolateColor(start, end, result); } GradientColorProvider(TreeMap treeMap, Color start, Color end); GradientColorProvider(TreeMap treeMap); @Override Color getColor(TreeMapNode node); }### Answer: @Test public void createProviderWithTreeMapParam_getColorWithNodeReturnBeakerColorWithRGB() { GradientColorProvider gradientColorProvider = new GradientColorProvider(treeMap); Assertions.assertThat(gradientColorProvider.getColor(treeMap.getRoot()).getRGB()).isNotZero(); Assertions.assertThat(gradientColorProvider.getColor(node01).getRGB()).isNotZero(); } @Test public void createProviderWithTreeMapAndTwoColorsParams_getColorWithNodeReturnBeakerColorWithRGB() { GradientColorProvider gradientColorProvider = new GradientColorProvider(treeMap, Color.BLUE, Color.GREEN); Assertions.assertThat(gradientColorProvider.getColor(treeMap.getRoot()).getRGB()).isNotZero(); Assertions.assertThat(gradientColorProvider.getColor(node01).getRGB()).isNotZero(); }
### Question: RandomColorProvider extends ColorProvider { @Override public Color getColor(TreeMapNode node) { Object value; if (groupByParent && node.getParent() instanceof TreeMapNode){ value = ((TreeMapNode) node.getParent()).getLabel(); }else{ value = getValue(node); } if (!this.mapping.containsKey(value)) { mapping.put(value, colours[this.cursor]); cursor++; if (this.cursor == colours.length) { cursor = 0; } } return mapping.get(value); } RandomColorProvider(); RandomColorProvider(final Color[] colours); RandomColorProvider(List<Object> colors); @Override Color getColor(TreeMapNode node); boolean isGroupByParent(); void setGroupByParent(boolean groupByParent); }### Answer: @Test public void createProviderWithEmptyConstructor_getColorWithNodeReturnBeakerColorWithRGB() { RandomColorProvider randomColorProvider = new RandomColorProvider(); Assertions.assertThat(randomColorProvider.getColor(node01).getRGB()).isNotZero(); Assertions.assertThat(randomColorProvider.getColor(node02).getRGB()).isNotZero(); } @Test public void createProviderWithColorArrayParam_getColorWithNodeReturnBeakerColorWithRGB() { RandomColorProvider randomColorProvider = new RandomColorProvider(new Color[] {Color.BLUE, Color.GREEN}); Assertions.assertThat(randomColorProvider.getColor(node01).getRGB()).isNotZero(); Assertions.assertThat(randomColorProvider.getColor(node02).getRGB()).isNotZero(); }
### Question: RadioButtons extends SingleSelectionWidget { public RadioButtons() { super(); openComm(); } RadioButtons(); @Override String getModelNameValue(); @Override String getViewNameValue(); static String VIEW_NAME_VALUE; static String MODEL_NAME_VALUE; }### Answer: @Test public void shouldSendCommMsgWhenValueChange() throws Exception { RadioButtons widget = radioButtons(); widget.setValue("1"); verifyMsgForProperty(groovyKernel, RadioButtons.VALUE, "1"); } @Test public void shouldSendCommMsgWhenOptionsChange() throws Exception { RadioButtons widget = radioButtons(); widget.setOptions(new String[]{"2", "3"}); verifyMsgForProperty(groovyKernel, RadioButtons.OPTIONS_LABELS, new String[]{"2", "3"}); }
### Question: Select extends SingleSelectionWidget { public Select() { super(); openComm(); } Select(); @Override String getModelNameValue(); @Override String getViewNameValue(); static String VIEW_NAME_VALUE; static String MODEL_NAME_VALUE; }### Answer: @Test public void shouldSendCommMsgWhenValueChange() throws Exception { Select widget = select(); widget.setValue("1"); verifyMsgForProperty(groovyKernel, Select.VALUE, "1"); } @Test public void shouldSendCommMsgWhenOptionsChange() throws Exception { Select widget = select(); widget.setOptions(new String[]{"2", "3"}); verifyMsgForProperty(groovyKernel, RadioButtons.OPTIONS_LABELS, new String[]{"2", "3"}); }
### Question: Dropdown extends SingleSelectionWidget { public Dropdown() { super(); openComm(); } Dropdown(); @Override String getModelNameValue(); @Override String getViewNameValue(); static final String VIEW_NAME_VALUE; static final String MODEL_NAME_VALUE; }### Answer: @Test public void shouldSendCommMsgWhenValueChange() throws Exception { Dropdown dropdown = dropdown(); dropdown.setValue("1"); verifyMsgForProperty(groovyKernel, Dropdown.VALUE, "1"); } @Test public void shouldSendCommMsgWhenOptionsChange() throws Exception { Dropdown dropdown = dropdown(); dropdown.setOptions(new String[]{"2", "3"}); verifyMsgForProperty(groovyKernel, Dropdown.OPTIONS_LABELS, new String[]{"2", "3"}); }
### Question: SelectMultipleSingle extends SingleSelectionWidget { public SelectMultipleSingle() { super(); openComm(); } SelectMultipleSingle(); @Override String getModelNameValue(); @Override String getViewNameValue(); static String VIEW_NAME_VALUE; static String MODEL_NAME_VALUE; }### Answer: @Test public void shouldSendCommMsgWhenValueChange() throws Exception { SelectMultipleSingle widget = selectMultipleSingle(); widget.setOptions(new String[]{"1","2", "3"}); kernel.clearPublishedMessages(); widget.setValue("2"); verifyMsgForProperty(kernel, SelectMultiple.VALUE, "2"); } @Test public void shouldSendCommMsgWhenOptionsChange() throws Exception { SelectMultipleSingle widget = selectMultipleSingle(); widget.setOptions(new String[]{"2", "3"}); verifyMsgForProperty(kernel, SelectMultiple.OPTIONS_LABELS, new String[]{"2", "3"}); }
### Question: DatePicker extends ValueWidget<String> { public void setShowTime(final Boolean showTime) { this.showTime = showTime; sendUpdate(SHOW_TIME, showTime); } DatePicker(); @Override void updateValue(Object value); @Override String getValueFromObject(Object input); @Override String getModelNameValue(); @Override String getViewNameValue(); void setShowTime(final Boolean showTime); Boolean getShowTime(); static final String VIEW_NAME_VALUE; static final String MODEL_NAME_VALUE; static final String SHOW_TIME; }### Answer: @Test public void shouldSendCommMsgWhenShowTimeChange() throws Exception { DatePicker widget = widget(); widget.setShowTime(true); verifyMsgForProperty(groovyKernel, DatePicker.SHOW_TIME, true); }
### Question: ColorPicker extends ValueWidget<String> { public ColorPicker() { super(); openComm(); } ColorPicker(); @Override String getValueFromObject(Object input); Boolean getConcise(); void setConcise(Boolean concise); @Override String getModelNameValue(); @Override String getViewNameValue(); static final String VIEW_NAME_VALUE; static final String MODEL_NAME_VALUE; static final String CONCISE; }### Answer: @Test public void shouldSendCommMsgWhenValueChange() throws Exception { ColorPicker widget = colorPicker(); widget.setValue("red"); TestWidgetUtils.verifyMsgForProperty(groovyKernel, ColorPicker.VALUE, "red"); }
### Question: Checkbox extends BoolWidget { public Checkbox() { super(); openComm(); } Checkbox(); @Override String getModelNameValue(); @Override String getViewNameValue(); static String VIEW_NAME_VALUE; static String MODEL_NAME_VALUE; }### Answer: @Test public void shouldSendCommMsgWhenValueChange() throws Exception { Checkbox widget = checkbox(); widget.setValue(true); verifyMsgForProperty(groovyKernel, Checkbox.VALUE, true); }
### Question: ToggleButton extends BoolWidget { public ToggleButton() { super(); openComm(); } ToggleButton(); String getTooltip(); void setTooltip(String tooltip); @Override String getModelNameValue(); @Override String getViewNameValue(); static String VIEW_NAME_VALUE; static String MODEL_NAME_VALUE; static final String TOOLTIP; }### Answer: @Test public void shouldSendCommMsgWhenValueChange() throws Exception { ToggleButton widget = toggleButton(); widget.setValue(true); verifyMsgForProperty(groovyKernel, ToggleButton.VALUE, true); }
### Question: HTML extends StringWidget { public HTML() { super(); openComm(); } HTML(); @Override String getModelNameValue(); @Override String getViewNameValue(); static final String VIEW_NAME_VALUE; static final String MODEL_NAME_VALUE; }### Answer: @Test public void shouldSendCommMsgWhenValueChange() throws Exception { HTML widget = html(); widget.setValue("Hello <b>World</b>"); verifyMsgForProperty(groovyKernel, HTML.VALUE, "Hello <b>World</b>"); }
### Question: Label extends StringWidget { public Label() { super(); openComm(); } Label(); @Override String getModelNameValue(); @Override String getViewNameValue(); static final String VIEW_NAME_VALUE; static final String MODEL_NAME_VALUE; }### Answer: @Test public void shouldSendCommMsgWhenValueChange() throws Exception { Label widget = label(); widget.setValue("1"); verifyMsgForProperty(groovyKernel, Label.VALUE, "1"); }
### Question: Textarea extends StringWidget { public Textarea() { super(); openComm(); } Textarea(); @Override String getModelNameValue(); @Override String getViewNameValue(); static final String VIEW_NAME_VALUE; static final String MODEL_NAME_VALUE; }### Answer: @Test public void shouldSendCommMsgWhenValueChange() throws Exception { Textarea widget = textarea(); widget.setValue("Text area 1"); verifyMsgForProperty(groovyKernel, Textarea.VALUE, "Text area 1"); }
### Question: Text extends StringWidget { public Text() { super(); openComm(); } Text(); @Override String getModelNameValue(); @Override String getViewNameValue(); static final String VIEW_NAME_VALUE; static final String MODEL_NAME_VALUE; }### Answer: @Test public void shouldSendCommMsgWhenValueChange() throws Exception { Text widget = text(); widget.setValue("1"); verifyMsgForProperty(groovyKernel, Text.VALUE, "1"); }
### Question: FloatSlider extends BoundedFloatWidget { public FloatSlider() { super(); openComm(); } FloatSlider(); String getOrientation(); void setOrientation(String orientation); String getSlider_color(); void setSlider_color(String slider_color); Boolean getReadOut(); void setReadOut(Object readOut); Boolean getContinuous_update(); void setContinuous_update(Boolean continuous_update); @Override String getModelNameValue(); @Override String getViewNameValue(); static final String VIEW_NAME_VALUE; static final String MODEL_NAME_VALUE; }### Answer: @Test public void shouldSendCommMsgWhenValueChange() throws Exception { FloatSlider floatSlider = floatSlider(); floatSlider.setValue(11.1); verifyMsgForProperty(groovyKernel, FloatSlider.VALUE, 11.1); } @Test public void shouldSendCommMsgWhenStepChange() throws Exception { FloatSlider floatSlider = floatSlider(); floatSlider.setStep(12.1); verifyMsgForProperty(groovyKernel, BoundedFloatWidget.STEP, 12.1); } @Test public void shouldSendCommMsgWhenMaxChange() throws Exception { FloatSlider floatSlider = floatSlider(); floatSlider.setMax(122.3); verifyMsgForProperty(groovyKernel, BoundedFloatWidget.MAX, 122.3); } @Test public void shouldSendCommMsgWhenMinChange() throws Exception { FloatSlider floatSlider = floatSlider(); floatSlider.setMin(10.2); verifyMsgForProperty(groovyKernel, BoundedFloatWidget.MIN, 10.2); }
### Question: ValueWidget extends DOMWidget { public Integer getInteger(Object input) { Integer ret = 0; if (input != null) { if (input instanceof Double) { ret = ((Double) input).intValue(); } else if (input instanceof Integer) { ret = (Integer) input; } else if (input instanceof String) { try { ret = Integer.parseInt((String) input); } catch (NumberFormatException e) { } } else if (input instanceof Object[]) { Object[] array = (Object[]) input; if (array.length > 0) { ret = (Integer) getInteger(array[0]); } } } 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 getIntegerWithStringParam_returnInteger() throws Exception { Integer value = valueWidget.getInteger("123"); Assertions.assertThat(value.intValue()).isEqualTo(123); } @Test public void getIntegerWithDoubleParam_returnInteger() throws Exception { Integer value = valueWidget.getInteger(new Double(123)); Assertions.assertThat(value.intValue()).isEqualTo(123); } @Test public void getIntegerWithIntegerParam_returnInteger() throws Exception { Integer value = valueWidget.getInteger(new Integer(123)); Assertions.assertThat(value.intValue()).isEqualTo(123); } @Test public void getIntegerWithArrayParam_returnInteger() throws Exception { Integer value = valueWidget.getInteger(new Integer[]{123, 234}); Assertions.assertThat(value.intValue()).isEqualTo(123); }
### Question: ValueWidget extends DOMWidget { public Double getDouble(Object input) { Double ret = 0D; if (input != null) { if (input instanceof Integer) { ret = ((Integer) input).doubleValue(); } else if (input instanceof Double) { ret = (Double) input; } else if (input instanceof String) { try { ret = Double.parseDouble((String) input); } catch (NumberFormatException e) { } } else if (input instanceof Object[]) { Object[] array = (Object[]) input; if (array.length > 0) { ret = (Double) getDouble(array[0]); } } } 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 getDoubleWithStringParam_returnDouble() throws Exception { Double value = valueWidget.getDouble("123"); Assertions.assertThat(value.doubleValue()).isEqualTo(123d); } @Test public void getDoubleWithDoubleParam_returnDouble() throws Exception { Double value = valueWidget.getDouble(new Double(123d)); Assertions.assertThat(value.doubleValue()).isEqualTo(123d); } @Test public void getDoubleWithIntegerParam_returnDouble() throws Exception { Double value = valueWidget.getDouble(new Double(123d)); Assertions.assertThat(value.doubleValue()).isEqualTo(123d); } @Test public void getDoubleWithArrayParam_returnDouble() throws Exception { Double value = valueWidget.getDouble(new Double[]{123d, 234d}); Assertions.assertThat(value.doubleValue()).isEqualTo(123d); }
### Question: JavaEvaluator implements Evaluator { @Override public void evaluate(SimpleEvaluationObject seo, String code) { jobQueue.add(new jobDescriptor(code,seo)); syncObject.release(); } JavaEvaluator(String id, String sId); @Override void startWorker(); String getShellId(); void killAllThreads(); void cancelExecution(); void resetEnvironment(); @Override 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.*;\n" + "Plot plot = new Plot(); plot.setTitle(\"test title\");\n" + "return plot;"; SimpleEvaluationObject seo = new SimpleEvaluationObject(code, new ExecuteCodeCallbackTest()); javaEvaluator.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 = "return 16/0;"; SimpleEvaluationObject seo = new SimpleEvaluationObject(code, new ExecuteCodeCallbackTest()); javaEvaluator.evaluate(seo, code); waitForResult(seo); Assertions.assertThat(seo.getStatus()).isEqualTo(ERROR); Assertions.assertThat((String)seo.getPayload()).contains("java.lang.ArithmeticException"); }
### Question: ValueWidget extends DOMWidget { public String getString(Object input) { String ret = ""; if (input != null) { if (input instanceof String) { ret = (String) input; } else if (input instanceof byte[]) { ret = new String((byte[]) input); } else { ret = input.toString(); } } 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 getStringWithStringParam_returnString() throws Exception { String value = valueWidget.getString("abc"); Assertions.assertThat(value).isEqualTo("abc"); } @Test public void getStringWithByteArrayParam_returnString() throws Exception { String value = valueWidget.getString("abc".getBytes()); Assertions.assertThat(value).isEqualTo("abc"); } @Test public void getStringWithDoubleParam_returnString() throws Exception { String value = valueWidget.getString(new Integer(123)); Assertions.assertThat(value).isEqualTo("123"); } @Test public void getStringWithNullParam_returnEmptyString() throws Exception { String value = valueWidget.getString(null); Assertions.assertThat(value).isEmpty(); }
### Question: ValueWidget extends DOMWidget { public String[] getStringArray(Object input) { List<String> ret = new ArrayList<>(); if (input != null) { if (input instanceof Object[]) { Object[] array = (Object[]) input; for (Object o : array) { ret.add(getString(o)); } }else if(input instanceof Collection<?>){ Collection<Object> array = (Collection<Object>) input; for (Object o : array) { ret.add(getString(o)); } } else { ret.add(getString(input)); } } return ((ArrayList<String>) ret).stream().toArray(String[]::new); } 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 getStringArrayWithNullArrayParam_returnEmptyArray() throws Exception { String[] value = valueWidget.getStringArray(null); Assertions.assertThat(value).isEmpty(); } @Test public void getStringArrayWithArrayParam_returnArray() throws Exception { String[] value = valueWidget.getStringArray(new String[]{"ab", "cd"}); Assertions.assertThat(value[0]).isEqualTo("ab"); Assertions.assertThat(value[1]).isEqualTo("cd"); } @Test public void getStringArrayWithListParam_returnArray() throws Exception { String[] value = valueWidget.getStringArray(Arrays.asList("ab", "cd")); Assertions.assertThat(value[0]).isEqualTo("ab"); Assertions.assertThat(value[1]).isEqualTo("cd"); } @Test public void getStringArrayWithIntegerParam_returnArray() throws Exception { String[] value = valueWidget.getStringArray(new Integer(123)); Assertions.assertThat(value[0]).isEqualTo("123"); }
### Question: MorphiaUtils { public static List<String> getApplicationPackageName(final ApplicationContext applicationContext) { Set<String> candidateClasses = new HashSet<>(); candidateClasses.addAll(Arrays.asList(applicationContext.getBeanNamesForAnnotation(SpringBootApplication.class))); candidateClasses.addAll(Arrays.asList(applicationContext.getBeanNamesForAnnotation(EnableAutoConfiguration.class))); candidateClasses.addAll(Arrays.asList(applicationContext.getBeanNamesForAnnotation(ComponentScan.class))); if (candidateClasses.isEmpty()) { throw new RuntimeException("Is mandatory for the starter have @SpringBootApplication, @EnableAutoConfiguration or @ComponentScan annotation"); } else { return candidateClasses.parallelStream() .map(candidateClazz -> applicationContext.getBean(candidateClazz).getClass().getPackage().getName()) .distinct() .collect(Collectors.toList()); } } static List<String> getApplicationPackageName(final ApplicationContext applicationContext); static Set<Class<?>> getClasses(final String packageName); }### Answer: @Test(expected = Exception.class) public void testWhenNoApplicationAnnotation_ShouldReturnAException() { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringApplicationAcceptNoSpringBootApplication.class); MorphiaUtils.getApplicationPackageName(context); } @Test public void testCallGetPackageName_ShouldReturnAPackageName() { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringApplicationTest.class); List<String> applicationPackageName = MorphiaUtils.getApplicationPackageName(context); assertThat(applicationPackageName.size(), is(1)); assertThat(applicationPackageName.get(0), is("io.github.ganchix.morphia.utils.context.normal")); }
### Question: MorphiaUtils { public static Set<Class<?>> getClasses(final String packageName) { Reflections reflections = new Reflections(packageName); return reflections.getTypesAnnotatedWith(Entity.class); } static List<String> getApplicationPackageName(final ApplicationContext applicationContext); static Set<Class<?>> getClasses(final String packageName); }### Answer: @Test public void testCallGetClasses_ShouldReturnAClassesInPackage() { Set<Class<?>> classes = MorphiaUtils.getClasses("io.github.ganchix.morphia.utils.context.normal"); assertThat(classes.size(), is(1)); } @Test public void testCallGetClasses_ShouldReturnAClassesInPackage1() { Set<Class<?>> classes = MorphiaUtils.getClasses("io.github.ganchix.morphia.utils.context.normal.NotClass.class"); }
### Question: Fruit { public <T> T fromHtml(String html, Class<T> classOfT) { return fromHtml(html, (Type) classOfT); } Fruit(); T fromHtml(String html, Class<T> classOfT); T fromHtml(String html, Type typeOfT); T fromHtml(File file, String charsetName, String baseUri, Class<T> classOfT); @SuppressWarnings("unchecked") T fromHtml(Element element, Type typeOfT); PickAdapter<T> getAdapter(Class<T> type); @SuppressWarnings("unchecked") PickAdapter<T> getAdapter(TypeToken<T> type); }### Answer: @Test public void testDirctList() { FruitItems items = new Fruit().fromHtml(htmlStr, FruitItems.class); assert items.size() == 5; assert items.get(4).getId() == 5; System.out.println("fruitItems: " + fruitInfo); } @Test public void testNullInput() { assert null == new Fruit().fromHtml("", Object.class); }
### Question: NoticesXmlParser { public static Notices parse(final InputStream inputStream) throws Exception { try { final XmlPullParser parser = Xml.newPullParser(); parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false); parser.setInput(inputStream, null); parser.nextTag(); return parse(parser); } finally { inputStream.close(); } } private NoticesXmlParser(); static Notices parse(final InputStream inputStream); }### Answer: @Test public void testParse() throws Exception { assertNotNull(NoticesXmlParser.parse(RuntimeEnvironment.application.getResources().openRawResource(R.raw.notices))); }
### Question: LicenseResolver { public static void registerLicense(final License license) { sLicenses.put(license.getName(), license); } private LicenseResolver(); static void registerLicense(final License license); static License read(final String license); }### Answer: @Test public void testRegisterLicense() throws Exception { LicenseResolver.registerLicense(new TestLicense()); final License license = LicenseResolver.read(TEST_LICENSE_NAME); assertNotNull(license); assertEquals(TEST_LICENSE_NAME, license.getName()); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.