method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
CategoryServiceImpl implements CategoryService { @Override public Page<Category> findCategoryByPage(Integer starPage, Integer itemNumber) { PageRequest pageRequest = new PageRequest(starPage,itemNumber); return categoryRepository.findAll(pageRequest); } @Override void saveCategory(Category category); @Override void insertCategories(Iterable<Category> iterable); @Override void deleteCategoryById(Long id); @Override void updateCategory(Category category); @Override Iterable<Category> findAll(); @Override Category findCategoryById(Long id); @Override Page<Category> findCategoryByPage(Integer starPage, Integer itemNumber); @Override Page<Category> findCategoryByPageAndOrder(Integer starPage, Integer itemNumber); }### Answer:
@Test public void findCategoryByPage() { Page<Category> page = categoryService.findCategoryByPage(5-1, 20); System.out.println("总页数"+page.getTotalPages()); System.out.println("总记录数目"+page.getTotalElements()); System.out.println("当前页面"+(page.getNumber()+1)); System.out.println("当前页面的内容"+page.getContent()); System.out.println("当前页面的记录数目"+page.getNumberOfElements()); } |
### Question:
CategoryServiceImpl implements CategoryService { @Override public Page<Category> findCategoryByPageAndOrder(Integer starPage, Integer itemNumber) { List<Sort.Order> orders = new ArrayList<>(); orders.add(new Sort.Order(Sort.Direction.DESC,"id")); PageRequest pageRequest = new PageRequest(starPage,itemNumber,new Sort(orders)); return categoryRepository.findAll(pageRequest); } @Override void saveCategory(Category category); @Override void insertCategories(Iterable<Category> iterable); @Override void deleteCategoryById(Long id); @Override void updateCategory(Category category); @Override Iterable<Category> findAll(); @Override Category findCategoryById(Long id); @Override Page<Category> findCategoryByPage(Integer starPage, Integer itemNumber); @Override Page<Category> findCategoryByPageAndOrder(Integer starPage, Integer itemNumber); }### Answer:
@Test public void findCategoryByPageAndOrder() { Page<Category> pageAndOrder = categoryService.findCategoryByPageAndOrder(0, 5); List<Category> content = pageAndOrder.getContent(); for (Category category : content) { System.out.println(category.toString()); } } |
### Question:
FF4JMBean { public void setFf4j(FF4j ff4j) { this.ff4j = ff4j; } @ManagedAttribute(description = "Returns states of every features of the store") Map<String, Boolean> getFeaturesStatus(); @ManagedOperation(description = "Enable feature from its identifier") @ManagedOperationParameters({@ManagedOperationParameter(name = "featureId", description = "Identifier of feature to enable")}) void enableFeature(String featureId); @ManagedOperation(description = "Disable feature from its identifier") @ManagedOperationParameters({@ManagedOperationParameter(name = "featureId", description = "Identifier of feature to disable")}) void disableFeature(String featureId); @ManagedOperation(description = "Returns feature authentication roles") @ManagedOperationParameters({@ManagedOperationParameter(name = "featureId", description = "Identifier of feature to get Roles")}) Set<String> getPermissions(String featureId); @ManagedOperation(description = "Add an authentication role to feature") @ManagedOperationParameters({@ManagedOperationParameter(name = "authentication Role", description = "role to grant on feature"), @ManagedOperationParameter(name = "featureId", description = "target feature id")}) void grantRoleOnFeature(String authRole, String featureId); @ManagedOperation(description = "Remove an authentication role from feature") @ManagedOperationParameters({@ManagedOperationParameter(name = "authRole", description = "role to remove on feature"), @ManagedOperationParameter(name = "featureId", description = "target feature id")}) void removeAuthRoleFromFeature(String authRole, String featureId); FF4j getFf4j(); void setFf4j(FF4j ff4j); }### Answer:
@Test public void defaultInitialisation() { FF4JMBean sampleBean = new FF4JMBean(); sampleBean.setFf4j(ff4j); Assert.assertNotNull(sampleBean); } |
### Question:
PropertyStoreCommonsConfig extends AbstractPropertyStore { @Override public boolean existProperty(String name) { Util.assertHasLength(name); return conf().containsKey(name); } PropertyStoreCommonsConfig(); PropertyStoreCommonsConfig(Configuration configuration); @Override boolean existProperty(String name); @Override void deleteProperty(String name); Set<String> listPropertyNames(); @Override void createProperty(Property<T> value); @Override Property<?> readProperty(String name); @Override Map<String, Property<?>> readAllProperties(); @Override void clear(); Configuration getConfiguration(); void setConfiguration(Configuration configuration); }### Answer:
@Test(expected = IllegalStateException.class) public void initializationKO() { PropertyStoreCommonsConfig psConf = new PropertyStoreCommonsConfig(); psConf.existProperty("toto"); } |
### Question:
FeatureJsonParser { @SuppressWarnings("unchecked") public static Feature parseFeature(String json) { try { return parseFeatureMap(objectMapper.readValue(json, HashMap.class)); } catch (IOException e) { throw new IllegalArgumentException("Cannot parse json as Feature " + json, e); } } private FeatureJsonParser(); @SuppressWarnings("unchecked") static Feature parseFeature(String json); @SuppressWarnings("unchecked") static Set<String> parsePermissions(String json); static String featureArrayToJson(Feature[] features); @SuppressWarnings("unchecked") static FlippingStrategy parseFlipStrategyAsJson(String uid, String json); @SuppressWarnings("unchecked") static FlippingStrategy parseFlipStrategy(String uid, Map<String, Object> flipMap); @SuppressWarnings("unchecked") static Feature[] parseFeatureArray(String json); }### Answer:
@Test public void testMarshaling() throws Exception { Map <String, Feature> features = ff4j.getFeatures(); for (String key : features.keySet()) { assertMarshalling(features.get(key)); Feature f1 = FeatureJsonParser.parseFeature(features.get(key).toJson()); assertMarshalling(f1); } }
@Test(expected = IllegalArgumentException.class) public void testInvalidJsonGetIllegalArgument() { FeatureJsonParser.parseFeature("something:invald"); } |
### Question:
FeatureJsonParser { @SuppressWarnings("unchecked") public static Feature[] parseFeatureArray(String json) { if (null == json || "".equals(json)) { return null; } try { List<LinkedHashMap<String, Object>> flipMap = objectMapper.readValue(json, List.class); Feature[] fArray = new Feature[flipMap.size()]; int idx = 0; for (LinkedHashMap<String, Object> ll : flipMap) { fArray[idx++] = parseFeatureMap(ll); } return fArray; } catch (Exception e) { throw new IllegalArgumentException("Cannot parse JSON " + json, e); } } private FeatureJsonParser(); @SuppressWarnings("unchecked") static Feature parseFeature(String json); @SuppressWarnings("unchecked") static Set<String> parsePermissions(String json); static String featureArrayToJson(Feature[] features); @SuppressWarnings("unchecked") static FlippingStrategy parseFlipStrategyAsJson(String uid, String json); @SuppressWarnings("unchecked") static FlippingStrategy parseFlipStrategy(String uid, Map<String, Object> flipMap); @SuppressWarnings("unchecked") static Feature[] parseFeatureArray(String json); }### Answer:
@Test public void testArrays() throws Exception { Map <String, Feature> features = ff4j.getFeatures(); int idx = 0; Feature[] f= new Feature[features.size()]; for (String feature : features.keySet()) { f[idx] = features.get(feature); idx++; } String featuresArrayAsJson = marshallWithJackson(f); Feature[] ff = FeatureJsonParser.parseFeatureArray(featuresArrayAsJson); Assert.assertEquals(ff4j.getFeatures().size(), ff.length); }
@Test(expected = IllegalArgumentException.class) public void testparseFeatureArrayError() { FeatureJsonParser.parseFeatureArray("something:invalid"); }
@Test public void testparseFeatureArrayEmpty() { Assert.assertNull(FeatureJsonParser.parseFeatureArray(null)); Assert.assertNull(FeatureJsonParser.parseFeatureArray("")); } |
### Question:
FeatureJsonParser { public static String featureArrayToJson(Feature[] features) { StringBuilder sb = new StringBuilder(); sb.append("["); if (features != null) { boolean first = true; for (Feature feature : features) { sb.append(first ? "" : ","); sb.append(feature.toJson()); first = false; } } sb.append("]"); return sb.toString(); } private FeatureJsonParser(); @SuppressWarnings("unchecked") static Feature parseFeature(String json); @SuppressWarnings("unchecked") static Set<String> parsePermissions(String json); static String featureArrayToJson(Feature[] features); @SuppressWarnings("unchecked") static FlippingStrategy parseFlipStrategyAsJson(String uid, String json); @SuppressWarnings("unchecked") static FlippingStrategy parseFlipStrategy(String uid, Map<String, Object> flipMap); @SuppressWarnings("unchecked") static Feature[] parseFeatureArray(String json); }### Answer:
@Test public void testSerialisation() { Feature[] features = { new Feature("f1"), new Feature("f2")}; Assert.assertNotNull(FeatureJsonParser.featureArrayToJson(features)); Assert.assertNotNull(FeatureJsonParser.featureArrayToJson(null)); } |
### Question:
FeatureJsonParser { @SuppressWarnings("unchecked") public static FlippingStrategy parseFlipStrategyAsJson(String uid, String json) { if (null == json || "".equals(json)) { return null; } try { return parseFlipStrategy(uid, (HashMap<String, Object>) objectMapper.readValue(json, HashMap.class)); } catch (Exception e) { throw new IllegalArgumentException("Cannot parse JSON " + json, e); } } private FeatureJsonParser(); @SuppressWarnings("unchecked") static Feature parseFeature(String json); @SuppressWarnings("unchecked") static Set<String> parsePermissions(String json); static String featureArrayToJson(Feature[] features); @SuppressWarnings("unchecked") static FlippingStrategy parseFlipStrategyAsJson(String uid, String json); @SuppressWarnings("unchecked") static FlippingStrategy parseFlipStrategy(String uid, Map<String, Object> flipMap); @SuppressWarnings("unchecked") static Feature[] parseFeatureArray(String json); }### Answer:
@Test public void testParseFlipStrategyAsJson() { Assert.assertNull(FeatureJsonParser.parseFlipStrategyAsJson("f1", "")); Assert.assertNull(FeatureJsonParser.parseFlipStrategyAsJson("f1", null)); String fExp = "{\"initParams\":{\"weight\":\"0.6\"},\"type\":\"org.ff4j.strategy.PonderationStrategy\"}"; Assert.assertNotNull(FeatureJsonParser.parseFlipStrategyAsJson("f1", fExp)); }
@Test(expected = IllegalArgumentException.class) public void testParseFlipStrategyAsJsonError() { FeatureJsonParser.parseFlipStrategyAsJson("f1", "something:invalid"); } |
### Question:
EventJsonParser { @SuppressWarnings("unchecked") public static Event parseEvent(String json) { try { return parseEventMap(objectMapper.readValue(json, HashMap.class)); } catch (IOException e) { throw new IllegalArgumentException("Cannot parse json as Event " + json, e); } } private EventJsonParser(); @SuppressWarnings("unchecked") static Event parseEvent(String json); static String eventArrayToJson(Event[] events); @SuppressWarnings("unchecked") static Event[] parseEventArray(String json); }### Answer:
@Test public void testMarshaling() { ff4j.setAuthorizationsManager(new AuthorizationsManager() { public String toJson() { return "dummy"; } public Set<String> listAllPermissions() { return new HashSet<>(); } public Set<String> getCurrentUserPermissions() { return new HashSet<>(); } public String getCurrentUserName() { return "dummy"; } }); Map<String, Event> events = new HashMap<>(); events.put("e1", new EventBuilder(ff4j).name("f1").build()); events.put("e2", new EventBuilder(ff4j).name("f2").build()); for (String key : events.keySet()) { Event e1 = EventJsonParser.parseEvent(events.get(key).toJson()); Assert.assertEquals(events.get(key).getName(), e1.getName()); Assert.assertTrue(events.get(key).compareTo(e1) == 0); } }
@Test(expected = IllegalArgumentException.class) public void testInvalidJsonGetIllegalArgument() { EventJsonParser.parseEvent("something:invald"); } |
### Question:
EventJsonParser { public static String eventArrayToJson(Event[] events) { StringBuilder sb = new StringBuilder(); sb.append("["); if (events != null) { boolean first = true; for (Event event : events) { sb.append(first ? "" : ","); sb.append(event.toJson()); first = false; } } sb.append("]"); return sb.toString(); } private EventJsonParser(); @SuppressWarnings("unchecked") static Event parseEvent(String json); static String eventArrayToJson(Event[] events); @SuppressWarnings("unchecked") static Event[] parseEventArray(String json); }### Answer:
@Test public void testSerialisation() { Event event1 = new Event(); event1.setUuid("e1"); Event event2 = new Event(); event2.setUuid("e2"); Event[] events = {event1, event2}; Assert.assertNotNull(EventJsonParser.eventArrayToJson(events)); Assert.assertNotNull(EventJsonParser.eventArrayToJson(null)); } |
### Question:
EventJsonParser { @SuppressWarnings("unchecked") public static Event[] parseEventArray(String json) { if (null == json || "".equals(json)) { return null; } try { List<LinkedHashMap<String, Object>> evtMap = objectMapper.readValue(json, List.class); Event[] eArray = new Event[evtMap.size()]; int idx = 0; for (LinkedHashMap<String, Object> ll : evtMap) { eArray[idx++] = parseEventMap(ll); } return eArray; } catch (Exception e) { throw new IllegalArgumentException("Cannot parse JSON " + json, e); } } private EventJsonParser(); @SuppressWarnings("unchecked") static Event parseEvent(String json); static String eventArrayToJson(Event[] events); @SuppressWarnings("unchecked") static Event[] parseEventArray(String json); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testparseEventArrayError() { EventJsonParser.parseEventArray("something:invalid"); }
@Test public void testparseFeatureArrayEmpty() { Assert.assertNull(EventJsonParser.parseEventArray(null)); Assert.assertNull(EventJsonParser.parseEventArray("")); } |
### Question:
PropertyStoreAwsSSM extends AbstractPropertyStore { @Override public void clear() { Set<String> names = listPropertyFullNames(); if (!Util.isEmpty(names)) { client.deleteParameters(new DeleteParametersRequest().withNames(names)); } } PropertyStoreAwsSSM(String path); PropertyStoreAwsSSM(AWSSimpleSystemsManagement client, String path); @Override boolean existProperty(String name); @Override void createProperty(Property<T> value); @Override Property<?> readProperty(String name); @Override void updateProperty(Property<T> prop); @Override void deleteProperty(String name); @Override Map<String, Property<?>> readAllProperties(); @Override Set<String> listPropertyNames(); @Override void clear(); void loadFromXMLFile(String fileName); void loadFromXMLFileStream(InputStream xmlIN); }### Answer:
@Override @Test public void clear() { Map<String, Property<?>> before = testedStore.readAllProperties(); Assert.assertFalse(before.isEmpty()); testedStore.clear(); Assert.assertTrue(testedStore.readAllProperties().isEmpty()); } |
### Question:
Util { @Nonnull public static String stripCrLf(@Nonnull final String text) { final char[] src = text.toCharArray(); final StringBuilder dest = new StringBuilder(src.length + 10); for (final char ch : src) { switch (ch) { case 10: dest.append("\\n"); break; case 13: dest.append("\\r"); break; default: dest.append(ch); } } return dest.toString(); } @Nonnull static String stripCrLf(@Nonnull final String text); @Nonnull static Class findRootEnclosingClass(@Nonnull final Class clazz); }### Answer:
@Test public void stripCrLf() throws Exception { assertThat(Util.stripCrLf("")).isEqualTo(""); assertThat(Util.stripCrLf("\n\rtest\r\n")).isEqualTo("\\n\\rtest\\r\\n"); } |
### Question:
SmartLog { @Nonnull public static LogContext current() { final Deque<LogContext> contextQueue = CONTEXTS.get(); if (!contextQueue.isEmpty()) { return contextQueue.peek(); } else { throw new RuntimeException("Loggable context is absent"); } } @Nonnull static LogContext start(@Nonnull final Output output); @Nonnull static LogContext start(@Nonnull final Object loggableObject); @Nonnull static LogContext start(@Nonnull final Output output, @Nullable final Object loggableObject); static void finish(); @Nonnull static LogContext current(); @Nonnull static LogContext output(@Nonnull final Output output); @Nonnull static LogContext level(@Nonnull final LogLevel level); @Nonnull static LogContext format(@Nonnull final Format format); @Nonnull static LogContext title(@Nonnull final String title); @Nonnull static LogContext title(@Nonnull final String format, final Object... args); @Nonnull static LogContext attach(@Nonnull final String name, @Nullable final Object value); @Nonnull static LogContext throwable(@Nonnull final Throwable newThrowable); @Nonnull static LogContext trace(final String msg); @Nonnull static LogContext trace(final String format, final Object... args); @Nonnull static LogContext trace(@Nonnull final TraceFlag flag, @Nonnull final String msg); @Nonnull static LogContext trace(@Nonnull final TraceFlag flag, @Nonnull final String msg, @Nonnull final Object... args); @Nonnull static LogContext result(final Object result); @Nonnull static LogContext result(final String description, final Object... args); @Nonnull static LogContext result(final LogLevel level, final Object result); @Nonnull static LogContext result(final LogLevel level, final String description, final Object... args); @Nonnull static LogContext result(final LogLevel level, final Throwable throwable, final String description); @Nonnull static LogContext result(final LogLevel level, final Throwable throwable, final String description, final Object... args); }### Answer:
@Test public void currentThrowExceptionIfNoLogContext() throws Exception { try { SmartLog.current(); } catch (Exception e) { Assertions.assertThat(e).hasMessage("Loggable context is absent"); } } |
### Question:
Util { @Nonnull public static Class findRootEnclosingClass(@Nonnull final Class clazz) { Class curr = clazz; while (true) { Class declaringClass = curr.getEnclosingClass(); if (declaringClass != null) { curr = declaringClass; } else { return curr; } } } @Nonnull static String stripCrLf(@Nonnull final String text); @Nonnull static Class findRootEnclosingClass(@Nonnull final Class clazz); }### Answer:
@Test public void findRootEnclosingClass() throws Exception { assertThat(Util.findRootEnclosingClass(UtilTest.class)).isSameAs(UtilTest.class); }
@Test public void findRootEnclosingClassForAnonymousClass() throws Exception { Class<? extends Object> internalClass = new Object() { }.getClass(); assertThat(Util.findRootEnclosingClass(internalClass)).isSameAs(UtilTest.class); }
@Test public void findRootEnclosingClassForInternalClass() throws Exception { assertThat(Util.findRootEnclosingClass(InternalClass.class)).isSameAs(UtilTest.class); } |
### Question:
Slf4JOutput implements Output { public static Builder create() { return new Builder(); } Slf4JOutput(final Builder builder); static Builder create(); @Override void write(final LogContext log); @Nonnull Logger getLogger(); @Nullable Format getFormat(); @Nullable Boolean getReplaceCrLf(); }### Answer:
@Test public void testFailFastIfNoLogger() { try { Slf4JOutput.create() .build(); Assert.fail(); } catch (Exception e) { assertThat(e).hasMessage("Logger is absent"); } } |
### Question:
DynamicPropertiesRule implements Rule<JDefinedClass, JDefinedClass> { JFieldRef getOrAddNotFoundVar(JDefinedClass jclass) { jclass.field(PROTECTED | STATIC | FINAL, Object.class, NOT_FOUND_VALUE_FIELD, _new(jclass.owner()._ref(Object.class))); return jclass.staticRef(NOT_FOUND_VALUE_FIELD); } DynamicPropertiesRule(RuleFactory ruleFactory); @Override JDefinedClass apply(String nodeName, JsonNode node, JsonNode parent, JDefinedClass jclass, Schema currentSchema); static final String NOT_FOUND_VALUE_FIELD; static final String SETTER_NAME; static final String GETTER_NAME; static final String BUILDER_NAME; static final String DEFINED_SETTER_NAME; static final String DEFINED_GETTER_NAME; }### Answer:
@Test public void shouldAddNotFoundField() { JFieldRef var = rule.getOrAddNotFoundVar(type); assertThat(var, notNullValue()); } |
### Question:
LanguageFeatures { public static boolean canUseJava7(GenerationConfig config) { return !LESS_THAN_7.contains(config.getTargetVersion()); } static boolean canUseJava7(GenerationConfig config); static boolean canUseJava8(GenerationConfig config); }### Answer:
@Test public void correctTestForJava7() { assertThat(LanguageFeatures.canUseJava7(mockConfig(version)), equalTo(versionSpec.canUse7)); } |
### Question:
ClassConverter extends BaseConverter<Class> { @Override public Class convert(String value) { if (isBlank(value)) { throw new ParameterException(getErrorString("a blank value", "a class")); } try { return Class.forName(value); } catch (ClassNotFoundException e) { throw new ParameterException(getErrorString(value, "a class")); } } ClassConverter(String optionName); @Override Class convert(String value); }### Answer:
@Test @SuppressWarnings("unchecked") public void classIsCreatedFromFullyQualifiedClassName() { Class<Annotator> clazz = converter.convert(Annotator.class.getName()); assertThat(clazz, is(equalTo(Annotator.class))); }
@Test(expected = ParameterException.class) public void invalidClassNameThrowsParameterException() { converter.convert("some garbage.name"); }
@Test(expected = ParameterException.class) public void nullValueThrowsParameterException() { converter.convert(null); } |
### Question:
UrlConverter extends BaseConverter<URL> { public URL convert(String value) { if (isBlank(value)) { throw new ParameterException(getErrorString("a blank value", "a valid URL")); } try { return URLUtil.parseURL(value); } catch (IllegalArgumentException e) { throw new ParameterException(getErrorString(value, "a valid URL")); } } UrlConverter(String optionName); URL convert(String value); }### Answer:
@Test public void urlIsCreatedFromFilePath() { URL url = converter.convert("/path/to/something"); assertThat(url.getPath(), endsWith("/path/to/something")); }
@Test public void urlIsCreatedFromFileUrl() { URL url = converter.convert("file:/path/to/something"); assertThat(url.toString(), is("file:/path/to/something")); }
@Test(expected = ParameterException.class) public void invalidUrlThrowsParameterException() { converter.convert("http:total nonsense"); }
@Test(expected = ParameterException.class) public void nullValueThrowsParameterException() { converter.convert(null); } |
### Question:
LanguageFeatures { public static boolean canUseJava8(GenerationConfig config) { return !LESS_THAN_8.contains(config.getTargetVersion()); } static boolean canUseJava7(GenerationConfig config); static boolean canUseJava8(GenerationConfig config); }### Answer:
@Test public void correctTestForJava8() { assertThat(LanguageFeatures.canUseJava8(mockConfig(version)), equalTo(versionSpec.canUse8)); } |
### Question:
MakeUniqueClassName { public static String makeUnique(String className) { final Matcher m = UNIQUE_NAMING_PATTERN.matcher(className); if (m.matches()) { final Integer number = Integer.parseInt(m.group(2)); return m.group(1) + (number + 1); } else { return className + "__1"; } } static String makeUnique(String className); }### Answer:
@Test public void testClassNameStrategy() { assertThat(MakeUniqueClassName.makeUnique("NodeMode"), equalTo("NodeMode__1")); assertThat(MakeUniqueClassName.makeUnique("NodeMode__5"), equalTo("NodeMode__6")); assertThat(MakeUniqueClassName.makeUnique("NodeMode__10"), equalTo("NodeMode__11")); assertThat(MakeUniqueClassName.makeUnique("NodeMode__100"), equalTo("NodeMode__101")); } |
### Question:
NameHelper { public String getGetterName(String propertyName, JType type, JsonNode node) { propertyName = getPropertyNameForAccessor(propertyName, node); String prefix = type.equals(type.owner()._ref(boolean.class)) ? "is" : "get"; String getterName; if (propertyName.length() > 1 && Character.isUpperCase(propertyName.charAt(1))) { getterName = prefix + propertyName; } else { getterName = prefix + capitalize(propertyName); } if (getterName.equals("getClass")) { getterName = "getClass_"; } return getterName; } NameHelper(GenerationConfig generationConfig); String getBuilderTypeParameterName(JDefinedClass instanceClass); String replaceIllegalCharacters(String name); String normalizeName(String name); String capitalizeTrailingWords(String name); String getPropertyName(String jsonFieldName, JsonNode node); String getSetterName(String propertyName, JsonNode node); String getBuilderName(String propertyName, JsonNode node); String getFieldName(String propertyName, JsonNode node); String getClassName(String propertyName, JsonNode node); String getGetterName(String propertyName, JType type, JsonNode node); String getBaseBuilderClassName(JClass outerClass); String getBaseBuilderClassNameSuffix(JClass outerClass); String getBuilderClassName(JClass outerClass); String getBuilderClassNameSuffix(JClass outerClass); String getUniqueClassName(String nodeName, JsonNode node, JPackage _package); String getClassName(String nodeName, JsonNode node, JPackage _package); static final String ILLEGAL_CHARACTER_REGEX; }### Answer:
@Test public void testGetterNamedCorrectly() { assertThat(nameHelper.getGetterName("foo", new JCodeModel().BOOLEAN, NODE), is("isFoo")); assertThat(nameHelper.getGetterName("foo", new JCodeModel().INT, NODE), is("getFoo")); assertThat(nameHelper.getGetterName("oAuth2State", new JCodeModel().INT, NODE), is("getoAuth2State")); assertThat(nameHelper.getGetterName("URL", new JCodeModel().INT, NODE), is("getUrl")); } |
### Question:
NameHelper { public String getSetterName(String propertyName, JsonNode node) { propertyName = getPropertyNameForAccessor(propertyName, node); String prefix = "set"; String setterName; if (propertyName.length() > 1 && Character.isUpperCase(propertyName.charAt(1))) { setterName = prefix + propertyName; } else { setterName = prefix + capitalize(propertyName); } if (setterName.equals("setClass")) { setterName = "setClass_"; } return setterName; } NameHelper(GenerationConfig generationConfig); String getBuilderTypeParameterName(JDefinedClass instanceClass); String replaceIllegalCharacters(String name); String normalizeName(String name); String capitalizeTrailingWords(String name); String getPropertyName(String jsonFieldName, JsonNode node); String getSetterName(String propertyName, JsonNode node); String getBuilderName(String propertyName, JsonNode node); String getFieldName(String propertyName, JsonNode node); String getClassName(String propertyName, JsonNode node); String getGetterName(String propertyName, JType type, JsonNode node); String getBaseBuilderClassName(JClass outerClass); String getBaseBuilderClassNameSuffix(JClass outerClass); String getBuilderClassName(JClass outerClass); String getBuilderClassNameSuffix(JClass outerClass); String getUniqueClassName(String nodeName, JsonNode node, JPackage _package); String getClassName(String nodeName, JsonNode node, JPackage _package); static final String ILLEGAL_CHARACTER_REGEX; }### Answer:
@Test public void testSetterNamedCorrectly() { assertThat(nameHelper.getSetterName("foo", NODE), is("setFoo")); assertThat(nameHelper.getSetterName("oAuth2State", NODE), is("setoAuth2State")); assertThat(nameHelper.getSetterName("URL", NODE), is("setUrl")); } |
### Question:
NameHelper { public String getBuilderName(String propertyName, JsonNode node) { propertyName = getPropertyNameForAccessor(propertyName, node); String prefix = "with"; if (propertyName.length() > 1 && Character.isUpperCase(propertyName.charAt(1))) { return prefix + propertyName; } else { return prefix + capitalize(propertyName); } } NameHelper(GenerationConfig generationConfig); String getBuilderTypeParameterName(JDefinedClass instanceClass); String replaceIllegalCharacters(String name); String normalizeName(String name); String capitalizeTrailingWords(String name); String getPropertyName(String jsonFieldName, JsonNode node); String getSetterName(String propertyName, JsonNode node); String getBuilderName(String propertyName, JsonNode node); String getFieldName(String propertyName, JsonNode node); String getClassName(String propertyName, JsonNode node); String getGetterName(String propertyName, JType type, JsonNode node); String getBaseBuilderClassName(JClass outerClass); String getBaseBuilderClassNameSuffix(JClass outerClass); String getBuilderClassName(JClass outerClass); String getBuilderClassNameSuffix(JClass outerClass); String getUniqueClassName(String nodeName, JsonNode node, JPackage _package); String getClassName(String nodeName, JsonNode node, JPackage _package); static final String ILLEGAL_CHARACTER_REGEX; }### Answer:
@Test public void testBuilderNamedCorrectly() { assertThat(nameHelper.getBuilderName("foo", NODE), is("withFoo")); assertThat(nameHelper.getBuilderName("oAuth2State", NODE), is("withoAuth2State")); assertThat(nameHelper.getBuilderName("URL", NODE), is("withUrl")); } |
### Question:
TypeUtil { public static JClass resolveType(JClassContainer _package, String typeDefinition) { try { FieldDeclaration fieldDeclaration = (FieldDeclaration) JavaParser.parseBodyDeclaration(typeDefinition + " foo;"); ClassOrInterfaceType c = (ClassOrInterfaceType) ((ReferenceType) fieldDeclaration.getType()).getType(); return buildClass(_package, c, 0); } catch (ParseException e) { throw new GenerationException("Couldn't parse type: " + typeDefinition, e); } } static JClass resolveType(JClassContainer _package, String typeDefinition); }### Answer:
@Test public void testResolveTypeCanHandleWildcard() { final JCodeModel codeModel = new JCodeModel(); final JClass _class = TypeUtil.resolveType(codeModel.rootPackage(), "java.util.List<?>"); assertThat(_class.erasure(), equalTo(codeModel.ref(List.class))); assertThat(_class.typeParams(), emptyArray()); assertThat(_class.isParameterized(), is(Boolean.TRUE)); assertThat(_class.getTypeParameters(), hasSize(1)); assertThat(_class.getTypeParameters().get(0)._extends(), is(equalTo(codeModel.ref(Object.class)))); }
@Test public void testResolveTypeCanHandleExtendsWildcard() { final JCodeModel codeModel = new JCodeModel(); final JClass _class = TypeUtil.resolveType(codeModel.rootPackage(), "java.util.List<? extends java.lang.Number>"); assertThat(_class.erasure(), equalTo(codeModel.ref(List.class))); assertThat(_class.typeParams(), emptyArray()); assertThat(_class.isParameterized(), is(Boolean.TRUE)); assertThat(_class.getTypeParameters(), hasSize(1)); assertThat(_class.getTypeParameters().get(0)._extends(), is(equalTo(codeModel.ref(Number.class)))); }
@Test(expected = IllegalArgumentException.class) public void testResolveTypeForSuperWildcardThrowsException() { TypeUtil.resolveType(new JCodeModel().rootPackage(), "java.util.List<? super java.lang.String>"); } |
### Question:
ContentResolver { public JsonNode resolve(URI uri) { if (CLASSPATH_SCHEMES.contains(uri.getScheme())) { return resolveFromClasspath(uri); } try { return objectMapper.readTree(uri.toURL()); } catch (JsonProcessingException e) { throw new IllegalArgumentException("Error parsing document: " + uri, e); } catch (IOException e) { throw new IllegalArgumentException("Unrecognised URI, can't resolve this: " + uri, e); } } ContentResolver(); ContentResolver(JsonFactory jsonFactory); JsonNode resolve(URI uri); }### Answer:
@Test(expected=IllegalArgumentException.class) public void wrongProtocolCausesIllegalArgumentException() { URI uriWithUnrecognisedProtocol = URI.create("foobar: resolver.resolve(uriWithUnrecognisedProtocol); }
@Test public void fileLinkIsResolvedToContent() throws IOException { URI schemaFile = createSchemaFile(); JsonNode uriContent = resolver.resolve(schemaFile); assertThat(uriContent.path("type").asText(), is(equalTo("string"))); }
@Test public void classpathLinkIsResolvedToContent() { URI schemaFile; JsonNode uriContent; schemaFile = URI.create("classpath:schema/address.json"); uriContent = resolver.resolve(schemaFile); assertThat(uriContent.path("description").asText().length(), is(greaterThan(0))); schemaFile = URI.create("classpath:/schema/address.json"); uriContent = resolver.resolve(schemaFile); assertThat(uriContent.path("description").asText().length(), is(greaterThan(0))); schemaFile = URI.create("resource:schema/address.json"); uriContent = resolver.resolve(schemaFile); assertThat(uriContent.path("description").asText().length(), is(greaterThan(0))); schemaFile = URI.create("java:schema/address.json"); uriContent = resolver.resolve(schemaFile); assertThat(uriContent.path("description").asText().length(), is(greaterThan(0))); } |
### Question:
PatternRule implements Rule<JFieldVar, JFieldVar> { @Override public JFieldVar apply(String nodeName, JsonNode node, JsonNode parent, JFieldVar field, Schema currentSchema) { if (ruleFactory.getGenerationConfig().isIncludeJsr303Annotations() && isApplicableType(field)) { JAnnotationUse annotation = field.annotate(Pattern.class); annotation.param("regexp", node.asText()); } return field; } PatternRule(RuleFactory ruleFactory); @Override JFieldVar apply(String nodeName, JsonNode node, JsonNode parent, JFieldVar field, Schema currentSchema); }### Answer:
@Test public void testRegex() { when(config.isIncludeJsr303Annotations()).thenReturn(true); final String patternValue = "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$"; when(node.asText()).thenReturn(patternValue); when(fieldVar.annotate(Pattern.class)).thenReturn(annotation); when(fieldVar.type().boxify().fullName()).thenReturn(fieldClass.getTypeName()); JFieldVar result = rule.apply("node", node, null, fieldVar, null); assertSame(fieldVar, result); verify(fieldVar, times(isApplicable ? 1 : 0)).annotate(Pattern.class); verify(annotation, times(isApplicable ? 1 : 0)).param("regexp", patternValue); }
@Test public void jsrDisable() { when(config.isIncludeJsr303Annotations()).thenReturn(false); JFieldVar result = rule.apply("node", node, null, fieldVar, null); assertSame(fieldVar, result); verify(fieldVar, never()).annotate(Pattern.class); verify(annotation, never()).param(anyString(), anyString()); } |
### Question:
FormatRule implements Rule<JType, JType> { @Override public JType apply(String nodeName, JsonNode node, JsonNode parent, JType baseType, Schema schema) { Class<?> type = getType(node.asText()); if (type != null) { JType jtype = baseType.owner().ref(type); if (ruleFactory.getGenerationConfig().isUsePrimitives()) { jtype = jtype.unboxify(); } return jtype; } else { return baseType; } } protected FormatRule(RuleFactory ruleFactory); @Override JType apply(String nodeName, JsonNode node, JsonNode parent, JType baseType, Schema schema); static String ISO_8601_DATE_FORMAT; static String ISO_8601_TIME_FORMAT; static String ISO_8601_DATETIME_FORMAT; }### Answer:
@Test public void applyGeneratesTypeFromFormatValue() { TextNode formatNode = TextNode.valueOf(formatValue); JType result = rule.apply("fooBar", formatNode, null, new JCodeModel().ref(String.class), null); assertThat(result.fullName(), equalTo(expectedType.getName())); }
@Test public void applyDefaultsToBaseType() { TextNode formatNode = TextNode.valueOf("unknown-format"); JType baseType = new JCodeModel().ref(Long.class); JType result = rule.apply("fooBar", formatNode, null, baseType, null); assertThat(result, equalTo(baseType)); } |
### Question:
DescriptionRule implements Rule<JDocCommentable, JDocComment> { @Override public JDocComment apply(String nodeName, JsonNode node, JsonNode parent, JDocCommentable generatableType, Schema schema) { JDocComment javadoc = generatableType.javadoc(); String descriptionText = node.asText(); if(StringUtils.isNotBlank(descriptionText)) { String[] lines = node.asText().split("/\r?\n/"); for(String line : lines) { javadoc.append(line); } } return javadoc; } protected DescriptionRule(); @Override JDocComment apply(String nodeName, JsonNode node, JsonNode parent, JDocCommentable generatableType, Schema schema); }### Answer:
@Test public void applyAddsDescriptionToJavadoc() throws JClassAlreadyExistsException { JDefinedClass jclass = new JCodeModel()._class(TARGET_CLASS_NAME); ObjectMapper mapper = new ObjectMapper(); TextNode descriptionNode = mapper.createObjectNode().textNode("some description"); JDocComment result = rule.apply("fooBar", descriptionNode, null, jclass, null); assertThat(result, sameInstance(jclass.javadoc())); assertThat(result.size(), is(1)); assertThat((String) result.get(0), is("some description")); } |
### Question:
TitleRule implements Rule<JDocCommentable, JDocComment> { @Override public JDocComment apply(String nodeName, JsonNode node, JsonNode parent, JDocCommentable generatableType, Schema schema) { JDocComment javadoc = generatableType.javadoc(); javadoc.add(0, node.asText() + "\n<p>\n"); return javadoc; } protected TitleRule(); @Override JDocComment apply(String nodeName, JsonNode node, JsonNode parent, JDocCommentable generatableType, Schema schema); }### Answer:
@Test public void applyAddsDescriptionToJavadoc() throws JClassAlreadyExistsException { JDefinedClass jclass = new JCodeModel()._class(TARGET_CLASS_NAME); ObjectMapper mapper = new ObjectMapper(); TextNode titleNode = mapper.createObjectNode().textNode("some title"); JDocComment result = rule.apply("fooBar", titleNode, null, jclass, null); assertThat(result, sameInstance(jclass.javadoc())); assertThat(result.size(), is(1)); assertThat(result.get(0), is("some title\n<p>\n")); } |
### Question:
Inflector { public String pluralize(String word) { if (uncountables.contains(word.toLowerCase())) { return word; } return replaceWithFirstRule(word, plurals); } private Inflector(Builder builder); static Inflector.Builder createDefaultBuilder(); static Inflector getInstance(); String pluralize(String word); String singularize(String word); static Builder builder(); }### Answer:
@Test public void testPluralize() { assertThat(Inflector.getInstance().pluralize("mattress"), is("mattresses")); assertThat(Inflector.getInstance().pluralize("address"), is("addresses")); } |
### Question:
AsyncCountDownLatch extends CountDownLatch implements Completable.Source { @Override public void subscribe(Completable.Observer subscriber) { completionSignal.subscribe(subscriber); } AsyncCountDownLatch(int count); boolean isCompleted(); @Override void subscribe(Completable.Observer subscriber); void countDown(); }### Answer:
@Test public void test0() { AsyncCountDownLatch latch = new AsyncCountDownLatch(0); MyObserver subscriber = new MyObserver(); latch.subscribe(subscriber); Assert.assertFalse(subscriber.onSubscribeSeen.get()); Assert.assertTrue(subscriber.onCompleteSeen.get()); } |
### Question:
Loader { public abstract void load() throws Exception; Loader(final String databaseName, final SparkSession spark, final DatabaseStatistics statistics); abstract void load(); }### Answer:
@Test void propertyTableTest() { final Settings settings = new Settings.Builder("testingDB").build(); final DatabaseStatistics statistics = new DatabaseStatistics("testingDB"); final WidePropertyTableLoader pt_loader = new WidePropertyTableLoader(settings, spark, statistics); pt_loader.load(); final Dataset<Row> propertyTable = spark.sql("SELECT * FROM property_table"); final long ptNumberRows = propertyTable.count(); assert (ptNumberRows == numberSubjects); final long ptNumberColumns = propertyTable.columns().length - 1; assertEquals(numberPredicates, ptNumberColumns, "Number of columns must be " + numberPredicates); }
@Test void verticalPartitioningTest() { final Settings settings = new Settings.Builder("testingDB").build(); final DatabaseStatistics statistics = new DatabaseStatistics("testingDB"); final VerticalPartitioningLoader vp_loader = new VerticalPartitioningLoader(settings, spark, statistics); vp_loader.load(); final Dataset<Row> tables_list = spark.sql("SHOW tables"); final long tables_count = tables_list.count(); assert (tables_count > numberPredicates); } |
### Question:
FileService { @Transactional public List listAllFiles(){ return fileDao.listAllFiles(); } @Autowired void setFileDao(FileDao fileDao); boolean insert(File file); @Transactional List listAllFiles(); @Transactional boolean deleteFile(int id); }### Answer:
@Test public void testListAllFiles()throws Exception{ List files = fileService.listAllFiles(); File file = (File)files.get(0); assertEquals(files.isEmpty(), false); } |
### Question:
UserService { public User createUser(User user) { passwordHelper.encryptPassword(user); return userDao.createUser(user); } User createUser(User user); User updateUser(User user); void deleteUser(Long userId); User findOne(Long userId); List<User> findAll(); void changePassword(Long userId, String newPassword); Set<String> findRoles(String username); Set<String> findPermissions(String username); User findByUsername(String username); }### Answer:
@Test @Rollback(false) public void test1(){ List<Long> list = new ArrayList<Long>(); list.add(Long.parseLong("1")); User user = new User(); user.setUsername("qqq"); user.setPassword("qqq"); user.setSalt("1"); user.setRoleIds(list); user.setLocked(false); userService.createUser(user); assertNotNull("1"); } |
### Question:
HMACSignature { public static String calculateRFC2104HMAC(String data, String key) throws java.security.SignatureException { String result = null; try { Charset utf8ChartSet = Charset.forName("UTF-8"); SecretKeySpec signingKey = new SecretKeySpec(key.getBytes(utf8ChartSet), HMAC_SHA1_ALGORITHM); Mac mac = Mac.getInstance(HMAC_SHA1_ALGORITHM); mac.init(signingKey); byte[] rawHmac = mac.doFinal(data.getBytes(utf8ChartSet)); result = Base64.encodeToString(rawHmac); } catch (NoSuchAlgorithmException | InvalidKeyException e) { throw new SignatureException("Failed to generate HMAC : " + e.getMessage()); } return result; } static String calculateRFC2104HMAC(String data, String key); }### Answer:
@Test public void calculateRFC2104HMACTest() throws SignatureException { String date = "Tue, 13 May 2014 20:10:38 +0200"; String resource = "/questionnaires/58"; String method = "GET"; String stringToSign = new StringBuilder().append(method).append(" ").append(resource).append("\n").append(date) .toString(); String secret = "L0LTMJ1XAMEY13FT27MWZMQX1LWK8I1L"; String signature = HMACSignature.calculateRFC2104HMAC(stringToSign, secret); assertThat(signature).isEqualTo("oVMRHIMFzmt0NrczGQG8iAu9prc="); } |
### Question:
AcronymGeneratorImpl implements AcronymGenerator { @Override public String generate(String givenNames, String surname) { Assert.hasText(givenNames, "Given name is required"); Assert.hasText(surname, "Surname is required"); int wordsSize = 0; wordsSize += givenNames.length(); wordsSize += surname.length(); if (wordsSize < DEFAULT_SIZE) { return StringUtils.upperCase(new StringBuilder().append(givenNames).append(surname).toString()); } int fromGivenNames = 4; int fromSurname = 4; if (givenNames.length() < 4) { fromGivenNames = givenNames.length(); fromSurname += (4 - givenNames.length()); } if (surname.length() < 4) { fromSurname = surname.length(); fromGivenNames += (4 - surname.length()); } StringBuilder builder = new StringBuilder(); builder.append(givenNames.substring(0, fromGivenNames)); builder.append(surname.substring(0, fromSurname)); return StringUtils.upperCase(builder.toString()); } @Override String generate(String givenNames, String surname); }### Answer:
@Test public void generateTest() { String givenNames = "Eva"; String surname = "Järvinen"; String acronym = acronymGenerator.generate(givenNames, surname); assertThat(acronym).isEqualTo("EVAJÄRVI"); } |
### Question:
QuestionnairesUI extends UI { @Override public void init(VaadinRequest request) { logger.info("New Vaadin UI created"); String invitation = request.getParameter("invitation"); logger.info("Invitation: {} of sessions : {}", invitation); setSizeFull(); GazpachoViewDisplay viewDisplay = new GazpachoViewDisplay(); setContent(viewDisplay); navigator = new Navigator(this, (ViewDisplay) viewDisplay); navigator.addProvider(viewProvider); navigator.setErrorProvider(new GazpachoErrorViewProvider()); if (isUserSignedIn()) { navigator.navigateTo(QuestionnaireView.NAME); } else { navigator.navigateTo(LoginView.NAME); } } @Override void init(VaadinRequest request); boolean isUserInRole(String role); String getPrincipalName(); boolean isUserSignedIn(); }### Answer:
@Test public void initTest() throws IOException, SAXException { System.out.println("hola holitas" + contextPath); final WebClient webClient = new WebClient(); webClient.addRequestHeader("Cache-Control", "no-cache, no-store, must-revalidate"); webClient.addRequestHeader("Pragma", "no-cache"); webClient.addRequestHeader("Expires", "0"); final HtmlPage page = webClient.getPage(contextPath.toExternalForm() + "?invitation=12345678"); final String pageAsText = page.asText(); webClient.closeAllWindows(); } |
### Question:
ObjectHandler implements Serializable { public Serializable getObject() { return (Serializable) object; } ObjectHandler(Object obj); boolean isGraalObject(); boolean isGraalObject(Object object); Object invoke(String method, ArrayList<Object> params); Serializable getObject(); void setObject(Serializable object); void write(ObjectOutputStream out); void read(ObjectInputStream in); }### Answer:
@Test public void testJavaObject() throws Exception { String s = "helloworld"; ObjectHandler obj = new ObjectHandler(s); byte[] bytes = Utils.toBytes(obj); ObjectHandler obj2 = (ObjectHandler) Utils.toObject(bytes); assert s.equals(obj2.getObject()); } |
### Question:
ServerInfo implements Serializable { public void addLabels(Map keyValues) { if (keyValues == null) { throw new NullPointerException("Labels must not be null"); } this.labels.putAll(keyValues); } ServerInfo(InetSocketAddress addr); InetSocketAddress getHost(); String getRegion(); void addLabels(Map keyValues); boolean matchNodeSelectorSpec(NodeSelectorSpec spec); transient Map<InetSocketAddress, NodeMetric> metrics; public int processorCount; }### Answer:
@Test(expected = NullPointerException.class) public void addLabelsWithNull() { ServerInfo server = new ServerInfo(null); server.addLabels(null); } |
### Question:
Server implements RemoteRaftServer { public UUID getMyServerID() { return pState.myServerID; } Server(StateMachineApplier applier); UUID getMyServerID(); void start(); void stop(); int appendEntries(
int term,
UUID leader,
int prevLogIndex,
int prevLogTerm,
List<LogEntry> entries,
int leaderCommit); int requestVote(int term, UUID candidate, int lastLogIndex, int lastLogTerm); Object applyToStateMachine(Object operation); void addServer(UUID id, RemoteRaftServer server); static final int LEADER_HEARTBEAT_TIMEOUT; }### Answer:
@Test public void getMyServerID() throws Exception { raftServer[0].getMyServerID(); } |
### Question:
Server implements RemoteRaftServer { RemoteRaftServer getCurrentLeader() { return getServer(vState.getCurrentLeader()); } Server(StateMachineApplier applier); UUID getMyServerID(); void start(); void stop(); int appendEntries(
int term,
UUID leader,
int prevLogIndex,
int prevLogTerm,
List<LogEntry> entries,
int leaderCommit); int requestVote(int term, UUID candidate, int lastLogIndex, int lastLogTerm); Object applyToStateMachine(Object operation); void addServer(UUID id, RemoteRaftServer server); static final int LEADER_HEARTBEAT_TIMEOUT; }### Answer:
@Test public void getCurrentLeader() throws Exception { raftServer[0].getCurrentLeader(); } |
### Question:
Server implements RemoteRaftServer { int majorityQuorumSize() { int f = fullQuorumSize() / 2 + 1; return f; } Server(StateMachineApplier applier); UUID getMyServerID(); void start(); void stop(); int appendEntries(
int term,
UUID leader,
int prevLogIndex,
int prevLogTerm,
List<LogEntry> entries,
int leaderCommit); int requestVote(int term, UUID candidate, int lastLogIndex, int lastLogTerm); Object applyToStateMachine(Object operation); void addServer(UUID id, RemoteRaftServer server); static final int LEADER_HEARTBEAT_TIMEOUT; }### Answer:
@Test public void majorityQuorumSize() throws Exception { raftServer[0].majorityQuorumSize(); } |
### Question:
Server implements RemoteRaftServer { int fullQuorumSize() { return vState.otherServers.size() + 1; } Server(StateMachineApplier applier); UUID getMyServerID(); void start(); void stop(); int appendEntries(
int term,
UUID leader,
int prevLogIndex,
int prevLogTerm,
List<LogEntry> entries,
int leaderCommit); int requestVote(int term, UUID candidate, int lastLogIndex, int lastLogTerm); Object applyToStateMachine(Object operation); void addServer(UUID id, RemoteRaftServer server); static final int LEADER_HEARTBEAT_TIMEOUT; }### Answer:
@Test public void fullQuorumSize() throws Exception { raftServer[0].fullQuorumSize(); } |
### Question:
Server implements RemoteRaftServer { RemoteRaftServer getServer(UUID serverId) { return vState.otherServers.get( serverId); } Server(StateMachineApplier applier); UUID getMyServerID(); void start(); void stop(); int appendEntries(
int term,
UUID leader,
int prevLogIndex,
int prevLogTerm,
List<LogEntry> entries,
int leaderCommit); int requestVote(int term, UUID candidate, int lastLogIndex, int lastLogTerm); Object applyToStateMachine(Object operation); void addServer(UUID id, RemoteRaftServer server); static final int LEADER_HEARTBEAT_TIMEOUT; }### Answer:
@Test public void getServer() throws Exception { assert (raftServer[0].getServer(raftServer[1].getMyServerID()) == serverPolicy[1]); } |
### Question:
Server implements RemoteRaftServer { public void addServer(UUID id, RemoteRaftServer server) { vState.otherServers.put(id, server); } Server(StateMachineApplier applier); UUID getMyServerID(); void start(); void stop(); int appendEntries(
int term,
UUID leader,
int prevLogIndex,
int prevLogTerm,
List<LogEntry> entries,
int leaderCommit); int requestVote(int term, UUID candidate, int lastLogIndex, int lastLogTerm); Object applyToStateMachine(Object operation); void addServer(UUID id, RemoteRaftServer server); static final int LEADER_HEARTBEAT_TIMEOUT; }### Answer:
@Test public void addServer() throws Exception { } |
### Question:
Server implements RemoteRaftServer { public void start() { this.become(State.FOLLOWER, vState.getState()); } Server(StateMachineApplier applier); UUID getMyServerID(); void start(); void stop(); int appendEntries(
int term,
UUID leader,
int prevLogIndex,
int prevLogTerm,
List<LogEntry> entries,
int leaderCommit); int requestVote(int term, UUID candidate, int lastLogIndex, int lastLogTerm); Object applyToStateMachine(Object operation); void addServer(UUID id, RemoteRaftServer server); static final int LEADER_HEARTBEAT_TIMEOUT; }### Answer:
@Test public void start() throws Exception { raftServer[0].start(); } |
### Question:
Server implements RemoteRaftServer { synchronized State become(State newState, State preconditionState) { if (vState.getState() == preconditionState) { switch (vState.getState()) { case NONE: break; case LEADER: leader.stop(); break; case FOLLOWER: follower.stop(); break; case CANDIDATE: candidate.stop(); } switch (newState) { case NONE: vState.setState(State.NONE, vState.getState()); break; case LEADER: leader.start(); break; case FOLLOWER: follower.start(); break; case CANDIDATE: candidate.start(); } } return vState.getState(); } Server(StateMachineApplier applier); UUID getMyServerID(); void start(); void stop(); int appendEntries(
int term,
UUID leader,
int prevLogIndex,
int prevLogTerm,
List<LogEntry> entries,
int leaderCommit); int requestVote(int term, UUID candidate, int lastLogIndex, int lastLogTerm); Object applyToStateMachine(Object operation); void addServer(UUID id, RemoteRaftServer server); static final int LEADER_HEARTBEAT_TIMEOUT; }### Answer:
@Test public void become() throws Exception { raftServer[0].start(); raftServer[0].become(FOLLOWER, FOLLOWER); assert (raftServer[0].getState() == FOLLOWER); raftServer[0].become(CANDIDATE, FOLLOWER); assert (raftServer[0].getState() == CANDIDATE); raftServer[0].become(LEADER, CANDIDATE); assert (raftServer[0].getState() == LEADER); } |
### Question:
Server implements RemoteRaftServer { void applyCommitted() { int lastApplied; while (vState.getCommitIndex() > (lastApplied = vState.getLastApplied())) { LogEntry entry; synchronized (pState) { entry = pState.log().get(vState.incrementLastApplied(lastApplied)); } logger.fine(pState.myServerID + ": Applying " + entry); try { applier.apply(entry.operation); } catch (java.lang.Exception e) { logger.warning( String.format( "Operation %s generated exception %s on replica. " + "This should generally not be a problem, as the same exception should be " + "generated on the master and all other replicas, and returned to the client " + "for appropriate action (e.g. retry)", entry, e)); } } } Server(StateMachineApplier applier); UUID getMyServerID(); void start(); void stop(); int appendEntries(
int term,
UUID leader,
int prevLogIndex,
int prevLogTerm,
List<LogEntry> entries,
int leaderCommit); int requestVote(int term, UUID candidate, int lastLogIndex, int lastLogTerm); Object applyToStateMachine(Object operation); void addServer(UUID id, RemoteRaftServer server); static final int LEADER_HEARTBEAT_TIMEOUT; }### Answer:
@Test public void applyCommitted() throws Exception { raftServer[0].applyCommitted(); } |
### Question:
Server implements RemoteRaftServer { void respondToRemoteTerm(int remoteTerm) { int currentTerm = pState.getCurrentTerm(); if (currentTerm < remoteTerm) { pState.setCurrentTerm(remoteTerm, currentTerm); become(State.FOLLOWER, vState.getState()); } } Server(StateMachineApplier applier); UUID getMyServerID(); void start(); void stop(); int appendEntries(
int term,
UUID leader,
int prevLogIndex,
int prevLogTerm,
List<LogEntry> entries,
int leaderCommit); int requestVote(int term, UUID candidate, int lastLogIndex, int lastLogTerm); Object applyToStateMachine(Object operation); void addServer(UUID id, RemoteRaftServer server); static final int LEADER_HEARTBEAT_TIMEOUT; }### Answer:
@Test public void respondToRemoteTerm() throws Exception { for (Server s : raftServer) { s.start(); } raftServer[0].become(CANDIDATE, FOLLOWER); int leaderCount = 0; UUID initialLeader = null; long startTime = System.currentTimeMillis(); while (leaderCount == 0 && System.currentTimeMillis() < startTime + Server.LEADER_HEARTBEAT_TIMEOUT) { for (Server s : raftServer) { if (s.getState() == LEADER) { initialLeader = s.getMyServerID(); leaderCount++; } } } assertEquals(raftServer[0].getMyServerID(), initialLeader); raftServer[0].respondToRemoteTerm(2); Assert.assertEquals(FOLLOWER, raftServer[0].getState()); } |
### Question:
Server implements RemoteRaftServer { public Object applyToStateMachine(Object operation) throws java.lang.Exception { logger.fine(String.format("%s: applyToStateMachine(%s)", pState.myServerID, operation)); if (vState.getState() == State.LEADER) { return leader.applyToStateMachine(operation); } else { throw new LeaderException( String.format("Current Leader is %s", vState.getCurrentLeader()), getCurrentLeader()); } } Server(StateMachineApplier applier); UUID getMyServerID(); void start(); void stop(); int appendEntries(
int term,
UUID leader,
int prevLogIndex,
int prevLogTerm,
List<LogEntry> entries,
int leaderCommit); int requestVote(int term, UUID candidate, int lastLogIndex, int lastLogTerm); Object applyToStateMachine(Object operation); void addServer(UUID id, RemoteRaftServer server); static final int LEADER_HEARTBEAT_TIMEOUT; }### Answer:
@Test public void doRPC() throws java.lang.Exception { successfulLeaderElection(); String[] methods = {"fooMethod", "barMethod"}; ArrayList<Object> args = new ArrayList<Object>(); for (String method : methods) { raftServer[0].applyToStateMachine(new ConsensusRSMPolicy.RPC(method, args)); } } |
### Question:
AppObjectSandboxProvider implements SandboxProvider, Serializable { @Override public ServerUpcalls getSandbox(ServerPolicyLibrary origin, UUID transactionId) throws Exception { if (!this.sandboxes.containsKey(transactionId)) { AppObjectShimServerPolicy sandbox = AppObjectShimServerPolicy.cloneInShimServerPolicy(origin.getAppObject()); this.sandboxes.put(transactionId, sandbox); } return this.sandboxes.get(transactionId); } @Override ServerUpcalls getSandbox(ServerPolicyLibrary origin, UUID transactionId); @Override ServerUpcalls getSandbox(UUID transactionId); @Override void removeSandbox(UUID transactionId); }### Answer:
@Test public void test_get_copy_of_appObject() throws Exception { UUID txId = UUID.randomUUID(); Serializable coreOrigin = "aaa"; AppObject originAppObject = new AppObject(coreOrigin); TwoPCCohortPolicy.TwoPCCohortServerPolicy origin = new TwoPCCohortPolicy.TwoPCCohortServerPolicy(); origin.$__initialize(originAppObject); AppObjectSandboxProvider provider = new AppObjectSandboxProvider(); AppObjectShimServerPolicy sandbox = (AppObjectShimServerPolicy) provider.getSandbox(origin, txId); AppObject sandboxAppObject = sandbox.getAppObject(); assertNotSame(sandboxAppObject, originAppObject); } |
### Question:
AppObjectShimServerPolicy extends DefaultPolicy.DefaultServerPolicy { public static AppObjectShimServerPolicy cloneInShimServerPolicy(AppObject appObject) throws Exception { AppObject deepCloneAppObject = (AppObject) Utils.ObjectCloner.deepCopy(appObject); return new AppObjectShimServerPolicy(appObject, deepCloneAppObject); } private AppObjectShimServerPolicy(AppObject origin, AppObject sandbox); MethodInvocationResponse onRPC(MethodInvocationRequest request); AppObject getOriginMaster(); static AppObjectShimServerPolicy cloneInShimServerPolicy(AppObject appObject); }### Answer:
@Test public void test_policy_saves_copy() throws Exception { Integer[] originCore = new Integer[] {1, 2, 3}; AppObject origin = new AppObject(originCore); AppObjectShimServerPolicy policy = AppObjectShimServerPolicy.cloneInShimServerPolicy(origin); AppObject retrieved = policy.getAppObject(); assertNotSame("AppObject retrieved is a brand new one", origin, retrieved); assertNotSame( "Core of AppObject retrieved is a deep copy", origin.getObject(), retrieved.getObject()); Integer[] retrievedCore = (Integer[]) retrieved.getObject(); retrievedCore[0] = 777; assertEquals("original value should not affected", 1, (long) originCore[0]); } |
### Question:
TransactionWrapper { public ArrayList<Object> getRPCParams() { return getTransactionRPCParams(this.transactionId, this.rpcMethod, this.rpcParams); } TransactionWrapper(String method, ArrayList<Object> params); TransactionWrapper(UUID txnId, String method, ArrayList<Object> params); static ArrayList<Object> getTransactionRPCParams(
UUID transactionId, String method, ArrayList<Object> params); ArrayList<Object> getRPCParams(); UUID getTransaction(); String getInnerRPCMethod(); ArrayList<Object> getInnerRPCParams(); static final String txWrapperTag; }### Answer:
@Test public void test_wrap_rpc_in_tx() { String method = "foo"; ArrayList<Object> params = new ArrayList<Object>(); UUID transactionId = UUID.randomUUID(); TransactionWrapper wrapper = new TransactionWrapper(transactionId, method, params); ArrayList<Object> wrappedMessage = wrapper.getRPCParams(); assertEquals(wrappedMessage.get(0), transactionId); ArrayList<Object> innerRPCMessage = (ArrayList<Object>) wrappedMessage.get(1); assertEquals(innerRPCMessage.get(0), method); assertEquals(innerRPCMessage.get(1), params); } |
### Question:
TwoPCLocalParticipants implements Serializable { public void fanOutTransactionPrimitive(UUID transactionId, String primitiveMethod) throws TransactionExecutionException { ArrayList<Object> paramsTX = TransactionWrapper.getTransactionRPCParams(transactionId, primitiveMethod, null); TransactionContext.enterTransaction( transactionId, this.getParticipantManager(transactionId)); try { for (ClientPolicy p : this.getParticipants(transactionId)) { if (TransactionContext.getProcessedClients().contains(p)) { continue; } TransactionContext.getProcessedClients().add(p); try { p.onRPC(TransactionWrapper.txWrapperTag, paramsTX); } catch (Exception e) { throw new TransactionExecutionException( "2PC transaction exception: " + primitiveMethod, e); } } } finally { TransactionContext.leaveTransaction(); } } TwoPCParticipants getParticipantManager(UUID transactionId); Collection<ClientPolicy> getParticipants(UUID transactionId); void addParticipants(UUID transactionId, Collection<ClientPolicy> participants); void cleanup(UUID transactionId); void fanOutTransactionPrimitive(UUID transactionId, String primitiveMethod); Boolean allParticipantsVotedYes(UUID transactionId); }### Answer:
@Test public void test_fanout_to_all() throws Exception { participants.fanOutTransactionPrimitive(id, "tx_commit"); verify(part1).onRPC(eq("tx_rpc"), any(ArrayList.class)); ArgumentCaptor<ArrayList> argumentCaptor = ArgumentCaptor.forClass(ArrayList.class); verify(part2).onRPC(eq("tx_rpc"), argumentCaptor.capture()); ArrayList<Object> params = argumentCaptor.getValue(); TransactionWrapper tx = new TransactionWrapper("tx_rpc", params); assertEquals("tx_commit", tx.getInnerRPCMethod()); } |
### Question:
TLSTransactionManager implements TransactionManager, Serializable { @Override public void commit(UUID transactionId) { this.localStatusManager.setStatus(transactionId, LocalStatus.COMMITTED); this.validator.onCommit(transactionId); try { this.localParticipantsManager.fanOutTransactionPrimitive( transactionId, TwoPCPrimitive.Commit); } catch (TransactionExecutionException e) { } this.localParticipantsManager.cleanup(transactionId); } void setValidator(TransactionValidator validator); @Override void join(UUID transactionId); @Override void leave(UUID transactionId); @Override Vote vote(UUID transactionId); @Override void commit(UUID transactionId); @Override void abort(UUID transactionId); }### Answer:
@Test public void test_commit_fanout() throws Exception { txManager.commit(txId); verify(this.participantsManager).fanOutTransactionPrimitive(txId, "tx_commit"); } |
### Question:
TLS2PCCoordinator implements TwoPCCoordinator { @Override public void beginTransaction() throws TransactionAlreadyStartedException { if (TransactionContext.getCurrentTransaction() != null) { throw new TransactionAlreadyStartedException("nested transaction is unsupported."); } UUID transactionId = UUID.randomUUID(); TwoPCParticipants participants = this.localParticipantsManager.getParticipantManager(transactionId); TransactionContext.enterTransaction(transactionId, participants); } TLS2PCCoordinator(TransactionValidator validator); @Override void beginTransaction(); @Override UUID getTransactionId(); @Override void join(UUID transactionId); @Override void leave(UUID transactionId); @Override Vote vote(UUID transactionId); @Override void commit(UUID transactionId); @Override void abort(UUID transactionId); }### Answer:
@Test(expected = TransactionAlreadyStartedException.class) public void test_coordinator_throws_on_reentrant() throws TransactionAlreadyStartedException { TransactionContext.enterTransaction(UUID.randomUUID(), participantManager); coordinator.beginTransaction(); } |
### Question:
TLS2PCCoordinator implements TwoPCCoordinator { @Override public Vote vote(UUID transactionId) throws TransactionExecutionException { try { if (!this.validator.promises(transactionId)) { return Vote.NO; } } catch (Exception e) { logger.log(Level.SEVERE, "coordinator 2PC preparation failed", e); return Vote.NO; } TransactionContext.initPrecessed(); if (this.localParticipantsManager.allParticipantsVotedYes(transactionId)) { return Vote.YES; } else { return Vote.NO; } } TLS2PCCoordinator(TransactionValidator validator); @Override void beginTransaction(); @Override UUID getTransactionId(); @Override void join(UUID transactionId); @Override void leave(UUID transactionId); @Override Vote vote(UUID transactionId); @Override void commit(UUID transactionId); @Override void abort(UUID transactionId); }### Answer:
@Test public void test_yes_if_promise_went_well() throws Exception { when(validator.promises(transactionId)).thenReturn(true); when(participants.allParticipantsVotedYes(transactionId)).thenReturn(true); TransactionManager.Vote vote = this.coordinator.vote(transactionId); assertEquals(TransactionManager.Vote.YES, vote); }
@Test public void test_nogo_if_promise_rejected() throws Exception { when(validator.promises(transactionId)).thenReturn(false); when(participants.allParticipantsVotedYes(transactionId)).thenReturn(true); TransactionManager.Vote vote = this.coordinator.vote(transactionId); assertEquals(TransactionManager.Vote.NO, vote); } |
### Question:
ExtResourceTransactionManager implements TransactionManager, Serializable { @Override public Vote vote(UUID transactionId) throws TransactionExecutionException { Vote vote = this.internalTransactionManager.vote(transactionId); if (vote.equals(Vote.YES)) { Vote voteExtResource = this.getBusinessObject(transactionId).vote(transactionId); if (!Vote.YES.equals(voteExtResource)) { logger.log(Level.WARNING, "inconsistent resource state; transaction aborted."); this.internalTransactionManager.abort(transactionId); vote = Vote.NO; } } return vote; } ExtResourceTransactionManager(
SandboxProvider sandboxProvider, TransactionManager internalTransactionManager); @Override void join(UUID transactionId); @Override void leave(UUID transactionId); @Override Vote vote(UUID transactionId); @Override void commit(UUID transactionId); @Override void abort(UUID transactionId); }### Answer:
@Test public void test_vote_yes_if_both_yes() throws Exception { when(businessObject.vote(transcationId)).thenReturn(TransactionManager.Vote.YES); when(intTxManager.vote(transcationId)).thenReturn(TransactionManager.Vote.YES); TransactionManager.Vote vote = txMgr.vote(transcationId); assertEquals(TransactionManager.Vote.YES, vote); }
@Test public void test_vote_no_if_extResource_fails() throws Exception { when(intTxManager.vote(transcationId)).thenReturn(TransactionManager.Vote.YES); when(businessObject.vote(transcationId)).thenReturn(TransactionManager.Vote.UNCERTIAN); TransactionManager.Vote vote = txMgr.vote(transcationId); assertEquals(TransactionManager.Vote.NO, vote); } |
### Question:
ExtResourceTransactionManager implements TransactionManager, Serializable { @Override public void commit(UUID transactionId) { this.getBusinessObject(transactionId).commit(transactionId); this.internalTransactionManager.commit(transactionId); } ExtResourceTransactionManager(
SandboxProvider sandboxProvider, TransactionManager internalTransactionManager); @Override void join(UUID transactionId); @Override void leave(UUID transactionId); @Override Vote vote(UUID transactionId); @Override void commit(UUID transactionId); @Override void abort(UUID transactionId); }### Answer:
@Test public void test_tx_primitive_engages_intTxMgr_and_extResource() { txMgr.commit(transcationId); verify(intTxManager, times(1)).commit(transcationId); verify(businessObject, times(1)).commit(transcationId); } |
### Question:
FlagValueCalculator { @Nullable public State queryState(@Nullable RegionAssociable subject, StateFlag... flags) { State value = null; for (StateFlag flag : flags) { value = StateFlag.combine(value, queryValue(subject, flag)); if (value == State.DENY) { break; } } return value; } FlagValueCalculator(List<ProtectedRegion> regions, @Nullable ProtectedRegion globalRegion); Result getMembership(RegionAssociable subject); @Nullable State queryState(@Nullable RegionAssociable subject, StateFlag... flags); @Nullable State queryState(@Nullable RegionAssociable subject, StateFlag flag); @Nullable V queryValue(@Nullable RegionAssociable subject, Flag<V> flag); Collection<V> queryAllValues(@Nullable RegionAssociable subject, Flag<V> flag); int getPriority(final ProtectedRegion region); @SuppressWarnings("unchecked") V getEffectiveFlag(final ProtectedRegion region, Flag<V> flag, @Nullable RegionAssociable subject); }### Answer:
@Test public void testQueryStateWilderness() throws Exception { MockApplicableRegionSet mock = new MockApplicableRegionSet(); StateFlag flag1 = new StateFlag("test1", false); StateFlag flag2 = new StateFlag("test2", true); FlagValueCalculator result = mock.getFlagCalculator(); assertThat(result.queryState(null, flag1), is((State) null)); assertThat(result.queryState(null, flag2), is(State.ALLOW)); } |
### Question:
FlagValueCalculator { public int getPriority(final ProtectedRegion region) { if (region == globalRegion) { return Integer.MIN_VALUE; } else { return region.getPriority(); } } FlagValueCalculator(List<ProtectedRegion> regions, @Nullable ProtectedRegion globalRegion); Result getMembership(RegionAssociable subject); @Nullable State queryState(@Nullable RegionAssociable subject, StateFlag... flags); @Nullable State queryState(@Nullable RegionAssociable subject, StateFlag flag); @Nullable V queryValue(@Nullable RegionAssociable subject, Flag<V> flag); Collection<V> queryAllValues(@Nullable RegionAssociable subject, Flag<V> flag); int getPriority(final ProtectedRegion region); @SuppressWarnings("unchecked") V getEffectiveFlag(final ProtectedRegion region, Flag<V> flag, @Nullable RegionAssociable subject); }### Answer:
@Test public void testGetEffectivePriority() throws Exception { MockApplicableRegionSet mock = new MockApplicableRegionSet(); ProtectedRegion region = mock.add(30); FlagValueCalculator result = mock.getFlagCalculator(); assertThat(result.getPriority(region), is(30)); }
@Test public void testGetEffectivePriorityGlobalRegion() throws Exception { MockApplicableRegionSet mock = new MockApplicableRegionSet(); ProtectedRegion region = mock.global(); FlagValueCalculator result = mock.getFlagCalculator(); assertThat(result.getPriority(region), is(Integer.MIN_VALUE)); } |
### Question:
PathMatchers { @Factory public static Matcher<Path> contains(String fileName) { return new DirectoryContains(fileName); } PathMatchers(); @Factory static Matcher<Path> contains(String fileName); @Factory static Matcher<Path> isDirectory(); @Factory static Matcher<Path> exists(LinkOption... options); @Factory static Matcher<Path> hasFilesCount(int expectedCount); @Factory static Matcher<Path> hasFilesCount(int expectedCount, String glob); }### Answer:
@Test public void shouldContains() throws Exception { Files.write(directory.resolve("file"), "content".getBytes(StandardCharsets.UTF_8)); assertThat(directory, contains("file")); }
@Test(expected = AssertionError.class) public void shouldFailIfNotContains() throws Exception { assertThat(directory, contains("file")); }
@Test public void shouldNotContains() throws Exception { assertThat(directory, not(contains("file"))); } |
### Question:
PathMatchers { @Factory public static Matcher<Path> exists(LinkOption... options) { return new Exists(options); } PathMatchers(); @Factory static Matcher<Path> contains(String fileName); @Factory static Matcher<Path> isDirectory(); @Factory static Matcher<Path> exists(LinkOption... options); @Factory static Matcher<Path> hasFilesCount(int expectedCount); @Factory static Matcher<Path> hasFilesCount(int expectedCount, String glob); }### Answer:
@Test public void shouldSymlinkNotExists() throws Exception { Path file = directory.resolve("file"); Path fileLinked = directory.resolve("file-linked"); Files.createSymbolicLink(file, fileLinked); assertThat(file, not(exists())); }
@Test public void shouldSymlinkExistsIfOptionConfigured() throws Exception { Path file = directory.resolve("file"); Path fileLinked = directory.resolve("file-linked"); Files.createSymbolicLink(file, fileLinked); System.out.println(Files.isSymbolicLink(file)); assertThat(file, exists(LinkOption.NOFOLLOW_LINKS)); }
@Test public void shouldExists() throws Exception { Path file = directory.resolve("file"); Files.write(file, "content".getBytes(StandardCharsets.UTF_8)); assertThat(file, exists()); }
@Test(expected = AssertionError.class) public void shouldFailIfNotExists() throws Exception { assertThat(directory.resolve("file"), exists()); }
@Test public void shouldNotExists() throws Exception { Path file = directory.resolve("file"); assertThat(file, not(exists())); } |
### Question:
PathMatchers { @Factory public static Matcher<Path> hasFilesCount(int expectedCount) { return new FilesCount(expectedCount); } PathMatchers(); @Factory static Matcher<Path> contains(String fileName); @Factory static Matcher<Path> isDirectory(); @Factory static Matcher<Path> exists(LinkOption... options); @Factory static Matcher<Path> hasFilesCount(int expectedCount); @Factory static Matcher<Path> hasFilesCount(int expectedCount, String glob); }### Answer:
@Test public void shouldHasFilesCount() throws Exception { Files.write(directory.resolve("first"), "content".getBytes(StandardCharsets.UTF_8)); Files.write(directory.resolve("second"), "content".getBytes(StandardCharsets.UTF_8)); assertThat(directory, hasFilesCount(2)); }
@Test public void shouldHasFilesCountByGlob() throws Exception { Files.write(directory.resolve("first-file"), "content".getBytes(StandardCharsets.UTF_8)); Files.write(directory.resolve("second-file"), "content".getBytes(StandardCharsets.UTF_8)); Files.write(directory.resolve("other"), "content".getBytes(StandardCharsets.UTF_8)); assertThat(directory, hasFilesCount(2, "*-file")); }
@Test(expected = AssertionError.class) public void shouldFailIfNotHasSuchFiles() throws Exception { assertThat(directory, hasFilesCount(2)); }
@Test(expected = AssertionError.class) public void shouldFailIfNotHasSuchFilesByGlob() throws Exception { Files.write(directory.resolve("first"), "content".getBytes(StandardCharsets.UTF_8)); assertThat(directory, hasFilesCount(2, "*-file")); } |
### Question:
SameAsURIMatcher extends TypeSafeDiagnosingMatcher<URI> { @Factory public static SameAsURIMatcher sameAsURI(URI expectedUri) { return new SameAsURIMatcher(expectedUri); } private SameAsURIMatcher(URI expectedUri); @Override void describeTo(Description description); SameAsURIMatcher filteredWith(UriDiffFilter... filters); @Factory static SameAsURIMatcher sameAsURI(URI expectedUri); @Factory static Matcher<String> sameAsURI(String expectedUri); }### Answer:
@Test(expected = AssertionError.class) public void shouldThrowAssertionErrorOnDifferentURIs() throws Exception { assertThat(ACTUAL_URI, sameAsURI(EXPECTED_URI)); }
@Test(expected = AssertionError.class) public void shouldThrowAssertionErrorWithoutFilters() throws Exception { assertThat(ACTUAL_AS_EXPECTED_WITH_PARAM_AND_SCHEME_URI, sameAsURI(EXPECTED_URI)); }
@Test public void shouldUseDefaultReport() throws Exception { Description description = new StringDescription(); sameAsURI(EXPECTED_URI).describeMismatch(ACTUAL_URI, description); assertThat("Description should contain actual and diff", description.toString(), both(containsString(UriDiffer.diff().actual(ACTUAL_URI).expected(EXPECTED_URI).changes().report())) .and(containsString(ACTUAL_URI.toString()))); } |
### Question:
HasTextMatcher extends TypeSafeMatcher<WebDriver> { @Factory public static Matcher<WebDriver> textOnCurrentPageContains(String text) { return textOnCurrentPage(CoreMatchers.containsString(text)); } protected HasTextMatcher(Matcher<String> matcher); @Override void describeTo(Description description); @Factory static Matcher<WebDriver> textOnCurrentPageContains(String text); @Factory static Matcher<WebDriver> textOnCurrentPage(Matcher<String> text); }### Answer:
@Test public void worksPositive() { WebDriver driver = mock(WebDriver.class); when(driver.getPageSource()).thenReturn(HTML_BODY); assertThat("Text should be found", driver, textOnCurrentPageContains(TEXT_PART)); }
@Test public void worksNegative() { final WebDriver driver = mock(WebDriver.class); when(driver.getPageSource()).thenReturn(ANOTHER_HTML_BODY); assertThat("Should not found text", driver, not(textOnCurrentPageContains(TEXT_PART))); } |
### Question:
CanFindElementMatcher extends TypeSafeMatcher<WebDriver> { @Factory public static Matcher<WebDriver> canFindElement(By by) { return new CanFindElementMatcher(by); } protected CanFindElementMatcher(By by); @Override void describeTo(Description description); @Factory static Matcher<WebDriver> canFindElement(By by); }### Answer:
@Test public void worksPositive() { WebDriver driver = mock(WebDriver.class); WebElement element = mock(WebElement.class); when(driver.findElement(XPATH_EXISTS)).thenReturn(element); assertThat("Element should be found", driver, canFindElement(XPATH_EXISTS)); }
@Test public void worksNegative() { WebDriver driver = mock(WebDriver.class); when(driver.findElement(XPATH_NOT_EXISTS)).thenThrow(new NoSuchElementException("")); assertThat("Element should not be found", driver, not(canFindElement(XPATH_NOT_EXISTS))); } |
### Question:
PathMatchers { @Factory public static Matcher<Path> isDirectory() { return new IsDirectory(); } PathMatchers(); @Factory static Matcher<Path> contains(String fileName); @Factory static Matcher<Path> isDirectory(); @Factory static Matcher<Path> exists(LinkOption... options); @Factory static Matcher<Path> hasFilesCount(int expectedCount); @Factory static Matcher<Path> hasFilesCount(int expectedCount, String glob); }### Answer:
@Test public void shouldIsDirectory() throws Exception { assertThat(directory, isDirectory()); }
@Test(expected = AssertionError.class) public void shouldFailIfNotADirectory() throws Exception { assertThat(directory.resolve("file"), isDirectory()); }
@Test public void shouldNotIsDirectory() throws Exception { Path file = directory.resolve("file"); Files.write(file, "content".getBytes(StandardCharsets.UTF_8)); assertThat(file, not(isDirectory())); }
@Test public void shouldNotFailIfFileDoesNotExists() throws Exception { Path file = directory.resolve("file"); assertThat(file, not(isDirectory())); } |
### Question:
HasCookieMatcher extends TypeSafeMatcher<WebDriver> { @Factory public static Matcher<WebDriver> hasCookie(String name) { return new HasCookieMatcher(name); } protected HasCookieMatcher(String name); @Override void describeTo(Description description); @Factory static Matcher<WebDriver> hasCookie(String name); }### Answer:
@Test public void shouldFindExistingCookie() { WebDriver driver = mock(WebDriver.class); Options options = mock(Options.class); Cookie cookie = new Cookie(cookieName, "oki-doki"); when(driver.manage()).thenReturn(options); when(options.getCookieNamed(eq(cookieName))).thenReturn(cookie); assertThat("Cookie not found!", driver, hasCookie(cookieName)); }
@Test public void shouldNotFindUnexistingCookie() { final WebDriver driver = mock(WebDriver.class); Options options = mock(Options.class); when(driver.manage()).thenReturn(options); when(options.getCookieNamed(eq(cookieName))).thenReturn(null); assertThat("Cook should not be found", driver, not(hasCookie(cookieName))); } |
### Question:
Telemetry { public synchronized static Telemetry getInstance() { if (sTelemetryInstance == null) { new Builder().build(); } return sTelemetryInstance; } private Telemetry(final Builder builder); synchronized static Telemetry getInstance(); void addObserver(@SuppressWarnings(WarningType.rawtype_warning) final ITelemetryObserver observer); void removeObserver(final Class<?> cls); void removeObserver(@SuppressWarnings(WarningType.rawtype_warning) final ITelemetryObserver observer); @SuppressWarnings({WarningType.rawtype_warning, WarningType.unchecked_warning}) List<ITelemetryObserver> getObservers(); static void emit(final BaseEvent event); void flush(); void flush(@NonNull final String correlationId); }### Answer:
@Test public void testTelemetryInstanceCreationSuccess() { Telemetry telemetry = Telemetry.getInstance(); Assert.assertNotNull(telemetry); } |
### Question:
ConfigurationLoader { public Map<String, Object> loadConfiguration(File file) throws IOException { Map<String, Object> config = new HashMap<>(defaultConfig); Map<String, Object> tmpConfig; try (InputStream input = new FileInputStream(file)) { Yaml yaml = new Yaml(); tmpConfig = yaml.load(input); if (tmpConfig == null) { return config; } for (Map.Entry element : tmpConfig.entrySet()) { String key = (String) element.getKey(); if (!variableNames.contains(key)) { throw new InvalidVariableException("unknown variable: " + key); } else { config.put(key, element.getValue()); } } } return config; } ConfigurationLoader(List<Variable> variables); Map<String, Object> loadConfiguration(File file); }### Answer:
@Test public void load() throws Exception { List<Variable> list = new ArrayList<>(); list.add(new Variable("probe")); list.add(new Variable("mode")); list.add(new Variable("should-have-default", "should have default value", "default")); ConfigurationLoader config = new ConfigurationLoader(list); Map<String, Object> result; try { result = config.loadConfiguration(testYML); } catch (IOException e) { throw new RuntimeException(e); } assertEquals(createTestingProbeList(), result.get("probe")); assertTrue(result.get("probe") instanceof ArrayList); assertEquals("continual", result.get("mode")); assertFalse(result.get("mode") instanceof ArrayList); assertTrue(result.get("mode") instanceof String); assertEquals("default", result.get("should-have-default")); assertFalse(result.get("should-have-default") instanceof ArrayList); assertTrue(result.get("should-have-default") instanceof String); }
@Test(expected = InvalidVariableException.class) public void invalidVariable() throws Exception { List<Variable> variables = Collections.singletonList(new Variable("allowed")); (new ConfigurationLoader(variables)).loadConfiguration(testYML); } |
### Question:
FileTemplateSetLoader extends TemplateSetLoader { @Override public TemplateSet load() throws IOException { Metadata metadata = loadMetadata(); Map<String, Template> templates = new HashMap<>(); for (String file : metadata.getTemplates()) { templates.put(file, loadTemplate(file)); } try { templates.put(FILE_MAPPING_TEMPLATE_FILENAME, loadTemplate(FILE_MAPPING_TEMPLATE_FILENAME)); } catch (IOException ignored) { } return new TemplateSet(templates, metadata.getVariables()); } FileTemplateSetLoader(File root); @Override TemplateSet load(); File getRoot(); }### Answer:
@Test public void load() throws Exception { TemplateSetLoader loader = new FileTemplateSetLoader(tempPath.toFile()); TemplateSet templateSet = loader.load(); assertEquals(1, templateSet.getVariables().size()); assertEquals("name", templateSet.getVariables().get(0).getName()); } |
### Question:
ApplicationCore { public void startup(String filename) throws Exception { sysConfig = new SystemConfiguration(filename); try { startBackground(); } catch (Exception e) { throw e; } registerWidgets(); } protected ApplicationCore(); static ApplicationCore getInstance(); void startup(String filename); void attach(); void detach(); String getWriteSession(); ArrayList<String> getSessionList(); boolean isAttached(); static void registerWidgets(); IRuntimeAggregator<?> getRuntimeAggregator(); ISystemConfiguration getSystemConfiguration(); ArrayList<String> getViewConfigurations(); ViewConfiguration getViewConfiguration(String name); String getLatestViewConfigurationName(); void saveViewConfiguration(ViewConfiguration config, String name); }### Answer:
@Test public void testStartup() throws Exception { assertEquals(instance.isAttached(), true); } |
### Question:
TypeScope extends Scope<NamedType> { public DataType type(String name) throws AmbiguousNameException { NamedType nt = find(name); if (nt == null) { return null; } return nt.type(); } TypeScope(); DataType type(String name); }### Answer:
@Test public void create_find_types() throws Exception { TypeScope ts = new TypeScope(); PrimitiveScope ps = new PrimitiveScope(); ts.add(new NamedType("a", ps.int16())); ts.add(new NamedType("d", ps.int32())); assertEquals(ps.int16(), ts.type("a")); assertEquals(ps.int32(), ts.type("d")); assertNull(ts.type("e")); } |
### Question:
ValueScope extends Scope<NamedValue> { public DataValue value(String name) throws AmbiguousNameException { Ensure.not_null(name, "name == null"); NamedValue nv = find(name); if (nv == null) { return null; } return nv.value(); } ValueScope(TypeScope types); TypeScope typed_scope(); DataType type(String name); DataValue value(String name); }### Answer:
@Test public void create_assign_obtain_values() throws Exception { m_vs.add(new NamedValue("a", m_ps.ascii().make("bar"))); DataValue vl = m_vs.value("a"); assertTrue(vl instanceof AsciiValue); AsciiValue sv = (AsciiValue) vl; assertEquals("bar", sv.value()); }
@Test public void obtain_non_existing_value() throws Exception { assertNull(m_vs.value("h")); } |
### Question:
ValueScope extends Scope<NamedValue> { public TypeScope typed_scope() { return m_types; } ValueScope(TypeScope types); TypeScope typed_scope(); DataType type(String name); DataValue value(String name); }### Answer:
@Test public void obtain_typed_scope() throws Exception { assertEquals(m_ts, m_vs.typed_scope()); } |
### Question:
ListDataType extends CollectionDataType { @Override public boolean is_abstract() { return false; } ListDataType(DataType inner_type, AnyType any); static final String build_list_name(DataType inner); static ListDataType list_of(DataType inner, PrimitiveScope pscope); @Override ListDataValue make(); @Override boolean is_abstract(); }### Answer:
@Test public void create_list_type_check_properties() throws Exception { assertEquals("list<b>", m_list_type.name()); assertTrue(m_list_type.sub_of(m_scope.any())); assertFalse(m_list_type.is_abstract()); assertEquals(m_type, m_list_type.inner_type()); } |
### Question:
ApplicationCore { public void attach() { if (!attached) { try { runtimeAgg.start(); attached = true; if (CREATE_MOCK_RAINBOW) { mockRainbow.run(); } } catch (RuntimeAggregatorException ex) { Logger.getLogger(ApplicationCore.class.getName()).log(Level.SEVERE, "Cannot attach to the Rainbow system.", ex); } } } protected ApplicationCore(); static ApplicationCore getInstance(); void startup(String filename); void attach(); void detach(); String getWriteSession(); ArrayList<String> getSessionList(); boolean isAttached(); static void registerWidgets(); IRuntimeAggregator<?> getRuntimeAggregator(); ISystemConfiguration getSystemConfiguration(); ArrayList<String> getViewConfigurations(); ViewConfiguration getViewConfiguration(String name); String getLatestViewConfigurationName(); void saveViewConfiguration(ViewConfiguration config, String name); }### Answer:
@Test public void testAttach() { instance.attach(); assertEquals(instance.isAttached(), true); } |
### Question:
ListDataType extends CollectionDataType { public static ListDataType list_of(DataType inner, PrimitiveScope pscope) { Ensure.not_null(inner); Ensure.not_null(pscope); Ensure.is_true(inner.in_scope(pscope)); DataTypeScope scope = inner.parent_dts(); DataType found = null; try { found = scope.find(build_list_name(inner)); } catch (AmbiguousNameException e) { } if (found == null) { found = new ListDataType(inner, pscope.any()); scope.add(found); } Ensure.not_null(found); Ensure.is_instance(found, ListDataType.class); return (ListDataType) found; } ListDataType(DataType inner_type, AnyType any); static final String build_list_name(DataType inner); static ListDataType list_of(DataType inner, PrimitiveScope pscope); @Override ListDataValue make(); @Override boolean is_abstract(); }### Answer:
@Test public void obtaining_existing_data_type() throws Exception { ListDataType t = ListDataType.list_of(m_type, m_scope); assertSame(m_list_type, t); }
@Test public void obtaining_new_data_type() throws Exception { ListDataType t1 = ListDataType.list_of(m_scope.int8(), m_scope); assertSame(t1, ListDataType.list_of(m_scope.int8(), m_scope)); } |
### Question:
BagDataType extends CollectionDataType { @Override public boolean is_abstract() { return false; } BagDataType(DataType inner_type, AnyType any); static final String build_bag_name(DataType inner); static BagDataType bag_of(DataType inner, PrimitiveScope pscope); @Override BagDataValue make(); @Override boolean is_abstract(); }### Answer:
@Test public void create_bag_type_check_properties() throws Exception { assertEquals("bag<b>", m_bag_type.name()); assertTrue(m_bag_type.sub_of(m_scope.any())); assertFalse(m_bag_type.is_abstract()); assertEquals(m_type, m_bag_type.inner_type()); } |
### Question:
BagDataType extends CollectionDataType { public static BagDataType bag_of(DataType inner, PrimitiveScope pscope) { Ensure.not_null(inner); Ensure.not_null(pscope); Ensure.is_true(inner.in_scope(pscope)); DataTypeScope scope = inner.parent_dts(); DataType found = null; try { found = scope.find(build_bag_name(inner)); } catch (AmbiguousNameException e) { } if (found == null) { found = new BagDataType(inner, pscope.any()); scope.add(found); } Ensure.not_null(found); Ensure.is_instance(found, BagDataType.class); return (BagDataType) found; } BagDataType(DataType inner_type, AnyType any); static final String build_bag_name(DataType inner); static BagDataType bag_of(DataType inner, PrimitiveScope pscope); @Override BagDataValue make(); @Override boolean is_abstract(); }### Answer:
@Test public void obtaining_existing_data_type() throws Exception { BagDataType t = BagDataType.bag_of(m_type, m_scope); assertSame(m_bag_type, t); }
@Test public void obtaining_new_data_type() throws Exception { BagDataType t1 = BagDataType.bag_of(m_scope.int8(), m_scope); assertSame(t1, BagDataType.bag_of(m_scope.int8(), m_scope)); } |
### Question:
ApplicationCore { public void detach() { if (attached) { runtimeAgg.stop(); attached = false; if (CREATE_MOCK_RAINBOW) { mockRainbow.cancel(); } } } protected ApplicationCore(); static ApplicationCore getInstance(); void startup(String filename); void attach(); void detach(); String getWriteSession(); ArrayList<String> getSessionList(); boolean isAttached(); static void registerWidgets(); IRuntimeAggregator<?> getRuntimeAggregator(); ISystemConfiguration getSystemConfiguration(); ArrayList<String> getViewConfigurations(); ViewConfiguration getViewConfiguration(String name); String getLatestViewConfigurationName(); void saveViewConfiguration(ViewConfiguration config, String name); }### Answer:
@Test public void testDetach() { instance.detach(); assertEquals(instance.isAttached(), false); } |
### Question:
SetDataType extends CollectionDataType { @Override public boolean is_abstract() { return false; } SetDataType(DataType inner_type, AnyType any); static final String build_set_name(DataType inner); static SetDataType set_of(DataType inner, PrimitiveScope pscope); @Override SetDataValue make(); @Override boolean is_abstract(); }### Answer:
@Test public void create_set_type_check_properties() throws Exception { assertEquals("set<b>", m_set_type.name()); assertTrue(m_set_type.sub_of(m_scope.any())); assertFalse(m_set_type.is_abstract()); assertEquals(m_type, m_set_type.inner_type()); } |
### Question:
SetDataType extends CollectionDataType { public static SetDataType set_of(DataType inner, PrimitiveScope pscope) { Ensure.not_null(inner); Ensure.not_null(pscope); Ensure.is_true(inner.in_scope(pscope)); DataTypeScope scope = inner.parent_dts(); DataType found = null; try { found = scope.find(build_set_name(inner)); } catch (AmbiguousNameException e) { } if (found == null) { found = new SetDataType(inner, pscope.any()); scope.add(found); } Ensure.not_null(found); Ensure.is_instance(found, SetDataType.class); return (SetDataType) found; } SetDataType(DataType inner_type, AnyType any); static final String build_set_name(DataType inner); static SetDataType set_of(DataType inner, PrimitiveScope pscope); @Override SetDataValue make(); @Override boolean is_abstract(); }### Answer:
@Test public void obtaining_existing_data_type() throws Exception { SetDataType t = SetDataType.set_of(m_type, m_scope); assertSame(m_set_type, t); }
@Test public void obtaining_new_data_type() throws Exception { SetDataType t1 = SetDataType.set_of(m_scope.int8(), m_scope); assertSame(t1, SetDataType.set_of(m_scope.int8(), m_scope)); } |
### Question:
HierarchicalName { public HierarchicalName make_absolute() { Ensure.is_false(m_is_absolute); return new HierarchicalName(true, m_names); } HierarchicalName(boolean absolute, List<String> names); HierarchicalName(boolean absolute, String... names); boolean absolute(); String peek(); HierarchicalName pop_first(); boolean leaf(); HierarchicalName push(String name); HierarchicalName make_absolute(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test(expected = AssertionError.class) public void making_absolute_absolute() throws Exception { HierarchicalName hn = new HierarchicalName(true, "foo"); hn.make_absolute(); } |
### Question:
HierarchicalName { @Override public String toString() { StringBuilder sb = new StringBuilder(); if (m_is_absolute) { sb.append("::"); } for (int i = 0; i < m_names.size(); i++) { if (i > 0) { sb.append("::"); } sb.append(m_names.get(i)); } return sb.toString(); } HierarchicalName(boolean absolute, List<String> names); HierarchicalName(boolean absolute, String... names); boolean absolute(); String peek(); HierarchicalName pop_first(); boolean leaf(); HierarchicalName push(String name); HierarchicalName make_absolute(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void hierarchical_name_as_string() throws Exception { HierarchicalName hn1 = new HierarchicalName(true, "a"); assertEquals("::a", hn1.toString()); HierarchicalName hn2 = new HierarchicalName(true, "a", "b"); assertEquals("::a::b", hn2.toString()); HierarchicalName hn3 = new HierarchicalName(false, "a"); assertEquals("a", hn3.toString()); HierarchicalName hn4 = new HierarchicalName(false, "a", "b"); assertEquals("a::b", hn4.toString()); } |
### Question:
HierarchicalName { @Override public boolean equals(Object obj) { if (obj == null || !(obj instanceof HierarchicalName)) { return false; } HierarchicalName hn = (HierarchicalName) obj; return hn.m_is_absolute == m_is_absolute && hn.m_names.equals(m_names); } HierarchicalName(boolean absolute, List<String> names); HierarchicalName(boolean absolute, String... names); boolean absolute(); String peek(); HierarchicalName pop_first(); boolean leaf(); HierarchicalName push(String name); HierarchicalName make_absolute(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void compare_to_invalid() throws Exception { HierarchicalName hn = new HierarchicalName(false, "foo"); assertFalse(hn.equals((Object) null)); assertFalse(hn.equals(23)); } |
### Question:
ApplicationCore { public ArrayList<String> getSessionList() { return databaseCon.getSessionList(); } protected ApplicationCore(); static ApplicationCore getInstance(); void startup(String filename); void attach(); void detach(); String getWriteSession(); ArrayList<String> getSessionList(); boolean isAttached(); static void registerWidgets(); IRuntimeAggregator<?> getRuntimeAggregator(); ISystemConfiguration getSystemConfiguration(); ArrayList<String> getViewConfigurations(); ViewConfiguration getViewConfiguration(String name); String getLatestViewConfigurationName(); void saveViewConfiguration(ViewConfiguration config, String name); }### Answer:
@Test public void testGetSessionList() { ArrayList<String> result = instance.getSessionList(); assertNotNull(result); } |
### Question:
Scope { public synchronized T find(String name) throws AmbiguousNameException { return find(new HierarchicalName(false, name)); } Scope(String name); final String name(); final Scope<T> parent(); final HierarchicalName absolute_hname(); synchronized final void add(Scope<T> scope); synchronized final void add(T obj); synchronized T find(String name); synchronized Scope<T> find_scope(String name); synchronized T find(HierarchicalName hn); synchronized Scope<T> find_scope(HierarchicalName hn); synchronized Set<T> all(); synchronized final void link(Scope<T> scope); synchronized Set<T> all_recursive(); synchronized boolean child_scope_of(Scope<?> scope); static Scope<?> common_inner_most_parent_scope(
Set<? extends Scope<?>> scopes); }### Answer:
@Test(expected = AssertionError.class) public void finding_object_with_null_string() throws Exception { TestScope s = new TestScope(); s.find((String) null); }
@Test(expected = AssertionError.class) public void finding_object_with_null_hierarchical_name() throws Exception { TestScope s = new TestScope(); s.find((HierarchicalName) null); } |
### Question:
Scope { public synchronized Scope<T> find_scope(String name) throws AmbiguousNameException { return find_scope(new HierarchicalName(false, name)); } Scope(String name); final String name(); final Scope<T> parent(); final HierarchicalName absolute_hname(); synchronized final void add(Scope<T> scope); synchronized final void add(T obj); synchronized T find(String name); synchronized Scope<T> find_scope(String name); synchronized T find(HierarchicalName hn); synchronized Scope<T> find_scope(HierarchicalName hn); synchronized Set<T> all(); synchronized final void link(Scope<T> scope); synchronized Set<T> all_recursive(); synchronized boolean child_scope_of(Scope<?> scope); static Scope<?> common_inner_most_parent_scope(
Set<? extends Scope<?>> scopes); }### Answer:
@Test(expected = AssertionError.class) public void finding_scope_with_null_string() throws Exception { TestScope s = new TestScope(); s.find_scope((String) null); }
@Test(expected = AssertionError.class) public void finding_scope_with_null_hierarchical_name() throws Exception { TestScope s = new TestScope(); s.find_scope((HierarchicalName) null); } |
### Question:
ApplicationCore { public boolean isAttached() { return attached; } protected ApplicationCore(); static ApplicationCore getInstance(); void startup(String filename); void attach(); void detach(); String getWriteSession(); ArrayList<String> getSessionList(); boolean isAttached(); static void registerWidgets(); IRuntimeAggregator<?> getRuntimeAggregator(); ISystemConfiguration getSystemConfiguration(); ArrayList<String> getViewConfigurations(); ViewConfiguration getViewConfiguration(String name); String getLatestViewConfigurationName(); void saveViewConfiguration(ViewConfiguration config, String name); }### Answer:
@Test public void testIsAttached() { boolean expResult = true; instance.attach(); boolean result = instance.isAttached(); assertEquals(expResult, result); } |
### Question:
Scope { public synchronized boolean child_scope_of(Scope<?> scope) { Ensure.not_null(scope); for (Scope<?> p = m_parent; p != null; p = p.m_parent) { if (p == scope) { return true; } } return false; } Scope(String name); final String name(); final Scope<T> parent(); final HierarchicalName absolute_hname(); synchronized final void add(Scope<T> scope); synchronized final void add(T obj); synchronized T find(String name); synchronized Scope<T> find_scope(String name); synchronized T find(HierarchicalName hn); synchronized Scope<T> find_scope(HierarchicalName hn); synchronized Set<T> all(); synchronized final void link(Scope<T> scope); synchronized Set<T> all_recursive(); synchronized boolean child_scope_of(Scope<?> scope); static Scope<?> common_inner_most_parent_scope(
Set<? extends Scope<?>> scopes); }### Answer:
@Test public void self_child_check_test() throws Exception { TestScope s0 = new TestScope(); assertFalse(s0.child_scope_of(s0)); } |
### Question:
AcmeGraph extends AcmeModelView { @Override protected void subUpdate() { IAcmeSystem newSystem = (IAcmeSystem) ModelHelper .getElementFromQualifiedName(model, currentSystem.getQualifiedName()); if (newSystem != null) { currentSystem = newSystem; } else { currentSystem = model; Logger.getLogger(AcmeGraph.class.getName()).log(Level.INFO, "The system {0} doesn''t exists. " + "Switch to top-level system.", currentSystem.getQualifiedName()); } Graph graph = createGraph(); graphLayer.setGraph(graph); } AcmeGraph(AbstractRainbowVaadinUI ui); IAcmeSystem getCurrentSystem(); void setCurrentSystem(IAcmeSystem system); void resetGraph(); }### Answer:
@Test public void testSubUpdate() throws Exception { System.out.println("subUpdate"); AcmeGraph instance = new AcmeGraph(dummyUI); instance.update(); Graph graph = instance.getGraphLayer().getGraph(); Node server0 = graph.nodes.get("ZNewsSys.Server0"); assertNotNull(server0); Node server1 = graph.nodes.get("ZNewsSys.Server1"); assertNotNull(server1); String port = server0.ports.get(0); assertEquals("ZNewsSys.Server0.http0", port); Node connector = graph.nodes.get("ZNewsSys.httpConn_0_0"); assertNotNull(connector); Edge attachment = graph.edges.get("ZNewsSys.Client1.p0 to httpConn_0_0.req"); assertNotNull(attachment); } |
### Question:
WorkerThreadGroup implements WorkerThreadGroupCI { public synchronized void add_subgroup(WorkerThreadGroup wtg) { Ensure.not_null(wtg, "wtg == null"); Ensure.is_true(wtg != this, "wtg == this"); Ensure.is_false(m_subgroups.contains(wtg), "m_subgroups.contains(wtg)"); Ensure.is_false(wtg.all_subgroups().contains(this), "wtg.all_subgroups().contains(this)"); m_subgroups.add(wtg); } WorkerThreadGroup(String name); @Override synchronized String name(); @Override synchronized String description(); synchronized void description(String d); @Override synchronized Set<WorkerThreadCI> threads(); @Override synchronized void start(); @Override synchronized void stop(); synchronized void add_thread(WorkerThread wt); synchronized void remove_thread(WorkerThread wt); synchronized void add_subgroup(WorkerThreadGroup wtg); synchronized void remove_subgroup(WorkerThreadGroup wtg); @Override synchronized Set<WorkerThreadGroupCI> direct_subgroups(); @Override Set<WorkerThreadGroupCI> all_subgroups(); @Override void start_all(); @Override void stop_all(); }### Answer:
@Test public void building_cyclic_thread_group_hierarchies() throws Exception { WorkerThreadGroup wtg1 = new WorkerThreadGroup("g1"); WorkerThreadGroup wtg2 = new WorkerThreadGroup("g2"); WorkerThreadGroup wtg3 = new WorkerThreadGroup("g3"); wtg1.add_subgroup(wtg2); wtg2.add_subgroup(wtg3); boolean fail = false; try { wtg3.add_subgroup(wtg1); fail = true; } catch (AssertionError e) { } if (fail) { fail(); } } |
### Question:
WorkerThread implements WorkerThreadCI { @Override public final synchronized void stop() { Ensure.is_true(m_state == WtState.RUNNING, "w_state != WtState.RUNNING"); if (Thread.currentThread() == m_thread) { throw new ClosingWorkerThreadFromWithinException(); } m_state = WtState.STOPPING; fire_state_changed(); Thread t = m_thread; while (t.isAlive()) { try { interrupt_wait(); wait(THREAD_STATE_POLL_TIME_MS); } catch (InterruptedException e) { } } if (m_thread != null) { m_state = WtState.STOPPED; fire_state_changed(); m_thread = null; } else { assert m_state == WtState.ABORTED; } } WorkerThread(String name); void add_listener(WorkerThreadListener l); void remove_listener(WorkerThreadListener l); @Override String name(); @Override synchronized String description(); @Override synchronized ThrowableCollector collector(); @Override final synchronized WtState state(); @Override final synchronized void start(); @Override final synchronized void stop(); }### Answer:
@Test(expected = AssertionError.class) public void stop_thread_before_starting() throws Exception { WorkerThread wt = new WorkerThread("x"); wt.stop(); } |
### Question:
WorkerThread implements WorkerThreadCI { @Override public String name() { return m_name; } WorkerThread(String name); void add_listener(WorkerThreadListener l); void remove_listener(WorkerThreadListener l); @Override String name(); @Override synchronized String description(); @Override synchronized ThrowableCollector collector(); @Override final synchronized WtState state(); @Override final synchronized void start(); @Override final synchronized void stop(); }### Answer:
@Test public void enumeration_checks() { WtState[] states = WtState.values(); for (WtState s : states) { WtState.valueOf(s.name()); } } |
### Question:
AcmeGraph extends AcmeModelView { public IAcmeSystem getCurrentSystem() { return currentSystem; } AcmeGraph(AbstractRainbowVaadinUI ui); IAcmeSystem getCurrentSystem(); void setCurrentSystem(IAcmeSystem system); void resetGraph(); }### Answer:
@Test public void testRootComponent() throws Exception { System.out.println("get/set RootComponent"); AcmeGraph instance = new AcmeGraph(dummyUI); String expResult = "ZNewsSys"; IAcmeSystem result = instance.getCurrentSystem(); assertNotNull(result); assertEquals(expResult, result.getName()); } |
### Question:
CloseableWorkerThread extends WorkerThread implements Closeable { @Override public synchronized void close() throws IOException { if (m_closeable == null) { return; } T t = m_closeable; m_closeable = null; if (state() == WtState.RUNNING) { thread().interrupt(); } try { t.close(); } finally { m_dispatcher.dispatch(new DispatcherOp<CloseableListener>() { @Override public void dispatch(CloseableListener l) { l.closed(null); } }); } } CloseableWorkerThread(String name, T closeable,
boolean close_on_abort); synchronized void add_listener(CloseableListener l); synchronized void remove_listener(CloseableListener l); @Override synchronized void close(); synchronized boolean closed(); }### Answer:
@SuppressWarnings("javadoc") @Test public void starting_after_closed() throws Exception { try ( PipedInputStream pis = new PipedInputStream(15); PipedOutputStream pos = new PipedOutputStream(pis); CloseableWorkerThread<PipedInputStream> cwt = new CloseableWorkerThread<PipedInputStream>("y", pis, false) { @Override protected void do_cycle_operation( PipedInputStream closeable) throws Exception { if (closeable.read() == -1) { throw new EOFException(); } } }) { cwt.start(); assertEquals(WtState.RUNNING, cwt.state()); Thread.sleep(250); assertEquals(WtState.RUNNING, cwt.state()); cwt.close(); Thread.sleep(250); assertEquals(WtState.ABORTED, cwt.state()); cwt.start(); assertEquals(WtState.RUNNING, cwt.state()); Thread.sleep(250); assertEquals(WtState.RUNNING, cwt.state()); cwt.stop(); assertEquals(WtState.STOPPED, cwt.state()); } } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.