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: EurekaVM { public void setApplications(List<Map<String, Object>> applications) { this.applications = applications; } List<Map<String, Object>> getApplications(); void setApplications(List<Map<String, Object>> applications); Map<String, Object> getStatus(); void setStatus(Map<String, Object> status); }### Answer: @Test public void setApplicationsTest() throws Exception { assertNull(eureka.getApplications()); eureka.setApplications(initFakeApplicationsList()); assertNotNull(eureka.getApplications()); List<Map<String, Object>> newList = new ArrayList<>(); eureka.setApplications(newList); assertEquals(newList, eureka.getApplications()); }
### Question: EurekaVM { public Map<String, Object> getStatus() { return status; } List<Map<String, Object>> getApplications(); void setApplications(List<Map<String, Object>> applications); Map<String, Object> getStatus(); void setStatus(Map<String, Object> status); }### Answer: @Test public void getStatusTest() throws Exception { Map<String, Object> status = eureka.getStatus(); assertNull(status); eureka.setStatus(initFakeStatus()); status = eureka.getStatus(); assertNotNull(status); assertTrue(status.size()==3); }
### Question: EurekaVM { public void setStatus(Map<String, Object> status) { this.status = status; } List<Map<String, Object>> getApplications(); void setApplications(List<Map<String, Object>> applications); Map<String, Object> getStatus(); void setStatus(Map<String, Object> status); }### Answer: @Test public void setStatusTest() throws Exception { assertNull(eureka.getStatus()); eureka.setStatus(initFakeStatus()); assertNotNull(eureka.getStatus()); Map<String, Object> newStatus = new HashMap<>(); eureka.setStatus(newStatus); assertEquals(newStatus, eureka.getStatus()); }
### Question: LoggerVM { public String getName() { return name; } LoggerVM(Logger logger); @JsonCreator LoggerVM(); String getName(); void setName(String name); String getLevel(); void setLevel(String level); @Override String toString(); }### Answer: @Test public void getNameTest() throws Exception { LoggerVM vm = new LoggerVM(); assertNull(vm.getName()); Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); vm = new LoggerVM(logger); assertEquals(Logger.ROOT_LOGGER_NAME, vm.getName()); }
### Question: LoggerVM { public void setName(String name) { this.name = name; } LoggerVM(Logger logger); @JsonCreator LoggerVM(); String getName(); void setName(String name); String getLevel(); void setLevel(String level); @Override String toString(); }### Answer: @Test public void setNameTest() throws Exception { LoggerVM vm = new LoggerVM(); vm.setName(null); assertNull(vm.getName()); vm = new LoggerVM(); vm.setName("fakeName"); assertEquals("fakeName", vm.getName()); Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); vm = new LoggerVM(logger); vm.setName("fakeRootName"); assertEquals("fakeRootName", vm.getName()); }
### Question: LoggerVM { public String getLevel() { return level; } LoggerVM(Logger logger); @JsonCreator LoggerVM(); String getName(); void setName(String name); String getLevel(); void setLevel(String level); @Override String toString(); }### Answer: @Test public void getLevelTest() throws Exception { LoggerVM vm = new LoggerVM(); assertNull(vm.getLevel()); Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); vm = new LoggerVM(logger); assertEquals(Level.ERROR.toString(), vm.getLevel()); }
### Question: LoggerVM { public void setLevel(String level) { this.level = level; } LoggerVM(Logger logger); @JsonCreator LoggerVM(); String getName(); void setName(String name); String getLevel(); void setLevel(String level); @Override String toString(); }### Answer: @Test public void setLevelTest() throws Exception { LoggerVM vm = new LoggerVM(); vm.setLevel(null); assertNull(vm.getLevel()); vm = new LoggerVM(); vm.setLevel("fakeLevel"); assertEquals("fakeLevel", vm.getLevel()); Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); vm = new LoggerVM(logger); vm.setLevel(Level.OFF.toString()); assertEquals(Level.OFF.toString(), vm.getLevel()); }
### Question: LoggerVM { @Override public String toString() { return "LoggerVM{" + "name='" + name + '\'' + ", level='" + level + '\'' + '}'; } LoggerVM(Logger logger); @JsonCreator LoggerVM(); String getName(); void setName(String name); String getLevel(); void setLevel(String level); @Override String toString(); }### Answer: @Test public void toStringTestTest() throws Exception { Logger logger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME); LoggerVM vm = new LoggerVM(logger); assertTrue(vm.toString().startsWith(LoggerVM.class.getSimpleName())); String json = vm.toString().replace(LoggerVM.class.getSimpleName(), ""); assertTrue(TestUtils.isValid(json)); }
### Question: LoginVM { public String getUsername() { return username; } String getUsername(); void setUsername(String username); String getPassword(); void setPassword(String password); Boolean isRememberMe(); void setRememberMe(Boolean rememberMe); @Override String toString(); }### Answer: @Test public void getUsernameTest(){ LoginVM vm = new LoginVM(); assertNull(vm.getUsername()); vm.setUsername("fakeUsername"); assertEquals("fakeUsername", vm.getUsername()); }
### Question: LoginVM { public void setUsername(String username) { this.username = username; } String getUsername(); void setUsername(String username); String getPassword(); void setPassword(String password); Boolean isRememberMe(); void setRememberMe(Boolean rememberMe); @Override String toString(); }### Answer: @Test public void setUsernameTest(){ LoginVM vm = new LoginVM(); assertNull(vm.getUsername()); vm.setUsername(null); assertNull(vm.getUsername()); vm.setUsername("fakeUsername"); assertEquals("fakeUsername", vm.getUsername()); vm = new LoginVM(); vm.setPassword("goodPassword"); assertFalse(validator.validate(vm).isEmpty()); vm.setUsername(""); assertFalse(validator.validate(vm).isEmpty()); vm.setUsername("badUsernameTooLongbadUsernameTooLongbadUsernameTooLongbadUsernameTooLongbadUsernameTooLong"); assertFalse(validator.validate(vm).isEmpty()); vm.setUsername("goodUsername"); assertTrue(validator.validate(vm).isEmpty()); }
### Question: LoginVM { public String getPassword() { return password; } String getUsername(); void setUsername(String username); String getPassword(); void setPassword(String password); Boolean isRememberMe(); void setRememberMe(Boolean rememberMe); @Override String toString(); }### Answer: @Test public void getPasswordTest(){ LoginVM vm = new LoginVM(); assertNull(vm.getPassword()); vm.setPassword("fakePassword"); assertEquals("fakePassword", vm.getPassword()); }
### Question: LoginVM { public void setPassword(String password) { this.password = password; } String getUsername(); void setUsername(String username); String getPassword(); void setPassword(String password); Boolean isRememberMe(); void setRememberMe(Boolean rememberMe); @Override String toString(); }### Answer: @Test public void setPasswordTest(){ LoginVM vm = new LoginVM(); assertNull(vm.getPassword()); vm.setPassword(null); assertNull(vm.getPassword()); vm.setPassword("fakePassword"); assertEquals("fakePassword", vm.getPassword()); vm = new LoginVM(); vm.setUsername("goodUsername"); vm.setPassword("goodPassword"); assertTrue(validator.validate(vm).isEmpty()); }
### Question: LoginVM { public Boolean isRememberMe() { return rememberMe; } String getUsername(); void setUsername(String username); String getPassword(); void setPassword(String password); Boolean isRememberMe(); void setRememberMe(Boolean rememberMe); @Override String toString(); }### Answer: @Test public void isRememberMeTest(){ LoginVM vm = new LoginVM(); assertNull(vm.isRememberMe()); vm.setRememberMe(true); assertTrue(vm.isRememberMe()); }
### Question: LoginVM { public void setRememberMe(Boolean rememberMe) { this.rememberMe = rememberMe; } String getUsername(); void setUsername(String username); String getPassword(); void setPassword(String password); Boolean isRememberMe(); void setRememberMe(Boolean rememberMe); @Override String toString(); }### Answer: @Test public void setRememberMeTest(){ LoginVM vm = new LoginVM(); assertNull(vm.isRememberMe()); vm.setRememberMe(null); assertNull(vm.isRememberMe()); vm.setRememberMe(true); assertTrue(vm.isRememberMe()); }
### Question: LoginVM { @Override public String toString() { return "LoginVM{" + "username='" + username + '\'' + ", rememberMe=" + rememberMe + '}'; } String getUsername(); void setUsername(String username); String getPassword(); void setPassword(String password); Boolean isRememberMe(); void setRememberMe(Boolean rememberMe); @Override String toString(); }### Answer: @Test public void toStringTest(){ LoginVM vm = new LoginVM(); assertTrue(vm.toString().startsWith(LoginVM.class.getSimpleName())); String json = vm.toString().replace(LoginVM.class.getSimpleName(), ""); assertTrue(TestUtils.isValid(json)); vm = new LoginVM(); vm.setUsername("fakeUsername"); vm.setPassword("fakePassword"); vm.setRememberMe(true); json = vm.toString().replace(LoginVM.class.getSimpleName(), ""); assertTrue(TestUtils.isValid(json)); }
### Question: UserVM { public String getLogin() { return login; } UserVM(); UserVM(String login, Set<String> authorities); String getLogin(); Set<String> getAuthorities(); @Override String toString(); }### Answer: @Test public void getLoginTest() { UserVM vm = new UserVM(); assertNull(vm.getLogin()); vm = new UserVM("login", null); assertEquals("login", vm.getLogin()); }
### Question: UserVM { public Set<String> getAuthorities() { return authorities; } UserVM(); UserVM(String login, Set<String> authorities); String getLogin(); Set<String> getAuthorities(); @Override String toString(); }### Answer: @Test public void getAuthoritiesTest() throws Exception { UserVM vm = new UserVM(); assertNull(vm.getAuthorities()); Set<String> set = new HashSet<>(); set.add("authorities1"); set.add("authorities2"); vm = new UserVM("login", set); assertEquals(set, vm.getAuthorities()); }
### Question: UserVM { @Override public String toString() { return "UserVM{" + "login='" + login + '\'' + ", authorities=" + authorities + "}"; } UserVM(); UserVM(String login, Set<String> authorities); String getLogin(); Set<String> getAuthorities(); @Override String toString(); }### Answer: @Test public void toStringTest() throws Exception { UserVM vm = new UserVM(); assertTrue(vm.toString().startsWith(UserVM.class.getSimpleName())); String json = vm.toString().replace(UserVM.class.getSimpleName(), ""); assertTrue(TestUtils.isValid(json)); Set<String> set = new HashSet<>(); set.add("authorities1"); set.add("authorities2"); vm = new UserVM("fakeLogin",set); json = vm.toString().replace(UserVM.class.getSimpleName(), ""); assertTrue(TestUtils.isValid(json)); }
### Question: MockNakadiPublishingClient implements NakadiPublishingClient { public synchronized List<String> getSentEvents(String eventType) { ArrayList<String> events = new ArrayList<>(); List<String> sentEvents = this.sentEvents.get(eventType); if (sentEvents != null) { events.addAll(sentEvents); } return events; } MockNakadiPublishingClient(); MockNakadiPublishingClient(ObjectMapper objectMapper); @Override synchronized void publish(String eventType, List<?> nakadiEvents); synchronized List<String> getSentEvents(String eventType); synchronized void clearSentEvents(); }### Answer: @Test public void returnsEmptyResultIfNoEventsHaveBeenSent() { assertThat(mockNakadiPublishingClient.getSentEvents("myEventType"), is(empty())); }
### Question: EventBatcher { public void finish() { if (!batch.isEmpty()) { this.publisher.accept(batch); } } EventBatcher(ObjectMapper objectMapper, Consumer<List<BatchItem>> publisher); void pushEvent(EventLog eventLogEntry, NakadiEvent nakadiEvent); void finish(); }### Answer: @Test public void shouldNotPublishEmptyBatches() { eventBatcher.finish(); verify(publisher, never()).accept(any()); }
### Question: TracerFlowIdComponent implements FlowIdComponent { @Override public void startTraceIfNoneExists() { if (tracer != null) { try { tracer.get(X_FLOW_ID).getValue(); } catch (IllegalArgumentException e) { log.warn("No trace was configured for the name {}. Returning null. " + "To configure Tracer provide an application property: " + "tracer.traces.X-Flow-ID=flow-id", X_FLOW_ID); } catch (IllegalStateException e) { tracer.start(); } } else { log.warn("No bean of class Tracer was found."); } } TracerFlowIdComponent(Tracer tracer); String getXFlowIdKey(); @Override String getXFlowIdValue(); @Override void startTraceIfNoneExists(); }### Answer: @Test public void makeSureTraceWillBeStartedIfNoneHasBeenStartedBefore() { TracerFlowIdComponent flowIdComponent = new TracerFlowIdComponent(tracer); when(tracer.get("X-Flow-ID").getValue()).thenThrow(new IllegalStateException()); flowIdComponent.startTraceIfNoneExists(); verify(tracer).start(); } @Test public void wontFailIfTraceHasNotBeenConfiguredInStartTrace() { TracerFlowIdComponent flowIdComponent = new TracerFlowIdComponent(tracer); when(tracer.get("X-Flow-ID")).thenThrow(new IllegalArgumentException()); flowIdComponent.startTraceIfNoneExists(); } @Test public void makeSureTraceWillNotStartedIfOneExists() { TracerFlowIdComponent flowIdComponent = new TracerFlowIdComponent(tracer); when(tracer.get("X-Flow-ID").getValue()).thenReturn("A_FUNKY_VALUE"); flowIdComponent.startTraceIfNoneExists(); verify(tracer, never()).start(); }
### Question: BaseRemoteAccessApi { public DefaultCrumbIssuer getCrumb() throws ApiException { ApiResponse<DefaultCrumbIssuer> resp = getCrumbWithHttpInfo(); return resp.getData(); } BaseRemoteAccessApi(); BaseRemoteAccessApi(ApiClient apiClient); ApiClient getApiClient(); void setApiClient(ApiClient apiClient); com.squareup.okhttp.Call getCrumbCall(final ProgressResponseBody.ProgressListener progressListener, final ProgressRequestBody.ProgressRequestListener progressRequestListener); DefaultCrumbIssuer getCrumb(); ApiResponse<DefaultCrumbIssuer> getCrumbWithHttpInfo(); com.squareup.okhttp.Call getCrumbAsync(final ApiCallback<DefaultCrumbIssuer> callback); }### Answer: @Test public void getCrumbTest() throws ApiException { DefaultCrumbIssuer response = api.getCrumb(); }
### Question: XmlModelLoader extends ModelLoader<XmlModel, InputStream> { @Override public XmlModel loadModel(InputStream xmlStream) throws ModelException { if (xmlStream == null) { throw new ModelException("XML model is not valid [null]."); } try { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); DocumentBuilder db = dbf.newDocumentBuilder(); Document doc = db.parse(xmlStream); return new XmlModel(new XmlDocument(doc)); } catch (IOException ioe) { logger.error(ioe, "Cannot load XML model."); throw new XmlModelException("Cannot load XML model", ioe); } catch (ParserConfigurationException pce) { logger.error(pce, "Cannot parse XML file model."); throw new XmlModelException("Cannot parse XML model", pce); } catch (SAXException se) { logger.error(se, "Cannot parse XML file model."); throw new XmlModelException("Cannot parse XML model.", se); } } @Override XmlModel loadModel(InputStream xmlStream); }### Answer: @Test public void testLoadXML() throws Exception { XmlModelLoader loader = new XmlModelLoader(); File file = new File("conf/test/xml/sample.xml"); XmlModel model = loader.loadModel(new FileInputStream(file)); Assert.assertNotNull(model); Assert.assertEquals(1, model.getDocuments().size()); Document doc = model.getDocuments().get(0).getDocument(); Assert.assertNotNull(doc); Element element = doc.getDocumentElement(); Assert.assertNotNull(element); }
### Question: UmlModelLoader extends ModelLoader<UmlModel, File> { @Override public UmlModel loadModel(File modelFile) throws UmlModelException { if (modelFile == null) { return new UmlModel(UmlModelProducer.getInstance().createUmlModel(null)); } try { Model model = getUmlRootModel(modelFile); UmlModel umlModel = new UmlModel(model); return umlModel; } catch (IOException e) { logger.error(e, "Canot load Template " + modelFile.getName()); throw new UmlModelException("Cannot load Template " + modelFile.getName(), e); } catch (RuntimeException re) { logger.error(re, "Canot load Template " + modelFile.getName()); throw new UmlModelException("Cannot load Template " + modelFile.getName(), re); } } @Override UmlModel loadModel(File modelFile); }### Answer: @Test public void testLoadModel() throws ModelException { UmlModelLoader loader = new UmlModelLoader(); UmlModel umlModel = loader.loadModel(new File("conf/template/uml/sample.uml")); Assert.assertNotNull(umlModel); Assert.assertNotNull(umlModel.getModel()); Assert.assertSame(ModelImpl.class, umlModel.getModel().getClass()); }
### Question: ReceiverServiceImpl implements ReceiverService { @Override public void receive(ProbeJson probeJson) { concurrentDataList.addProbeJson(probeJson); } @Override void receive(ProbeJson probeJson); @Override @Scheduled(cron = "0 0/20 7-23 * * ?") void commit(); @Override RealTimeJson statLatest(); }### Answer: @Test public void receive() throws Exception { receiverService.receive(new ProbeJson()); Thread.sleep(1000); System.out.println(ConcurrentDataList.instance().getAll().size()); }
### Question: UserDaoImpl implements UserDao { @Override public UserEntity save(UserEntity userEntity) { return userRepository.save(userEntity); } @Override UserEntity findById(int id); @Override UserEntity findByName(String name); @Override UserEntity findByNameAndPassword(String name, String password); @Override UserEntity save(UserEntity userEntity); @Override void delete(int id); }### Answer: @Test @Rollback @Transactional public void save() throws Exception { }
### Question: UserDaoImpl implements UserDao { @Override public void delete(int id) { userRepository.delete(id); } @Override UserEntity findById(int id); @Override UserEntity findByName(String name); @Override UserEntity findByNameAndPassword(String name, String password); @Override UserEntity save(UserEntity userEntity); @Override void delete(int id); }### Answer: @Test public void delete() throws Exception { }
### Question: NewOldServiceImpl implements NewOldService { @Override public List<NewOldVo> getNewOldStat(int startHour, QueryThreshold threshold, int startRange, String probeId) throws ParamException { if (threshold==null) throw new ParamException(ServerCode.PARAM_FORMAT,"threshold","threshold cannot be null"); return newOldDao.getNewOldStat(startHour, threshold, startRange, probeId); } @Override List<NewOldVo> getNewOldStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override NewOldVo findById(int id); @Override NewOldVo save(NewOldCustomElement newOldCustomElement); }### Answer: @Test public void getNewOldStat() throws Exception { System.out.println(newOldService .getNewOldStat((int)(System.currentTimeMillis()/(3600*1000)-1), QueryThreshold.HOUR,10,null)); }
### Question: NewOldServiceImpl implements NewOldService { @Override public List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId) { return ObjectMapper.convertToChartData(newOldDao.findByHourAndProbe(hour, probeId)); } @Override List<NewOldVo> getNewOldStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override NewOldVo findById(int id); @Override NewOldVo save(NewOldCustomElement newOldCustomElement); }### Answer: @Test public void findByHourAndProbe() throws Exception { }
### Question: NewOldServiceImpl implements NewOldService { @Override public NewOldVo findById(int id) throws ServerException { NewOldEntity entity = newOldDao.findById(id); if (entity == null) throw new ServerException(ServerCode.NOT_FOUND); return new NewOldVo(entity); } @Override List<NewOldVo> getNewOldStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override NewOldVo findById(int id); @Override NewOldVo save(NewOldCustomElement newOldCustomElement); }### Answer: @Test public void findById() throws Exception { }
### Question: NewOldServiceImpl implements NewOldService { @Override public NewOldVo save(NewOldCustomElement newOldCustomElement) { NewOldEntity entity = new NewOldEntity(); entity.setWifiProb(newOldCustomElement.getWifiProb()); entity.setHour(new Timestamp(newOldCustomElement.getHour()36001000)); entity.setNewCustomer(newOldCustomElement.getNewCustomer()); entity.setOldCustomer(newOldCustomElement.getOldCustomer()); return new NewOldVo(newOldDao.save(entity)); } @Override List<NewOldVo> getNewOldStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override NewOldVo findById(int id); @Override NewOldVo save(NewOldCustomElement newOldCustomElement); }### Answer: @Test public void save() throws Exception { }
### Question: UserServiceImpl implements UserService { @Override public UserVo login(String username, String password) throws ServerException { UserEntity userEntity = userDao.findByName(username); if (userEntity==null) throw new ServerException(ServerCode.USER_NOT_FOUND); if (!userEntity.getPassword().equals(password)) throw new ServerException(ServerCode.ERROR_PASSWORD); return new UserVo(userEntity); } @Override UserVo login(String username, String password); @Override UserVo register(String username, String password); @Override UserVo changePassword(String username, String oldPassword, String newPassword); }### Answer: @Test public void login() throws Exception { System.out.println(userService.login("admin","admin")); try { userService.login("admin","ha"); fail(); } catch (ServerException e) { System.out.println(e.getMessage()); } }
### Question: ActivenessServiceImpl implements ActivenessService { @Override public List<ActivenessVo> getActivenessStat(int startHour, QueryThreshold threshold, int startRange, String probeId) throws ParamException { if (threshold==null) throw new ParamException(ServerCode.PARAM_FORMAT,"threshold","threshold cannot be null"); return activenessDao.getActivenessStat(startHour, threshold, startRange, probeId); } @Override List<ActivenessVo> getActivenessStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override ActivenessVo findById(int id); @Override ActivenessVo save(CustomerActivenessElement activenessElement); }### Answer: @Test public void getActivenessStat() throws Exception { System.out.println(activenessService .getActivenessStat((int)(System.currentTimeMillis()/(3600*1000)), QueryThreshold.HOUR,10,null)); }
### Question: ActivenessServiceImpl implements ActivenessService { @Override public List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId) { ActivenessEntity activenessEntity = activenessDao.findByHourAndProbe(hour, probeId); return ObjectMapper.convertToChartData(activenessEntity); } @Override List<ActivenessVo> getActivenessStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override ActivenessVo findById(int id); @Override ActivenessVo save(CustomerActivenessElement activenessElement); }### Answer: @Test public void findByHourAndProbe() throws Exception { System.out.println(activenessService.findByHourAndProbe((int)(System.currentTimeMillis()/(3600*1000)),"1s12sz")); }
### Question: ActivenessServiceImpl implements ActivenessService { @Override public ActivenessVo findById(int id) throws ServerException { ActivenessEntity entity = activenessDao.findById(id); if (entity==null) throw new ServerException(ServerCode.NOT_FOUND); return new ActivenessVo(entity); } @Override List<ActivenessVo> getActivenessStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override ActivenessVo findById(int id); @Override ActivenessVo save(CustomerActivenessElement activenessElement); }### Answer: @Test public void findById() throws Exception { System.out.println(activenessService.findById(1)); }
### Question: ReceiverServiceImpl implements ReceiverService { @Override @Scheduled(cron = "0 0/20 7-23 * * ?") public void commit() { new Thread( () -> { try { if (concurrentDataList.getSize()>0) { int sleep = (int) (Math.random()60000); try { Thread.sleep(sleep); } catch (InterruptedException e) { e.printStackTrace(); } List<ProbeJson> probeJsons = concurrentDataList.getAll(); InputStream inputStream = new ByteArrayInputStream(GsonTool.convertObjectToJson(probeJsons).getBytes()); try { Calendar c = Calendar.getInstance(); HDFSTool.uploadFiles(inputStream, String.valueOf(c.get(Calendar.YEAR)) + "-" + (c.get(Calendar.MONTH) + 1) + "-" + c.get(Calendar.DATE) + "/" + c.get(Calendar.MILLISECOND) + "-" + receiverConfig.getName()+".json"); } catch (Exception e) { e.printStackTrace(); } } } catch (Exception e) { e.printStackTrace(); } }).start(); } @Override void receive(ProbeJson probeJson); @Override @Scheduled(cron = "0 0/20 7-23 * ?") void commit(); @Override RealTimeJson statLatest(); }### Answer: @Test public void commit() throws Exception { }
### Question: ActivenessServiceImpl implements ActivenessService { @Override public ActivenessVo save(CustomerActivenessElement activenessElement) { ActivenessEntity entity = new ActivenessEntity(); entity.setWifiProb(activenessElement.getWifiProb()); entity.setHour(new Timestamp(activenessElement.getHour()36001000)); entity.setNumOfHighActive(activenessElement.getNumOfHighActive()); entity.setNumOfMedianActive(activenessElement.getNumOfMedianActive()); entity.setNumOfLowActive(activenessElement.getNumOfLowActive()); entity.setNumOfSleepActive(activenessElement.getNumOfSleepActive()); return new ActivenessVo(activenessDao.save(entity)); } @Override List<ActivenessVo> getActivenessStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override ActivenessVo findById(int id); @Override ActivenessVo save(CustomerActivenessElement activenessElement); }### Answer: @Test public void save() throws Exception { }
### Question: VisitCircleServiceImpl implements VisitCircleService { @Override public List<VisitCircleVo> getVisitCircleStat(int startHour, QueryThreshold threshold, int startRange, String probeId) throws ParamException { if (threshold==null) throw new ParamException(ServerCode.PARAM_FORMAT,"threshold","threshold cannot be null"); return visitCircleDao.getVisitCircleStat(startHour, threshold, startRange, probeId); } @Override List<VisitCircleVo> getVisitCircleStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override VisitCircleVo findById(int id); @Override VisitCircleVo save(VisitingCycleElement visitingCycleElement); }### Answer: @Test public void getVisitCircleStat() throws Exception { System.out.println(visitCircleService .getVisitCircleStat((int)(System.currentTimeMillis()/(3600*1000)-1), QueryThreshold.HOUR,10,null)); }
### Question: VisitCircleServiceImpl implements VisitCircleService { @Override public List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId) { return ObjectMapper.convertToViewData( ObjectMapper.convertToChartData(visitCircleDao.findByHourAndProbe(hour, probeId)), ConvertType.circle); } @Override List<VisitCircleVo> getVisitCircleStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override VisitCircleVo findById(int id); @Override VisitCircleVo save(VisitingCycleElement visitingCycleElement); }### Answer: @Test public void findByHourAndProbe() throws Exception { System.out.println((int)(System.currentTimeMillis()/(36001000)-1)); System.out.println(visitCircleService.findByHourAndProbe((int)(System.currentTimeMillis()/(36001000)),"1s12sz")); }
### Question: VisitCircleServiceImpl implements VisitCircleService { @Override public VisitCircleVo findById(int id) throws ServerException { VisitCircleEntity visitCircleEntity = visitCircleDao.findById(id); if (visitCircleEntity==null) throw new ServerException(ServerCode.NOT_FOUND); return new VisitCircleVo(visitCircleEntity); } @Override List<VisitCircleVo> getVisitCircleStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override VisitCircleVo findById(int id); @Override VisitCircleVo save(VisitingCycleElement visitingCycleElement); }### Answer: @Test public void findById() throws Exception { }
### Question: VisitCircleServiceImpl implements VisitCircleService { @Override public VisitCircleVo save(VisitingCycleElement visitingCycleElement) { VisitCircleEntity entity = new VisitCircleEntity(); entity.setWifiProb(visitingCycleElement.getWifiProb()); entity.setHour(new Timestamp(visitingCycleElement.getHour()36001000)); List<Tuple<Long,Integer>> data = visitingCycleElement.getStatistic(); int setIndex = 0; Field[] fields = VisitCircleEntity.class.getDeclaredFields(); for (;setIndex<fields.length-3 && setIndex < data.size(); setIndex++) { Field field = fields[setIndex+3]; field.setAccessible(true); try { field.set(entity,data.get(setIndex).getY()); } catch (IllegalAccessException e) { System.out.println(); } field.setAccessible(false); } return new VisitCircleVo(visitCircleDao.save(entity)); } @Override List<VisitCircleVo> getVisitCircleStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override VisitCircleVo findById(int id); @Override VisitCircleVo save(VisitingCycleElement visitingCycleElement); }### Answer: @Test public void save() throws Exception { }
### Question: ProbeServiceImpl implements ProbeService { @Override public Page<ProbeVo> findAll(int page, int size) { Page<ProbeEntity> probeEntities = probeDao.findAll(page, size); return new PageImpl<>(probeEntities.getContent().stream().map(ProbeVo::new).collect(Collectors.toList()), probeEntities.nextPageable(),probeEntities.getTotalElements()); } @Override Page<ProbeVo> findAll(int page, int size); @Override ProbeVo findById(int id); }### Answer: @Test public void findAll() throws Exception { System.out.println(probeService.findAll(0,10).getContent()); }
### Question: ProbeServiceImpl implements ProbeService { @Override public ProbeVo findById(int id) throws ServerException { ProbeEntity probeEntity = probeDao.findById(id); if (probeEntity==null) throw new ServerException(ServerCode.NOT_FOUND); return new ProbeVo(probeEntity); } @Override Page<ProbeVo> findAll(int page, int size); @Override ProbeVo findById(int id); }### Answer: @Test public void findById() throws Exception { System.out.println(probeService.findById(1)); }
### Question: FlowServiceImpl implements FlowService { @Override public List<FlowVo> getFStat(int startHour, QueryThreshold threshold, int startRange, String probeId) throws ParamException { if (threshold==null) throw new ParamException(ServerCode.PARAM_FORMAT,"threshold","threshold cannot be null"); return flowDao.getFlowStat(startHour, threshold, startRange, probeId); } @Override List<FlowVo> getFStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override FlowVo findById(int id); @Override FlowVo save(CustomerFlowElement flowElement); }### Answer: @Test public void getFStat() throws Exception { System.out.println(flowService .getFStat((int)(System.currentTimeMillis()/(3600*1000)-1), QueryThreshold.HOUR,10,null)); }
### Question: FlowServiceImpl implements FlowService { @Override public List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId) { return ObjectMapper.convertToChartData(flowDao.findByHourAndProbe(hour, probeId)); } @Override List<FlowVo> getFStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override FlowVo findById(int id); @Override FlowVo save(CustomerFlowElement flowElement); }### Answer: @Test public void findByHourAndProbe() throws Exception { System.out.println(flowService.findByHourAndProbe((int)(System.currentTimeMillis()/(3600*1000)-1),"1s12sz")); }
### Question: FlowServiceImpl implements FlowService { @Override public FlowVo findById(int id) throws ServerException { FlowEntity entity = flowDao.findById(id); if (entity==null) throw new ServerException(ServerCode.NOT_FOUND); return new FlowVo(entity); } @Override List<FlowVo> getFStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override FlowVo findById(int id); @Override FlowVo save(CustomerFlowElement flowElement); }### Answer: @Test public void findById() throws Exception { }
### Question: HttpTools { public static URLConnection sendGet(String url) { try { URL realUrl = new URL(url); URLConnection connection = realUrl.openConnection(); connection.setRequestProperty("connection", "Keep-Alive"); connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)"); connection.setConnectTimeout(200); connection.connect(); return connection; } catch (IOException e) { return null; } } static URLConnection sendGet(String url); static String getLocalIp(); }### Answer: @Test public void sendGet() throws Exception { URLConnection connection = HttpTools.sendGet("http: Map<String, List<String>> map = connection.getHeaderFields(); for (String key : map.keySet()) { System.out.println(key + "--->" + map.get(key)); } }
### Question: FlowServiceImpl implements FlowService { @Override public FlowVo save(CustomerFlowElement flowElement) { FlowEntity flowEntity = new FlowEntity(); flowEntity.setWifiProb(flowElement.getWifiProb()); flowEntity.setHour(new Timestamp(flowElement.getHour()36001000)); flowEntity.setInNoOutWifi(flowElement.getInNoOutWifi()); flowEntity.setInNoOutStore(flowElement.getInNoOutStore()); flowEntity.setOutNoInWifi(flowElement.getOutNoInWifi()); flowEntity.setOutNoInStore(flowElement.getOutNoInStore()); flowEntity.setInAndOutWifi(flowElement.getInAndOutWifi()); flowEntity.setIntAndOutStore(flowElement.getInAndOutStore()); flowEntity.setStayInWifi(flowElement.getStayInWifi()); flowEntity.setStayInStore(flowElement.getStayInStore()); flowEntity.setJumpRate(flowElement.getJumpRate()); flowEntity.setInStoreRate(flowElement.getInStoreRate()); flowEntity.setDeepVisit(flowElement.getDeepVisit()); return new FlowVo(flowDao.save(flowEntity)); } @Override List<FlowVo> getFStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override FlowVo findById(int id); @Override FlowVo save(CustomerFlowElement flowElement); }### Answer: @Test public void save() throws Exception { }
### Question: StoreHoursServiceImpl implements StoreHoursService { @Override public List<StoreHoursVo> getStoreHoursStat(int startHour, QueryThreshold threshold, int startRange, String probeId) throws ParamException { if (threshold==null) throw new ParamException(ServerCode.PARAM_FORMAT,"threshold","threshold cannot be null"); return storeHoursDao.getStoreHoursStat(startHour, threshold, startRange, probeId); } @Override List<StoreHoursVo> getStoreHoursStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override StoreHoursVo findById(int id); @Override StoreHoursVo save(InStoreHoursElement storeHoursElement); }### Answer: @Test public void getStoreHoursStat() throws Exception { System.out.println(storeHoursService .getStoreHoursStat((int)(System.currentTimeMillis()/(3600*1000)-1000), QueryThreshold.DAY,30,null)); }
### Question: StoreHoursServiceImpl implements StoreHoursService { @Override public List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId) { return ObjectMapper.convertToViewData( ObjectMapper.convertToChartData(storeHoursDao.findByHourAndProbe(hour, probeId)), ConvertType.store); } @Override List<StoreHoursVo> getStoreHoursStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override StoreHoursVo findById(int id); @Override StoreHoursVo save(InStoreHoursElement storeHoursElement); }### Answer: @Test public void findByHourAndProbe() throws Exception { System.out.println(storeHoursService.findByHourAndProbe((int)(System.currentTimeMillis()/(3600*1000)),"1s12sz")); }
### Question: StoreHoursServiceImpl implements StoreHoursService { @Override public StoreHoursVo findById(int id) throws ServerException { StoreHoursEntity entity = storeHoursDao.findById(id); if (entity==null) throw new ServerException(ServerCode.NOT_FOUND); return new StoreHoursVo(entity); } @Override List<StoreHoursVo> getStoreHoursStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override StoreHoursVo findById(int id); @Override StoreHoursVo save(InStoreHoursElement storeHoursElement); }### Answer: @Test public void findById() throws Exception { }
### Question: StoreHoursServiceImpl implements StoreHoursService { @Override public StoreHoursVo save(InStoreHoursElement storeHoursElement) { StoreHoursEntity entity = new StoreHoursEntity(); entity.setWifiProb(storeHoursElement.getWifiProb()); entity.setHour(new Timestamp(storeHoursElement.getHour()36001000)); List<Tuple<Long,Integer>> data = storeHoursElement.getStatistic(); int setIndex = 0; Field[] fields = StoreHoursEntity.class.getDeclaredFields(); for (;setIndex<fields.length-3 && setIndex < data.size(); setIndex++) { Field field = fields[setIndex+3]; field.setAccessible(true); try { field.set(entity,data.get(setIndex).getY()); } catch (IllegalAccessException e) { e.printStackTrace(); } field.setAccessible(false); } return new StoreHoursVo(storeHoursDao.save(entity)); } @Override List<StoreHoursVo> getStoreHoursStat(int startHour, QueryThreshold threshold, int startRange, String probeId); @Override List<Tuple<String, Number>> findByHourAndProbe(int hour, String probeId); @Override StoreHoursVo findById(int id); @Override StoreHoursVo save(InStoreHoursElement storeHoursElement); }### Answer: @Test public void save() throws Exception { }
### Question: HttpTools { public static String getLocalIp() { InputStream inputStream = HttpTools.class.getClassLoader().getResourceAsStream("config/ipconfig"); BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream)); try { String config = reader.readLine(); Enumeration<NetworkInterface> netInterfaces; try { netInterfaces = NetworkInterface.getNetworkInterfaces(); } catch (SocketException e) { e.printStackTrace(); return null; } while (netInterfaces.hasMoreElements()) { NetworkInterface ni = netInterfaces.nextElement(); if (ni.getDisplayName().equals(config)) { Enumeration<InetAddress> ia = ni.getInetAddresses(); while (ia.hasMoreElements()) { InetAddress ip = ia.nextElement(); String ipStr = ip.getHostAddress(); if (ipStr.length() < 17) return ipStr; } } } } catch (IOException e) { e.printStackTrace(); } return null; } static URLConnection sendGet(String url); static String getLocalIp(); }### Answer: @Test public void getLocalIp() throws Exception { System.out.println(HttpTools.getLocalIp()); }
### Question: ActivenessDaoImpl implements ActivenessDao { @Override public List<ActivenessVo> getActivenessStat(int startHour, QueryThreshold threshold, int statRange, String probeId) { String isProbeSelected = probeId==null \|\| probeId.isEmpty()? "": "AND wifiProb = :probeId "; String sqlQuery = "SELECT wifiProb,DATE_FORMAT(hour,:dateFormat),sum(numOfHighActive)," + "sum(numOfMedianActive),sum(numOfLowActive),sum(numOfSleepActive) " + "FROM activeness " + "WHERE UNIX_TIMESTAMP(hour) >= (:startHour3600) " + isProbeSelected+ " GROUP BY wifiProb,DATE_FORMAT(hour,:dateFormat) " + "LIMIT 0,:statRange"; Query query = entityManager.createNativeQuery(sqlQuery); query.setParameter("dateFormat", ThresholdUtil.convertToString(threshold)); query.setParameter("startHour",startHour); if (!isProbeSelected.isEmpty()) query.setParameter("probeId",probeId); query.setParameter("statRange",statRange>=1? statRange: 10); List resultList = query.getResultList(); List<ActivenessVo> activenessVos = new LinkedList<>(); for (Object object: resultList) { activenessVos.add((ActivenessVo) ObjectMapper.arrayToObject(ActivenessVo.class,object)); } return activenessVos; } @Override List<ActivenessVo> getActivenessStat(int startHour, QueryThreshold threshold, int statRange, String probeId); @Override ActivenessEntity findByHourAndProbe(int hour, String probeId); @Override ActivenessEntity findById(int id); @Override ActivenessEntity save(ActivenessEntity entity); }### Answer: @Test public void getActivenessStat() throws Exception { long time = System.currentTimeMillis(); int hour = (int) (time/(100060*60)); System.out.println(activenessDao.getActivenessStat(hour, QueryThreshold.HOUR, 10, null)); }
### Question: ActivenessDaoImpl implements ActivenessDao { @Override public ActivenessEntity findByHourAndProbe(int hour, String probeId) { Timestamp timestamp = new Timestamp(((long) hour)36001000); System.out.println(timestamp.getTime()); return activenessRepository.findByHourAndWifiProb(timestamp,probeId); } @Override List<ActivenessVo> getActivenessStat(int startHour, QueryThreshold threshold, int statRange, String probeId); @Override ActivenessEntity findByHourAndProbe(int hour, String probeId); @Override ActivenessEntity findById(int id); @Override ActivenessEntity save(ActivenessEntity entity); }### Answer: @Test public void findByHourAndProbe() throws Exception { }
### Question: ActivenessDaoImpl implements ActivenessDao { @Override public ActivenessEntity findById(int id) { return activenessRepository.findOne(id); } @Override List<ActivenessVo> getActivenessStat(int startHour, QueryThreshold threshold, int statRange, String probeId); @Override ActivenessEntity findByHourAndProbe(int hour, String probeId); @Override ActivenessEntity findById(int id); @Override ActivenessEntity save(ActivenessEntity entity); }### Answer: @Test public void findById() throws Exception { }
### Question: ActivenessDaoImpl implements ActivenessDao { @Override public ActivenessEntity save(ActivenessEntity entity) { return activenessRepository.save(entity); } @Override List<ActivenessVo> getActivenessStat(int startHour, QueryThreshold threshold, int statRange, String probeId); @Override ActivenessEntity findByHourAndProbe(int hour, String probeId); @Override ActivenessEntity findById(int id); @Override ActivenessEntity save(ActivenessEntity entity); }### Answer: @Test public void save() throws Exception { }
### Question: UserDaoImpl implements UserDao { @Override public UserEntity findById(int id) { return userRepository.findOne(id); } @Override UserEntity findById(int id); @Override UserEntity findByName(String name); @Override UserEntity findByNameAndPassword(String name, String password); @Override UserEntity save(UserEntity userEntity); @Override void delete(int id); }### Answer: @Test public void findById() throws Exception { System.out.println(userDao.findById(1).getUsername()); }
### Question: UserDaoImpl implements UserDao { @Override public UserEntity findByName(String name) { return userRepository.findByUsername(name); } @Override UserEntity findById(int id); @Override UserEntity findByName(String name); @Override UserEntity findByNameAndPassword(String name, String password); @Override UserEntity save(UserEntity userEntity); @Override void delete(int id); }### Answer: @Test public void findByName() throws Exception { System.out.println(userDao.findByName("admin")); }
### Question: PotentiometerSimulator implements ISimulatorUpdater { public boolean isSetup() { return mIsSetup; } PotentiometerSimulator(IAnalogInWrapper aWrapper, IPwmWrapper aSpeedController); void setParameters(double aThrow, double aMinVoltage, double aMaxVoltage); @Override void update(); boolean isSetup(); @Override Object getConfig(); }### Answer: @Test public void testIncompletePotSim() { PotentiometerSimulator pot = new PotentiometerSimulator(null, null); Assertions.assertFalse(pot.isSetup()); new AnalogInput(0); pot = new PotentiometerSimulator(SensorActuatorRegistry.get().getAnalogIn().get(0), null); Assertions.assertFalse(pot.isSetup()); }
### Question: CompressorWrapper extends ASensorWrapper { public CompressorWrapper() { super("Compressor"); mAirPressure = 120; mChargeRate = .25; } CompressorWrapper(); void setChargeRate(double aChargeRate); void solenoidFired(double aPressure); void update(); double getAirPressure(); }### Answer: @Test public void testCompressorWrapper() { CompressorWrapper compressor = new CompressorWrapper(); compressor.setChargeRate(.1); Assertions.assertEquals(120, compressor.getAirPressure(), DOUBLE_EPSILON); compressor.solenoidFired(60); Assertions.assertEquals(60, compressor.getAirPressure(), DOUBLE_EPSILON); simulateForTime(2, () -> { compressor.update(); }); Assertions.assertEquals(70, compressor.getAirPressure(), DOUBLE_EPSILON); compressor.solenoidFired(90); Assertions.assertEquals(0, compressor.getAirPressure(), DOUBLE_EPSILON); simulateForTime(30, () -> { compressor.update(); }); Assertions.assertEquals(120, compressor.getAirPressure(), DOUBLE_EPSILON); }
### Question: XboxJoystick extends BaseJoystick { @Override public float[] getAxisValues() { float[] output = super.getAxisValues(); float triggerValue = output[2]; if (triggerValue < 0) { output[2] = 0; output[3] = triggerValue; } else { output[2] = triggerValue; output[3] = 0; } return output; } XboxJoystick(Controller aController); XboxJoystick(Controller aController, String aName); @Override float[] getAxisValues(); }### Answer: @Test public void testKeyboardJoystick() throws Exception { XboxJoystick joystick = new XboxJoystick(new MockController()); float[] axisValues = joystick.getAxisValues(); short[] povValues = joystick.getPovValues(); int buttonMask = joystick.getButtonMask(); Assertions.assertEquals(6, axisValues.length); Assertions.assertEquals(1, povValues.length); Assertions.assertEquals(0, buttonMask); }
### Question: GuavaUtils { public static <T> boolean isPresent(T t){ Optional<T>optionalObj = Optional.fromNullable(t); return optionalObj.isPresent(); } static boolean isPresent(T t); }### Answer: @Test public void isPresentTest(){ B1 b = null; assertEquals(false, GuavaUtils.isPresent(b)); b = new B1(); assertEquals(true, GuavaUtils.isPresent(b)); }
### Question: DozerUtils { public static <T> T convertSourceObjToDesObj(Object source,Class<T> destinationClass){ return mapper.map(source, destinationClass); } static T convertSourceObjToDesObj(Object source,Class<T> destinationClass); static void main(String[] args); }### Answer: @Test public void testDozer(){ B1 b = new B1(); b.setName("sa"); B2 b2 = DozerUtils.convertSourceObjToDesObj(b, B2.class); Assert.assertEquals("sa", b2.getAge()); }
### Question: AgentMaster { private AgentMaster(SmartConf conf) throws IOException { String[] addresses = AgentUtils.getMasterAddress(conf); if (addresses == null) { throw new IOException("AgentMaster address not configured!"); } String address = addresses[0]; LOG.info("Agent master: " + address); Config config = AgentUtils.overrideRemoteAddress( ConfigFactory.load(AgentConstants.AKKA_CONF_FILE), address); CmdletDispatcherHelper.init(); this.agentManager = new AgentManager(); Props props = Props.create(MasterActor.class, null, agentManager); ActorSystemLauncher launcher = new ActorSystemLauncher(config, props); launcher.start(); } private AgentMaster(SmartConf conf); static AgentMaster getAgentMaster(); static AgentMaster getAgentMaster(SmartConf conf); boolean isAgentRegisterReady(SmartConf conf); boolean isTikvAlreadyLaunched(SmartConf conf); void sendLaunchTikvMessage(); static void setCmdletManager(CmdletManager statusUpdater); boolean canAcceptMore(); String launchCmdlet(LaunchCmdlet launch); void stopCmdlet(long cmdletId); void shutdown(); List<AgentInfo> getAgentInfos(); int getNumAgents(); static final Timeout TIMEOUT; }### Answer: @Test public void testAgentMaster() throws Exception { AgentMaster master = AgentMaster.getAgentMaster(); while (master.getMasterActor() == null) { } String instId = "instance-0"; Object answer = master.askMaster(AgentToMaster.RegisterNewAgent.getInstance(instId)); assertTrue(answer instanceof MasterToAgent.AgentRegistered); MasterToAgent.AgentRegistered registered = (MasterToAgent.AgentRegistered) answer; assertEquals(instId, registered.getAgentId().getId()); }
### Question: SecurityUtil { public static void loginUsingKeytab(SmartConf conf) throws IOException{ String keytabFilename = conf.get(SmartConfKeys.SMART_SERVER_KEYTAB_FILE_KEY); if (keytabFilename == null \|\| keytabFilename.length() == 0) { throw new IOException("Running in secure mode, but config doesn't have a keytab"); } File keytabPath = new File(keytabFilename); String principal = conf.get(SmartConfKeys.SMART_SERVER_KERBEROS_PRINCIPAL_KEY); try { SecurityUtil.loginUsingKeytab(principal, keytabPath.getAbsolutePath()); } catch (IOException e) { LOG.error("Fail to login using keytab. " + e); throw new IOException("Fail to login using keytab. " + e); } LOG.info("Login successful for user: " + principal); } static synchronized Subject loginUserFromTgtTicket(String smartSecurity); static Subject loginUsingTicketCache(String principal); static void loginUsingKeytab(SmartConf conf); static void loginUsingKeytab(String keytabFilename, String principal); static Subject loginUsingKeytab( String principal, File keytabFile); static Configuration useTicketCache(String principal, String ticketCacheFileName); static Configuration useKeytab(String principal, File keytabFile); static boolean isSecurityEnabled(SmartConf conf); static final Logger LOG; static final boolean ENABLE_DEBUG; }### Answer: @Test public void loginUsingKeytab() throws Exception { File keytabFile = generateKeytab(keytabFileName, principal); Subject subject = SecurityUtil.loginUsingKeytab(principal, keytabFile); Assert.assertEquals(principal, subject.getPrincipals().iterator().next().getName()); System.out.println("Login successful for user: " + subject.getPrincipals().iterator().next()); }
### Question: CustomerOrderExtractor implements PayloadWrapperExtractor<CustomerOrderPayload, CustomerOrder> { @Override public CustomerOrder extractData(PayloadWrapper<CustomerOrderPayload> payloadWrapper) { CustomerOrder value = null; if (payloadWrapper.hasPayload()) { value = new CustomerOrder(); CustomerOrderPayload payload = payloadWrapper.getPayload(); value.setCustomerId(payload.getCustomerId()); value.setShippingAddress(payload.getShippingAddress()); value.setOrderDate(payload.getOrderDate()); value.setItemSet(payload.getItemSet()); } return value; } @Override CustomerOrder extractData(PayloadWrapper<CustomerOrderPayload> payloadWrapper); }### Answer: @Test public void testExtractData() { CustomerOrderExtractor extractor = new CustomerOrderExtractor(); PayloadWrapper<CustomerOrderPayload> payloadWrapper = new PayloadWrapper<CustomerOrderPayload>(null); assertThat(extractor.extractData(payloadWrapper)).isNull(); Date orderDate = new Date(); List<String> items = Arrays.asList("item1", "item2"); CustomerOrderPayload payload = new CustomerOrderPayload(); payload.setId("id"); payload.setCustomerId("customerId"); payload.setOrderDate(orderDate.getTime()); payload.setShippingAddress("shippingAddress"); payload.setItemSet(new HashSet<>(items)); payloadWrapper = new PayloadWrapper<CustomerOrderPayload>(payload); CustomerOrder expected = new CustomerOrder(); expected.setCustomerId("customerId"); expected.setOrderDate(orderDate.getTime()); expected.setShippingAddress("shippingAddress"); expected.setItemSet(new HashSet<>(items)); assertThat(extractor.extractData(payloadWrapper)).isEqualTo(expected); }
### Question: ItemExtractor implements PayloadWrapperExtractor<ItemPayload, Item> { @Override public Item extractData(PayloadWrapper<ItemPayload> payloadWrapper) { Item value = null; if (payloadWrapper.hasPayload()) { value = new Item(); ItemPayload payload = payloadWrapper.getPayload(); value.setName(payload.getName()); value.setDescription(payload.getDescription()); value.setPrice(payload.getPrice().toString()); } return value; } @Override Item extractData(PayloadWrapper<ItemPayload> payloadWrapper); }### Answer: @Test public void testExtractData() { ItemExtractor extractor = new ItemExtractor(); PayloadWrapper<ItemPayload> payloadWrapper = new PayloadWrapper<ItemPayload>(null); assertThat(extractor.extractData(payloadWrapper)).isNull(); ItemPayload payload = new ItemPayload(); payload.setId("id"); payload.setName("name"); payload.setDescription("description"); payload.setPrice(new BigDecimal("9.99")); payloadWrapper = new PayloadWrapper<ItemPayload>(payload); Item expected = new Item(); expected.setName("name"); expected.setDescription("description"); expected.setPrice("9.99"); assertThat(extractor.extractData(payloadWrapper)).isEqualTo(expected); }
### Question: CustomerExtractor implements PayloadWrapperExtractor<CustomerPayload, Customer> { @Override public Customer extractData(PayloadWrapper<CustomerPayload> payloadWrapper) { Customer value = null; if (payloadWrapper.hasPayload()) { value = new Customer(); CustomerPayload payload = payloadWrapper.getPayload(); value.setName(payload.getName()); } return value; } @Override Customer extractData(PayloadWrapper<CustomerPayload> payloadWrapper); }### Answer: @Test public void testExtractData() { CustomerExtractor extractor = new CustomerExtractor(); PayloadWrapper<CustomerPayload> payloadWrapper = new PayloadWrapper<CustomerPayload>(null); assertThat(extractor.extractData(payloadWrapper)).isNull(); CustomerPayload payload = new CustomerPayload(); payload.setId("id"); payload.setName("name"); payloadWrapper = new PayloadWrapper<CustomerPayload>(payload); Customer expected = new Customer(); expected.setName("name"); assertThat(extractor.extractData(payloadWrapper)).isEqualTo(expected); }
### Question: ItemResultSetExtractor implements ResultSetExtractor<PayloadWrapper<ItemPayload>> { @Override public PayloadWrapper<ItemPayload> extractData(ResultSet rs) throws SQLException, DataAccessException { ItemPayload itemPayload = null; if (rs.next()) { itemPayload = new ItemPayload(); itemPayload.setId(rs.getString("ID")); itemPayload.setName(rs.getString("NAME")); itemPayload.setPrice(rs.getBigDecimal("PRICE")); itemPayload.setDescription(rs.getString("DESCRIPTION")); } return new PayloadWrapper<>(itemPayload); } @Override PayloadWrapper<ItemPayload> extractData(ResultSet rs); }### Answer: @Test public void testExtractData() throws SQLException { ItemResultSetExtractor extractor = new ItemResultSetExtractor(); ResultSet rs = mock(ResultSet.class); given(rs.next()).willReturn(true).willReturn(false); given(rs.getString("ID")).willReturn("item1"); given(rs.getString("NAME")).willReturn("item name"); given(rs.getString("DESCRIPTION")).willReturn("description"); given(rs.getBigDecimal("PRICE")).willReturn(new BigDecimal("1.99")); ItemPayload payload = new ItemPayload(); payload.setId("item1"); payload.setName("item name"); payload.setDescription("description"); payload.setPrice(new BigDecimal("1.99")); PayloadWrapper<ItemPayload> payloadWrapper = new PayloadWrapper<ItemPayload>(payload); assertThat(extractor.extractData(rs)).isEqualTo(payloadWrapper); }
### Question: CustomerResultSetExtractor implements ResultSetExtractor<PayloadWrapper<CustomerPayload>> { @Override public PayloadWrapper<CustomerPayload> extractData(ResultSet rs) throws SQLException, DataAccessException { CustomerPayload customerPayload = null; if (rs.next()) { customerPayload = new CustomerPayload(); customerPayload.setId(rs.getString("ID")); customerPayload.setName(rs.getString("NAME")); } return new PayloadWrapper<>(customerPayload); } @Override PayloadWrapper<CustomerPayload> extractData(ResultSet rs); }### Answer: @Test public void testExtractData() throws DataAccessException, SQLException { CustomerResultSetExtractor extractor = new CustomerResultSetExtractor(); ResultSet rs = mock(ResultSet.class); given(rs.next()).willReturn(true).willReturn(false); given(rs.getString("ID")).willReturn("customer1"); given(rs.getString("NAME")).willReturn("customer name"); CustomerPayload payload = new CustomerPayload(); payload.setId("customer1"); payload.setName("customer name"); PayloadWrapper<CustomerPayload> payloadWrapper = new PayloadWrapper<CustomerPayload>(payload); assertThat(extractor.extractData(rs)).isEqualTo(payloadWrapper); }
### Question: CustomerOrderResultSetExtractor implements ResultSetExtractor<PayloadWrapper<CustomerOrderPayload>> { @Override public PayloadWrapper<CustomerOrderPayload> extractData(ResultSet rs) throws SQLException, DataAccessException { CustomerOrderPayload result = null; while (rs.next()) { if (result == null) { result = new CustomerOrderPayload(); result.setId(rs.getString("ID")); result.setCustomerId(rs.getString("CUSTOMER_ID")); result.setShippingAddress(rs.getString("S_ADDRESS")); result.setOrderDate(rs.getDate("ORDER_TS").getTime()); result.setItemSet(new HashSet<String>()); } result.getItemSet().add(rs.getString("ITEM_ID")); } return new PayloadWrapper<>(result); } @Override PayloadWrapper<CustomerOrderPayload> extractData(ResultSet rs); }### Answer: @Test public void testExtractData() throws DataAccessException, SQLException { Date orderDate = new Date(12345L); List<String> items = Arrays.asList("item1", "item2"); CustomerOrderResultSetExtractor extractor = new CustomerOrderResultSetExtractor(); ResultSet rs = mock(ResultSet.class); given(rs.next()).willReturn(true).willReturn(true).willReturn(false); given(rs.getString("ID")).willReturn("order1"); given(rs.getString("CUSTOMER_ID")).willReturn("customer1"); given(rs.getString("S_ADDRESS")).willReturn("address"); given(rs.getDate("ORDER_TS")).willReturn(orderDate); given(rs.getString("ITEM_ID")).willReturn("item1").willReturn("item2"); CustomerOrderPayload payload = new CustomerOrderPayload(); payload.setId("order1"); payload.setCustomerId("customer1"); payload.setOrderDate(orderDate.getTime()); payload.setShippingAddress("address"); payload.setItemSet(new HashSet<>(items)); PayloadWrapper<CustomerOrderPayload> payloadWrapper = new PayloadWrapper<CustomerOrderPayload>(payload); assertThat(extractor.extractData(rs)).isEqualTo(payloadWrapper); }
### Question: GeodeMessageAggregator { @CorrelationStrategy public String correlation(Message<?> message) { int hashCode = message.getHeaders().get("srcKey").hashCode(); int divisor = groupCount; return "[" + (String) message.getHeaders().get("srcGroup") + "]" + ",[" + Math.floorMod(hashCode, divisor) + "]"; } GeodeMessageAggregator(ApplicationContext context, int groupCount, int batchSize); @Aggregator GeodeDataWrapper output(List<Message<PayloadWrapper>> messages); @CorrelationStrategy String correlation(Message<?> message); @ReleaseStrategy boolean canMessagesBeReleased(List<Message<?>> messages); }### Answer: @Test public void testCorrelation() { Message<PayloadWrapper<Object>> message = MessageBuilder .withPayload(new PayloadWrapper<Object>(new Object())) .setHeader("srcGroup", "foo") .setHeader("srcKey", "key1") .build(); String expectedResult = "[foo],[" + Math.floorMod("key1".hashCode(), groupCount) + "]"; assertThat(geodeMessageAggregator.correlation(message), is(expectedResult)); }
### Question: GeodeMessageAggregator { @ReleaseStrategy public boolean canMessagesBeReleased(List<Message<?>> messages) { return messages.size() >= batchSize; } GeodeMessageAggregator(ApplicationContext context, int groupCount, int batchSize); @Aggregator GeodeDataWrapper output(List<Message<PayloadWrapper>> messages); @CorrelationStrategy String correlation(Message<?> message); @ReleaseStrategy boolean canMessagesBeReleased(List<Message<?>> messages); }### Answer: @Test public void testCanMessagesBeReleased() { List<Message<?>> messages = new ArrayList<>(); Message<PayloadWrapper<Object>> message1 = MessageBuilder .withPayload(new PayloadWrapper<Object>(null)) .setHeader("srcGroup", "foo") .setHeader("srcKey", "key1") .build(); messages.add(message1); assertThat(geodeMessageAggregator.canMessagesBeReleased(messages), is(false)); Message<PayloadWrapper<Object>> message2 = MessageBuilder .withPayload(new PayloadWrapper<>(new Object())) .setHeader("srcGroup", "foo") .setHeader("srcKey", "key2") .build(); messages.add(message2); assertThat(geodeMessageAggregator.canMessagesBeReleased(messages), is(true)); }
### Question: GeodeMessageHandler { public void handleMessage(Message<GeodeDataWrapper> message) { MessageHeaders headers = message.getHeaders(); GeodeDataWrapper payload = message.getPayload(); String regionName = (String) headers.get("srcGroup"); Region<Object, Object> region = clientCache.getRegion(regionName); region.putAll(payload.getDataMapForPut()); region.removeAll(payload.getKeySetForRemove()); } GeodeMessageHandler(ClientCache clientCache); void handleMessage(Message<GeodeDataWrapper> message); }### Answer: @Test @SuppressWarnings({ "rawtypes", "unchecked" }) public void testHandleMessage() { GeodeDataWrapper geodeDataWrapper = new GeodeDataWrapper(); geodeDataWrapper.getDataMapForPut().put("key1", "value1"); geodeDataWrapper.getDataMapForPut().put("key2", "value2"); geodeDataWrapper.getKeySetForRemove().add("key1"); Message<GeodeDataWrapper> message = MessageBuilder .withPayload(geodeDataWrapper) .setHeader("srcGroup", "foo") .build(); geodeMessageHandler.handleMessage(message); ArgumentCaptor<Map> mapCaptor = ArgumentCaptor.forClass(Map.class); verify(region, times(1)).putAll(mapCaptor.capture()); assertThat(geodeDataWrapper.getDataMapForPut(), is(mapCaptor.getValue())); ArgumentCaptor<Set> setCaptor = ArgumentCaptor.forClass(Set.class); verify(region, times(1)).removeAll(setCaptor.capture()); assertThat(geodeDataWrapper.getDataMapForPut(), is(mapCaptor.getValue())); }
### Question: RollingNumber { public double getAvg(CounterDataType counterDataType) { long latestRollingSum = getTotalSum(counterDataType); return (double)(latestRollingSum) / intervals; } RollingNumber(); void addOne(CounterDataType dataType); void add(CounterDataType dataType, long value); long getTotalSum(CounterDataType dataType); double getAvg(CounterDataType counterDataType); }### Answer: @Test public void test() { for (int i = 0; i < 10; i++) { new Thread(() -> { while (true) { testMock(); } }).start(); } new Thread(() -> { try { while (true) { Thread.sleep(1000); System.out.println(rollingNumber.getAvg(CounterDataType.PASSED)); } } catch (Exception e) { } }).start(); try { System.in.read(); } catch (Exception e) { } System.out.println("程序退出"); }
### Question: FileUtils { public static List<File> getFileListByPath(String path) { return getFileListByPath(path, null); } static String getExtension(String fileName); static void writeByteArrayToFile(File file, byte[] data, boolean append); static byte[] readFileToByteArray(File file); static void writeStringToFile(File file, String data, String encoding, boolean append); static String readFileToString(File file, String encoding); static String byteCountToDisplaySize(long size); static void moveDirectoryToDirectory(File src, File destDir, boolean isCover); static void moveFileToDirectory(File srcFile, File destDir, boolean isCover); static void moveFile(File srcFile, File destFile, boolean isCover); static void copyDirectoryToDirectory(File srcDir, File destDir); static void copyDirectoryToDirectory(File srcDir, File destDir, FileFilter filter); static void copyFileToDirectory(File srcFile, File destDir); static void copyFileToDirectory(File srcFile, File destDir, boolean preserveFileDate); static void copyFile(File srcFile, File destFile); static void copyFile(File srcFile, File destFile, boolean preserveFileDate); static void deleteFileOrDirectoryQuietly(String filePath); static void deleteFileOrDirectory(String filePath, boolean deleteThisPath); static List<File> getFileListByPath(String path); static List<File> getFileListByPath(String path, FileFilter filter); static Properties readProperties(String path); static Properties readProperties(InputStream in); static void writeProperties(String path, Properties properties); static final String EMPTY; static final long ONE_KB; static final long ONE_MB; static final long ONE_GB; static final long ONE_TB; static final long ONE_PB; static final long ONE_EB; }### Answer: @Test public void testGetFileListByPath() { List<File> fileList = FileUtils.getFileListByPath("/Users/xuan/Desktop/xuan"); for (File f : fileList) { System.out.println(f.getName()); } }
### Question: Validators { public static boolean isBlank(String str) { int strLen; if (str == null \|\| (strLen = str.length()) == 0) { return true; } for (int i = 0; i < strLen; i++) { if ((Character.isWhitespace(str.charAt(i)) == false)) { return false; } } return true; } static boolean isAlphanumeric(String str); static boolean isBlank(String str); static boolean isDate(String str); static boolean isDateTime(String str); static boolean isEmail(String str); static boolean isEmpty(Object[] args); static boolean isEmpty(String str); static boolean isEmpty(Collection<T> collection); static boolean isEmptyMap(Map<K, V> map); static boolean isIdCardNumber(String str); static boolean isNumber(String str); static boolean isNumber(String str, int min, int max); static boolean isNumeric(String str); static boolean isNumeric(String str, int fractionNum); static boolean isPostcode(String str); static boolean isString(String str, int minLength, int maxLength); static boolean isTime(String str); static boolean isSimpleChinese(String str); static boolean isRegexMatch(String str, String regex); }### Answer: @Test public void testIsBlank(){ Assert.assertTrue(Validators.isBlank(null)); Assert.assertTrue(Validators.isBlank("")); Assert.assertTrue(Validators.isBlank(" ")); Assert.assertTrue(!Validators.isBlank("bob")); Assert.assertTrue(!Validators.isBlank(" bob ")); }
### Question: MathUtils { public static double add(double v1, double v2) { BigDecimal b1 = createBigDecimal(v1); BigDecimal b2 = createBigDecimal(v2); return b1.add(b2).doubleValue(); } static double add(double v1, double v2); static double div(double v1, double v2); static double div(double v1, double v2, int scale); static boolean isInvalidDouble(double v); static double mul(double v1, double v2); static double round(double v, int scale); static double sub(double v1, double v2); }### Answer: @Test public void testAdd() { System.out.println(MathUtils.add(1.1d, 1.2d)); }
### Question: Diverter { public boolean isHit(long bizId) { return hitNum(bizId) >= 0; } Diverter(DiverterConfig config); boolean isHit(long bizId); long hitNum(long bizId); }### Answer: @Test public void test() { for (long i = 0; i < 100; i++) { boolean hit = diverter.isHit(i); System.out.println("i=" + i + ".hit=" + hit); } }
### Question: UUIDUtils { public static String uuid() { return uuid.generateHex(); } private UUIDUtils(); byte[] generateBytes(); static String uuid(); }### Answer: @Test public void testUuid() { Set<String> idSet = new HashSet<>(); for (int i = 0; i < 50; i++) { new Thread(new Runnable() { @Override public void run() { for (int i = 0; i < 30000; i++) { String uuid = UUIDUtils.uuid(); if (idSet.contains(uuid)) { System.out.println("++++++++++uuid重复:" + uuid); } } } }).start(); } }
### Question: LocalKvUtils { public static String get(String path, String key) { Properties properties = getPropertiesFromPath(path); if (null == properties) { return null; } return properties.getProperty(key); } static void put(String path, String key, String value); static void put(String path, Map<String, String> map); static String get(String path, String key); static void remove(String path, String key); static void removeAll(String path); static void writeProperties(String path, Properties properties); }### Answer: @Test public void testGet() { String install = LocalKvUtils.get(path, "install"); System.out.println("==========>" + install); }
### Question: LocalKvUtils { public static void put(String path, String key, String value) { Properties properties = getPropertiesFromPath(path); if (null == properties) { return; } properties.put(key, value); writeProperties(path, properties); } static void put(String path, String key, String value); static void put(String path, Map<String, String> map); static String get(String path, String key); static void remove(String path, String key); static void removeAll(String path); static void writeProperties(String path, Properties properties); }### Answer: @Test public void testPut() { LocalKvUtils.put(path, "install", "2"); LocalKvUtils.put(path, "test", "200"); }
### Question: LocalKvUtils { public static void remove(String path, String key) { Properties properties = getPropertiesFromPath(path); if (null == properties) { return; } properties.remove(key); writeProperties(path, properties); } static void put(String path, String key, String value); static void put(String path, Map<String, String> map); static String get(String path, String key); static void remove(String path, String key); static void removeAll(String path); static void writeProperties(String path, Properties properties); }### Answer: @Test public void testRemove() { LocalKvUtils.remove(path, "test"); }
### Question: LocalKvUtils { public static void removeAll(String path) { if (null == path) { return; } File file = new File(path); if (file.exists()) { file.delete(); } } static void put(String path, String key, String value); static void put(String path, Map<String, String> map); static String get(String path, String key); static void remove(String path, String key); static void removeAll(String path); static void writeProperties(String path, Properties properties); }### Answer: @Test public void testRemoveAll() { LocalKvUtils.removeAll(path); }
### Question: Map2BeanUtils { public static <T> T map2Bean(Map<String, Object> map, Class<T> beanClass) { T obj; try { obj = beanClass.newInstance(); BeanInfo beanInfo = Introspector.getBeanInfo(beanClass); PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); for (PropertyDescriptor property : propertyDescriptors) { String key = property.getName(); if (!map.containsKey(key)) { continue; } Object value = map.get(key); Method setter = property.getWriteMethod(); setter.invoke(obj, value); } } catch (Exception e) { throw new RuntimeException(e); } return obj; } static T map2Bean(Map<String, Object> map, Class<T> beanClass); static Map<String, Object> bean2Map(Object obj); }### Answer: @Test public void testMap2Bean() { Map<String, Object> map = new HashMap<>(); map.put("name", "xuan"); map.put("age", 18); map.put("sonName", "xuanson"); Son user = Map2BeanUtils.map2Bean(map, Son.class); System.out.println("++++++++++user:" + user.getName() + "---" + user.getAge() + "---" + user.getSonName()); }
### Question: Map2BeanUtils { public static Map<String, Object> bean2Map(Object obj) { if (obj == null) { return null; } Map<String, Object> map = new HashMap<>(); try { BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass()); PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); for (PropertyDescriptor property : propertyDescriptors) { String key = property.getName(); if (key.equals("class")) { continue; } Method getter = property.getReadMethod(); Object value = getter.invoke(obj); map.put(key, value); } } catch (Exception e) { throw new RuntimeException(e); } return map; } static T map2Bean(Map<String, Object> map, Class<T> beanClass); static Map<String, Object> bean2Map(Object obj); }### Answer: @Test public void testBean2Map(){ Son user = new Son(); user.setName("xuan"); user.setAge(20); user.setSonName("xuanson"); Map map = Map2BeanUtils.bean2Map(user); System.out.println("++++++++++map:" + map); } @Test public void testBean2Map2(){ Son son = new Son(); son.setSonName("sonName"); son.setAge(20); son.setName("name"); Son2 son2 = new Son2(); son2.setSon2Name("son2Name"); son2.setAge(22); son2.setName("name2"); Father father = new Father(); father.setAge(88); father.setName("name3"); Family family = new Family(); family.setSon(son); family.setSon2(son2); family.setFather(father); Map map = Map2BeanUtils.bean2Map(family); System.out.println("++++++++++map:" + map); }
### Question: JavaCommOpenHandler 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]; } } JavaCommOpenHandler(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: ValueWidget extends DOMWidget { public Boolean getBoolean(Object input) { Boolean ret = false; if (input != null) { if (input instanceof Boolean) { ret = (Boolean) input; } else if (input instanceof String) { ret = new Boolean((String) input); } } return ret; } T getValue(); void setValue(Object value); @Override void updateValue(Object input); abstract T getValueFromObject(Object input); Boolean getDisabled(); void setDisabled(Object disabled); Boolean getVisible(); void setVisible(Object visible); String getDescription(); void setDescription(Object description); Integer getMsg_throttle(); void setMsg_throttle(Object msg_throttle); Integer getInteger(Object input); Double getDouble(Object input); String getString(Object input); String[] getStringArray(Object input); Boolean getBoolean(Object input); }### Answer: @Test public void getBooleanWithBooleanParam_returnBoolean() throws Exception { Boolean value = valueWidget.getBoolean(Boolean.TRUE); Assertions.assertThat(value).isTrue(); } @Test public void getBooleanWithStringParam_returnBoolean() throws Exception { Boolean value = valueWidget.getBoolean("true"); Assertions.assertThat(value).isTrue(); } @Test public void getBooleanWithNullParam_returnFalse() throws Exception { Boolean value = valueWidget.getBoolean(null); Assertions.assertThat(value).isFalse(); }
### Question: ScalaCommOpenHandler extends CommOpenHandler { public Handler<Message>[] getKernelControlChanelHandlers(String targetName){ if(TargetNamesEnum.KERNEL_CONTROL_CHANNEL.getTargetName().equalsIgnoreCase(targetName)){ return (Handler<Message>[]) KERNEL_CONTROL_CHANNEL_HANDLERS; }else{ return (Handler<Message>[]) new Handler<?>[0]; } } ScalaCommOpenHandler(KernelFunctionality kernel); Handler<Message>[] getKernelControlChanelHandlers(String targetName); }### Answer: @Test public void getControlHandlersWithTargetName_returnNotEmptyHandlersArray() throws Exception { Handler<Message>[] handlers = commOpenHandler.getKernelControlChanelHandlers(targetName); Assertions.assertThat(handlers).isNotEmpty(); } @Test public void getControlHandlersWithEmptyString_returnEmptyHandlersArray() throws Exception { Handler<Message>[] handlers = commOpenHandler.getKernelControlChanelHandlers(""); Assertions.assertThat(handlers).isEmpty(); }
### Question: CommCloseHandler extends KernelHandler<Message> { @Override public void handle(Message message) { wrapBusyIdle(kernel, message, () -> { handleMsg(message); }); } CommCloseHandler(KernelFunctionality kernel); static String getString(Map<String, Serializable> map, String name); @Override void handle(Message message); }### Answer: @Test public void handleMessage_shouldSendShellSocketMessage() throws Exception { commCloseHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); } @Test public void handleMessage_sentMessageHasTypeIsCommClose() throws Exception { commCloseHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getType()) .isEqualTo(JupyterMessages.COMM_CLOSE.getName()); } @Test public void handleMessage_sentMessageHasSessionId() throws Exception { String expectedSessionId = message.getHeader().getSession(); commCloseHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getSession()).isEqualTo(expectedSessionId); } @Test public void handleMessage_sentMessageHasParentHeader() throws Exception { String expectedHeader = message.getHeader().asJson(); commCloseHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getParentHeader().asJson()).isEqualTo(expectedHeader); } @Test public void handleMessage_sentMessageHasIdentities() throws Exception { String expectedIdentities = new String(message.getIdentities().get(0)); commCloseHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(new String(sendMessage.getIdentities().get(0))) .isEqualTo(expectedIdentities); }
### Question: CommInfoHandler extends KernelHandler<Message> { @Override public void handle(Message message) { wrapBusyIdle(kernel, message, () -> { handleMsg(message); }); } CommInfoHandler(KernelFunctionality kernel); @Override void handle(Message message); }### Answer: @Test public void handleMessage_shouldSendShellSocketMessage() throws Exception { commInfoHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); } @Test public void handleMessage_sentMessageHasTypeIsCommInfoReply() throws Exception { commInfoHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getType()) .isEqualTo(JupyterMessages.COMM_INFO_REPLY.getName()); } @Test public void handleMessage_sentMessageHasSessionId() throws Exception { String expectedSessionId = message.getHeader().getSession(); commInfoHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getHeader().getSession()).isEqualTo(expectedSessionId); } @Test public void handleMessage_sentMessageHasParentHeader() throws Exception { String expectedHeader = message.getHeader().asJson(); commInfoHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(sendMessage.getParentHeader().asJson()).isEqualTo(expectedHeader); } @Test public void handleMessage_sentMessageHasIdentities() throws Exception { String expectedIdentities = new String(message.getIdentities().get(0)); commInfoHandler.handle(message); Assertions.assertThat(kernel.getSentMessages()).isNotEmpty(); Message sendMessage = kernel.getSentMessages().get(0); Assertions.assertThat(new String(sendMessage.getIdentities().get(0))) .isEqualTo(expectedIdentities); }
### Question: MessageCreator { public Message createIdleMessage(Message parentMessage) { return getExecutionStateMessage(parentMessage, IDLE); } MessageCreator(KernelFunctionality kernel); Message buildMessage(Message message, String mime, String code, int executionCount); Message buildClearOutput(Message message, boolean wait); Message buildDisplayData(Message message, MIMEContainer value); Message buildOutputMessage(Message message, String text, boolean hasError); synchronized void createMagicMessage(Message reply, int executionCount, Message message); synchronized List<MessageHolder> createMessage(SimpleEvaluationObject seo); Message createBusyMessage(Message parentMessage); Message createIdleMessage(Message parentMessage); static final String EXECUTION_STATE; static final String BUSY; static final String IDLE; static final String TEXT_PLAIN; static final String NULL_RESULT; static Logger logger; }### Answer: @Test public void createIdleMessage_messageHasTypeIsStatus() { Message message = messageCreator.createIdleMessage(new Message()); assertThat(message.type()).isEqualTo(JupyterMessages.STATUS); } @Test public void createIdleMessage_messageHasExecutionStateIsIdle() { Message message = messageCreator.createIdleMessage(new Message()); Map data = message.getContent(); assertThat(data.get(MessageCreator.EXECUTION_STATE)).isEqualTo(MessageCreator.IDLE); }
### Question: MessageCreator { public Message createBusyMessage(Message parentMessage) { return getExecutionStateMessage(parentMessage, BUSY); } MessageCreator(KernelFunctionality kernel); Message buildMessage(Message message, String mime, String code, int executionCount); Message buildClearOutput(Message message, boolean wait); Message buildDisplayData(Message message, MIMEContainer value); Message buildOutputMessage(Message message, String text, boolean hasError); synchronized void createMagicMessage(Message reply, int executionCount, Message message); synchronized List<MessageHolder> createMessage(SimpleEvaluationObject seo); Message createBusyMessage(Message parentMessage); Message createIdleMessage(Message parentMessage); static final String EXECUTION_STATE; static final String BUSY; static final String IDLE; static final String TEXT_PLAIN; static final String NULL_RESULT; static Logger logger; }### Answer: @Test public void createBusyMessage_messageHasTypeIsStatus() { Message message = messageCreator.createBusyMessage(new Message()); assertThat(message.type()).isEqualTo(JupyterMessages.STATUS); } @Test public void createBusyMessage_messageHasExecutionStateIsBusy() { Message message = messageCreator.createBusyMessage(new Message()); Map data = message.getContent(); assertThat(data.get(MessageCreator.EXECUTION_STATE)).isEqualTo(MessageCreator.BUSY); }
### Question: ScalaEvaluator implements Evaluator { @Override public void evaluate(SimpleEvaluationObject seo, String code) { jobQueue.add(new jobDescriptor(code,seo)); syncObject.release(); } @Inject ScalaEvaluator(Provider<BeakerObjectConverter> osp); void initialize(String id, String sId); @Override void startWorker(); String getShellId(); void setupAutoTranslation(); void killAllThreads(); void cancelExecution(); void resetEnvironment(); void exit(); @Override void setShellOptions(final KernelParameters kernelParameters); @Override void evaluate(SimpleEvaluationObject seo, String code); @Override AutocompleteResult autocomplete(String code, int caretPosition); }### Answer: @Test public void evaluatePlot_shouldCreatePlotObject() throws Exception { String code = "import com.twosigma.beaker.chart.xychart.Plot;\n" + "val plot = new Plot();\n" + "plot.setTitle(\"test title\");"; SimpleEvaluationObject seo = new SimpleEvaluationObject(code, new ExecuteCodeCallbackTest()); scalaEvaluator.evaluate(seo, code); waitForResult(seo); Assertions.assertThat(seo.getStatus()).isEqualTo(FINISHED); Assertions.assertThat(seo.getPayload() instanceof Plot).isTrue(); Assertions.assertThat(((Plot)seo.getPayload()).getTitle()).isEqualTo("test title"); } @Test public void evaluateDivisionByZero_shouldReturnArithmeticException() throws Exception { String code = "16/0"; SimpleEvaluationObject seo = new SimpleEvaluationObject(code, new ExecuteCodeCallbackTest()); scalaEvaluator.evaluate(seo, code); waitForResult(seo); Assertions.assertThat(seo.getStatus()).isEqualTo(ERROR); Assertions.assertThat((String)seo.getPayload()).contains("java.lang.ArithmeticException"); }
### Question: TableDisplayAlignmentSerializer extends JsonSerializer<TableDisplayAlignmentProvider> { @Override public void serialize(TableDisplayAlignmentProvider value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException { synchronized (value) { jgen.writeString(value.getCode()); } } @Override void serialize(TableDisplayAlignmentProvider value, JsonGenerator jgen, SerializerProvider provider); }### Answer: @Test public void serializeTableDisplayLeftAligment_resultJsonHasLValue() throws IOException { serializer.serialize( TableDisplayAlignmentProvider.LEFT_ALIGNMENT, jgen, new DefaultSerializerProvider.Impl()); jgen.flush(); JsonNode actualObj = mapper.readTree(sw.toString()); Assertions.assertThat(actualObj.asText()).isEqualTo("L"); }
### Question: NamespaceClient { public synchronized static NamespaceClient getBeaker() { if (currentSession!=null){ return nsClients.get(currentSession); } return null; } NamespaceClient(); synchronized void showProgressUpdate(String message, int progress); SimpleEvaluationObject getOutputObj(); synchronized void setOutputObj(SimpleEvaluationObject input); synchronized static NamespaceClient getBeaker(); synchronized static NamespaceClient getBeaker(String session); synchronized static void delBeaker(String sessionId); synchronized Object set(String name, Object value); Object setFast(String name, Object value); Object unset(String name); synchronized Object get(final String name); static SynchronousQueue<Object> getMessageQueue(String channel); List<BeakerCodeCell> getCodeCells(String tagFilter); }### Answer: @Test public void getNamespaceClientBySessionId_returnNamespaceClient() { NamespaceClient curNamespaceClient = NamespaceClient.getBeaker(SESSION_ID); Assertions.assertThat(namespaceClient).isNotNull(); Assertions.assertThat(curNamespaceClient).isEqualTo(namespaceClient); } @Test public void getNamespaceClientByCurrentSessionId_returnNamespaceClient() { NamespaceClient curNamespaceClient = NamespaceClient.getBeaker(); Assertions.assertThat(curNamespaceClient).isNotNull(); Assertions.assertThat(curNamespaceClient).isEqualTo(namespaceClient); }
### Question: SelectMultipleSingleWidget extends ListComponent implements CommFunctionality, EasyFormWidget { @Override public void setValues(Collection<String> values) { super.setValues(values); this.widget.setOptions(values.stream().toArray(String[]::new)); } SelectMultipleSingleWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override void setSize(Integer size); @Override Integer getSize(); @Override void setValues(Collection<String> values); @Override DOMWidget getWidget(); @Override void close(); }### Answer: @Test public void setValues() throws Exception { String newValue = "2"; SelectMultipleSingleWidget widget = new SelectMultipleSingleWidget(); widget.setValues(asList("1", "2", "3")); kernel.clearPublishedMessages(); widget.setValue(newValue); verifyMsgForProperty(kernel, SelectMultiple.VALUE, "2"); }
### Question: SelectMultipleSingleWidget extends ListComponent implements CommFunctionality, EasyFormWidget { @Override public void setSize(Integer size) { this.widget.setSize(size); } SelectMultipleSingleWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override void setSize(Integer size); @Override Integer getSize(); @Override void setValues(Collection<String> values); @Override DOMWidget getWidget(); @Override void close(); }### Answer: @Test public void setSize() throws Exception { Integer newValue = 2; SelectMultipleSingleWidget widget = new SelectMultipleSingleWidget(); widget.setValues(asList("1", "2", "3")); kernel.clearPublishedMessages(); widget.setSize(newValue); verifyMsgForProperty(kernel, SelectMultipleSingle.SIZE, 2); }
### Question: CheckBoxWidget extends CheckBox implements CommFunctionality, EasyFormWidget { @Override public void setValue(String value) { this.widget.setValue(Boolean.valueOf(value)); } CheckBoxWidget(); @Override String getLabel(); @Override Comm getComm(); @Override void setLabel(String label); @Override String getValue(); @Override void setValue(String value); @Override DOMWidget getWidget(); @Override void close(); }### Answer: @Test public void setValue() throws Exception { Boolean newValue = Boolean.TRUE; CheckBoxWidget widget = new CheckBoxWidget(); kernel.clearPublishedMessages(); widget.setValue(newValue.toString()); verifyValue(kernel.getPublishedMessages().get(0), newValue); }

Subsets and Splits

No community queries yet

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