method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
CategoryServiceImpl implements CategoryService { @Override public void deleteCategoryById(Long id) { categoryRepository.delete(id); } @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 deleteCategoryById() throws Exception { categoryService.deleteCategoryById(100L); } |
### Question:
CategoryServiceImpl implements CategoryService { @Override public void updateCategory(Category category) { categoryRepository.save(category); } @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 updateCategory() throws Exception { Category category = categoryService.findCategoryById(2L); category.setName("修改你的名称"); categoryService.updateCategory(category); } |
### Question:
CategoryServiceImpl implements CategoryService { @Override public Iterable<Category> findAll() { return categoryRepository.findAll(); } @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 findAll() throws Exception { Iterable<Category> all = categoryService.findAll(); for (Category category : all) { System.err.println(category.toString()); } } |
### Question:
CategoryServiceImpl implements CategoryService { @Override public Category findCategoryById(Long id) { return categoryRepository.findOne(id); } @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 findCategoryById() throws Exception { Category category = categoryService.findCategoryById(99L); System.err.println(category.toString()); } |
### 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:
FF4jConfiguration extends AbstractConfiguration { @Override public Iterator<String> getKeys(String prefix) { Set< String > setOfNames = ff4jStore().listPropertyNames(); Set< String > results = new HashSet<String>(); if (setOfNames != null && setOfNames.size() > 0) { for (String name : setOfNames) { if (name.startsWith(prefix)) { results.add(name); } } } return results.iterator(); } FF4jConfiguration(); FF4jConfiguration(PropertyStore ff4jPropertyStore); @Override Configuration subset(String prefix); @Override Properties getProperties(String key); @Override boolean isEmpty(); @Override boolean containsKey(String key); @Override void addProperty(String key, Object value); @SuppressWarnings("unchecked") @Override void setProperty(String key, Object value); @Override void clearProperty(String key); @Override void clear(); @Override Object getProperty(String key); @Override Iterator<String> getKeys(String prefix); @Override Iterator<String> getKeys(); @Override boolean getBoolean(String key); @Override Boolean getBoolean(String key, Boolean defaultValue); @Override boolean getBoolean(String key, boolean defaultValue); @Override byte getByte(String key); @Override byte getByte(String key, byte defaultValue); @Override Byte getByte(String key, Byte defaultValue); @Override double getDouble(String key); @Override double getDouble(String key, double defaultValue); @Override Double getDouble(String key, Double defaultValue); @Override float getFloat(String key); @Override float getFloat(String key, float defaultValue); @Override Float getFloat(String key, Float defaultValue); @Override int getInt(String key); @Override int getInt(String key, int defaultValue); @Override Integer getInteger(String key, Integer defaultValue); @Override long getLong(String key); @Override Long getLong(String key, Long defaultValue); @Override long getLong(String key, long defaultValue); @Override short getShort(String key); @Override short getShort(String key, short defaultValue); @Override Short getShort(String key, Short defaultValue); @Override BigDecimal getBigDecimal(String key); @Override BigDecimal getBigDecimal(String key, BigDecimal defaultValue); @Override BigInteger getBigInteger(String key); @Override BigInteger getBigInteger(String key, BigInteger defaultValue); @Override String getString(String key); @Override String getString(String key, String defaultValue); @Override List<Object> getList(String key); @Override List<Object> getList(String key, List<?> defaultValue); @Override String[] getStringArray(String key); PropertyStore ff4jStore(); PropertyStore getFf4jStore(); void setFf4jStore(PropertyStore ff4jStore); }### Answer:
@Test public void testgetKeysNull() { InMemoryPropertyStore tmpStore = new InMemoryPropertyStore(); Configuration tmpConf = new FF4jConfiguration(tmpStore); Iterator<String> propsKeys = tmpConf.getKeys("z"); Assert.assertFalse(propsKeys.hasNext()); tmpStore.setProperties(null); Assert.assertFalse(tmpConf.getKeys().hasNext()); Assert.assertFalse(tmpConf.getKeys("z").hasNext()); }
@Test public void testgetKeys() { Assert.assertTrue(ff4jConf.containsKey("propInt")); Assert.assertTrue(ff4jConf.containsKey("propString")); Assert.assertTrue(ff4jConf.getKeys().hasNext()); Iterator<String> propsKeys = ff4jConf.getKeys("prop"); Assert.assertTrue(propsKeys.hasNext()); } |
### Question:
FF4jConfiguration extends AbstractConfiguration { public PropertyStore ff4jStore() { if (ff4jStore == null) { throw new IllegalStateException("Cannot load property from store as not initialized please set 'ff4jStore' property"); } return getFf4jStore(); } FF4jConfiguration(); FF4jConfiguration(PropertyStore ff4jPropertyStore); @Override Configuration subset(String prefix); @Override Properties getProperties(String key); @Override boolean isEmpty(); @Override boolean containsKey(String key); @Override void addProperty(String key, Object value); @SuppressWarnings("unchecked") @Override void setProperty(String key, Object value); @Override void clearProperty(String key); @Override void clear(); @Override Object getProperty(String key); @Override Iterator<String> getKeys(String prefix); @Override Iterator<String> getKeys(); @Override boolean getBoolean(String key); @Override Boolean getBoolean(String key, Boolean defaultValue); @Override boolean getBoolean(String key, boolean defaultValue); @Override byte getByte(String key); @Override byte getByte(String key, byte defaultValue); @Override Byte getByte(String key, Byte defaultValue); @Override double getDouble(String key); @Override double getDouble(String key, double defaultValue); @Override Double getDouble(String key, Double defaultValue); @Override float getFloat(String key); @Override float getFloat(String key, float defaultValue); @Override Float getFloat(String key, Float defaultValue); @Override int getInt(String key); @Override int getInt(String key, int defaultValue); @Override Integer getInteger(String key, Integer defaultValue); @Override long getLong(String key); @Override Long getLong(String key, Long defaultValue); @Override long getLong(String key, long defaultValue); @Override short getShort(String key); @Override short getShort(String key, short defaultValue); @Override Short getShort(String key, Short defaultValue); @Override BigDecimal getBigDecimal(String key); @Override BigDecimal getBigDecimal(String key, BigDecimal defaultValue); @Override BigInteger getBigInteger(String key); @Override BigInteger getBigInteger(String key, BigInteger defaultValue); @Override String getString(String key); @Override String getString(String key, String defaultValue); @Override List<Object> getList(String key); @Override List<Object> getList(String key, List<?> defaultValue); @Override String[] getStringArray(String key); PropertyStore ff4jStore(); PropertyStore getFf4jStore(); void setFf4jStore(PropertyStore ff4jStore); }### Answer:
@Test(expected = IllegalStateException.class) public void testNullStore() { new FF4jConfiguration().ff4jStore(); } |
### 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:
YamlParser implements FF4jConfigurationParser<FF4jConfiguration> { @Override @SuppressWarnings("unchecked") public FF4jConfiguration parseConfigurationFile(InputStream inputStream) { Util.assertNotNull(inputStream, "Cannot read file stream is empty, check readability and path."); Map<?,?> yamlConfigFile = safeYaml.load(inputStream); Map<?,?> ff4jYamlMap = (Map<?, ?>) yamlConfigFile.get(FF4J_TAG); FF4jConfiguration ff4jConfig = new FF4jConfiguration(); if (ff4jYamlMap != null) { if (ff4jYamlMap.containsKey(GLOBAL_AUDIT_TAG)) { ff4jConfig.setAudit(Boolean.valueOf(ff4jYamlMap.get(GLOBAL_AUDIT_TAG).toString())); } if (ff4jYamlMap.containsKey(GLOBAL_AUTOCREATE)) { ff4jConfig.setAutoCreate(Boolean.valueOf(ff4jYamlMap.get(GLOBAL_AUTOCREATE).toString())); } ff4jConfig.getProperties() .putAll(parseProperties((List<Map<String, Object>>) ff4jYamlMap.get(PROPERTIES_TAG)) ); parseFeatures(ff4jConfig, (List<Map<String, Object>>) ff4jYamlMap.get(FEATURES_TAG)); } return ff4jConfig; } YamlParser(); @Override InputStream export(FF4jConfiguration ff4jConfig); @Override @SuppressWarnings("unchecked") FF4jConfiguration parseConfigurationFile(InputStream inputStream); }### Answer:
@Test(expected = IllegalArgumentException.class) public void yamlFile_shouldExist() { new YamlParser().parseConfigurationFile(null); }
@Test public void importYaml_should_be_same_asXMLImport() { InputStream xmlFile = getClass().getClassLoader().getResourceAsStream("test-ff4j-features.xml"); InputStream ymlFile = getClass().getClassLoader().getResourceAsStream("test-ff4j-features.yml"); XmlConfig xmlConfig = new XmlParser().parseConfigurationFile(xmlFile); FF4jConfiguration ymlConfig = new YamlParser().parseConfigurationFile(ymlFile); assertEquals(xmlConfig.getFeatures().size(), ymlConfig.getFeatures().size()); assertEquals(xmlConfig.getProperties().size(), ymlConfig.getProperties().size()); Feature f1Xml = xmlConfig.getFeatures().get("first"); Feature f1Yml = ymlConfig.getFeatures().get("first"); assertEquals(f1Xml.getDescription(), f1Yml.getDescription()); assertEquals(f1Xml.getCustomProperties().size(), f1Yml.getCustomProperties().size()); Feature f3Xml = xmlConfig.getFeatures().get("third"); Feature f3Yml = ymlConfig.getFeatures().get("third"); assertEquals( f3Xml.getFlippingStrategy().getClass(), f3Yml.getFlippingStrategy().getClass()); assertEquals( f3Xml.getFlippingStrategy().getInitParams().get("expression"), f3Yml.getFlippingStrategy().getInitParams().get("expression")); assertEquals( f3Xml.getPermissions(), f3Yml.getPermissions()); } |
### Question:
PropertyJsonParser { @SuppressWarnings("unchecked") public static Property<?> parseProperty(String json) { if (null == json || "".equals(json)) { return null; } Map<String, Object> propertyJson; try { propertyJson = objectMapper.readValue(json, HashMap.class); } catch (Exception re) { throw new IllegalArgumentException("Cannot parse JSON Property", re); } String propertyName = String.valueOf(propertyJson.get("name")); String propertyVal = String.valueOf(propertyJson.get("value")); String propertyType = String.valueOf(propertyJson.get("type")); Property < ?> ap = PropertyFactory.createProperty(propertyName, propertyType, propertyVal); List <Object> listOfFixedValue = (List<Object>) propertyJson.get(FIXED_VALUES); if (listOfFixedValue != null) { for (Object v : listOfFixedValue) { ap.add2FixedValueFromString(String.valueOf(v)); } if (ap.getFixedValues() != null && !ap.getFixedValues().contains(ap.getValue())) { throw new IllegalArgumentException("Cannot create property <" + ap.getName() + "> invalid value <" + ap.getValue() + "> expected one of " + ap.getFixedValues()); } } return ap; } private PropertyJsonParser(); @SuppressWarnings("unchecked") static Property<?> parseProperty(String json); @SuppressWarnings("unchecked") static Property<?>[] parsePropertyArray(String json); @SuppressWarnings("unchecked") static Property<?> parsePropertyMap(Map<String, Object> fMap); static final String FIXED_VALUES; }### Answer:
@Test public void testParsePropertyEmpty() { Assert.assertNull(PropertyJsonParser.parseProperty("")); Assert.assertNull(PropertyJsonParser.parseProperty(null)); }
@Test(expected = IllegalArgumentException.class) public void testParsePropertyError() { Assert.assertNull(PropertyJsonParser.parseProperty("something:invalid")); }
@Test public void testFull() { String pExp = "{\"name\":\"p1\",\"description\":null,\"type\":\"org.ff4j.property.PropertyString\",\"value\":\"v1\",\"fixedValues\":null}"; Property<?> p = PropertyJsonParser.parseProperty(pExp); Assert.assertNotNull(p); Assert.assertNotNull(p.getType()); Assert.assertEquals("v1", p.getValue()); } |
### 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:
PropertiesParser implements FF4jConfigurationParser<FF4jConfiguration> { @Override public FF4jConfiguration parseConfigurationFile(InputStream inputStream) { Util.assertNotNull(inputStream, "Cannot read file stream is empty, check readability and path."); try { Properties props = new Properties(); props.load(inputStream); return parseConfiguration(props); } catch (IOException e) { throw new IllegalArgumentException("Cannot read property files"); } } PropertiesParser(); @Override InputStream export(FF4jConfiguration ff4jConfig); FF4jConfiguration parseSystemConfiguration(); @Override FF4jConfiguration parseConfigurationFile(InputStream inputStream); FF4jConfiguration parseConfiguration(Properties props); FF4jConfiguration parseConfiguration(Map<String, String> mapProperties); }### Answer:
@Test(expected = IllegalArgumentException.class) public void propertiesFile_shouldExist() { new PropertiesParser().parseConfigurationFile(null); }
@Test public void importProperties_should_be_same_asXMLImport() { InputStream xmlFile = getClass().getClassLoader().getResourceAsStream("test-ff4j-features.xml"); InputStream ymlFile = getClass().getClassLoader().getResourceAsStream("test-ff4j-features.properties"); XmlConfig xmlConfig = new XmlParser().parseConfigurationFile(xmlFile); FF4jConfiguration propsConfig = new PropertiesParser().parseConfigurationFile(ymlFile); assertEquals(xmlConfig.getFeatures().size(), propsConfig.getFeatures().size()); assertEquals(xmlConfig.getProperties().size(), propsConfig.getProperties().size()); Feature f1Xml = xmlConfig.getFeatures().get("first"); Feature f1props = propsConfig.getFeatures().get("first"); assertEquals(f1Xml.getDescription(), f1props.getDescription()); assertEquals(f1Xml.getCustomProperties().size(), f1props.getCustomProperties().size()); Feature f3Xml = xmlConfig.getFeatures().get("third"); Feature f3Props = propsConfig.getFeatures().get("third"); assertEquals( f3Xml.getFlippingStrategy().getClass(), f3Props.getFlippingStrategy().getClass()); assertEquals( f3Xml.getFlippingStrategy().getInitParams().get("expression"), f3Props.getFlippingStrategy().getInitParams().get("expression")); assertEquals( f3Xml.getPermissions(), f3Props.getPermissions()); } |
### 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:
FF4jConfiguration extends AbstractConfiguration { @Override public Configuration subset(String prefix) { Map < String, Property<?>> myProps = ff4jStore().readAllProperties(); PropertyStore ps = new InMemoryPropertyStore(); for (Map.Entry< String, Property<?>> prop : myProps.entrySet()) { if (prop.getKey().startsWith(prefix)) { ps.createProperty(prop.getValue()); } } return new FF4jConfiguration(ps); } FF4jConfiguration(); FF4jConfiguration(PropertyStore ff4jPropertyStore); @Override Configuration subset(String prefix); @Override Properties getProperties(String key); @Override boolean isEmpty(); @Override boolean containsKey(String key); @Override void addProperty(String key, Object value); @SuppressWarnings("unchecked") @Override void setProperty(String key, Object value); @Override void clearProperty(String key); @Override void clear(); @Override Object getProperty(String key); @Override Iterator<String> getKeys(String prefix); @Override Iterator<String> getKeys(); @Override boolean getBoolean(String key); @Override Boolean getBoolean(String key, Boolean defaultValue); @Override boolean getBoolean(String key, boolean defaultValue); @Override byte getByte(String key); @Override byte getByte(String key, byte defaultValue); @Override Byte getByte(String key, Byte defaultValue); @Override double getDouble(String key); @Override double getDouble(String key, double defaultValue); @Override Double getDouble(String key, Double defaultValue); @Override float getFloat(String key); @Override float getFloat(String key, float defaultValue); @Override Float getFloat(String key, Float defaultValue); @Override int getInt(String key); @Override int getInt(String key, int defaultValue); @Override Integer getInteger(String key, Integer defaultValue); @Override long getLong(String key); @Override Long getLong(String key, Long defaultValue); @Override long getLong(String key, long defaultValue); @Override short getShort(String key); @Override short getShort(String key, short defaultValue); @Override Short getShort(String key, Short defaultValue); @Override BigDecimal getBigDecimal(String key); @Override BigDecimal getBigDecimal(String key, BigDecimal defaultValue); @Override BigInteger getBigInteger(String key); @Override BigInteger getBigInteger(String key, BigInteger defaultValue); @Override String getString(String key); @Override String getString(String key, String defaultValue); @Override List<Object> getList(String key); @Override List<Object> getList(String key, List<?> defaultValue); @Override String[] getStringArray(String key); PropertyStore ff4jStore(); PropertyStore getFf4jStore(); void setFf4jStore(PropertyStore ff4jStore); }### Answer:
@Test public void testSubSet() { Assert.assertTrue(ff4jConf.containsKey("name")); Configuration conf2 = ff4jConf.subset("prop"); Assert.assertTrue(conf2.containsKey("propInt")); Assert.assertFalse(conf2.containsKey("name")); } |
### Question:
FF4jConfiguration extends AbstractConfiguration { @Override public void addProperty(String key, Object value) { ff4jStore().createProperty(PropertyFactory.createProperty(key, value)); } FF4jConfiguration(); FF4jConfiguration(PropertyStore ff4jPropertyStore); @Override Configuration subset(String prefix); @Override Properties getProperties(String key); @Override boolean isEmpty(); @Override boolean containsKey(String key); @Override void addProperty(String key, Object value); @SuppressWarnings("unchecked") @Override void setProperty(String key, Object value); @Override void clearProperty(String key); @Override void clear(); @Override Object getProperty(String key); @Override Iterator<String> getKeys(String prefix); @Override Iterator<String> getKeys(); @Override boolean getBoolean(String key); @Override Boolean getBoolean(String key, Boolean defaultValue); @Override boolean getBoolean(String key, boolean defaultValue); @Override byte getByte(String key); @Override byte getByte(String key, byte defaultValue); @Override Byte getByte(String key, Byte defaultValue); @Override double getDouble(String key); @Override double getDouble(String key, double defaultValue); @Override Double getDouble(String key, Double defaultValue); @Override float getFloat(String key); @Override float getFloat(String key, float defaultValue); @Override Float getFloat(String key, Float defaultValue); @Override int getInt(String key); @Override int getInt(String key, int defaultValue); @Override Integer getInteger(String key, Integer defaultValue); @Override long getLong(String key); @Override Long getLong(String key, Long defaultValue); @Override long getLong(String key, long defaultValue); @Override short getShort(String key); @Override short getShort(String key, short defaultValue); @Override Short getShort(String key, Short defaultValue); @Override BigDecimal getBigDecimal(String key); @Override BigDecimal getBigDecimal(String key, BigDecimal defaultValue); @Override BigInteger getBigInteger(String key); @Override BigInteger getBigInteger(String key, BigInteger defaultValue); @Override String getString(String key); @Override String getString(String key, String defaultValue); @Override List<Object> getList(String key); @Override List<Object> getList(String key, List<?> defaultValue); @Override String[] getStringArray(String key); PropertyStore ff4jStore(); PropertyStore getFf4jStore(); void setFf4jStore(PropertyStore ff4jStore); }### Answer:
@Test public void testAddProperty() { Assert.assertFalse(ff4jConf.containsKey("myNewProp")); ff4jConf.addProperty("myNewProp", "hello"); Assert.assertTrue(ff4jConf.containsKey("myNewProp")); Assert.assertTrue(pStore.existProperty("myNewProp")); Assert.assertEquals("hello", pStore.readProperty("myNewProp").asString()); } |
### Question:
FF4jConfiguration extends AbstractConfiguration { @Override protected void addPropertyDirect(String key, Object value) { ff4jStore().createProperty(PropertyFactory.createProperty(key, value)); } FF4jConfiguration(); FF4jConfiguration(PropertyStore ff4jPropertyStore); @Override Configuration subset(String prefix); @Override Properties getProperties(String key); @Override boolean isEmpty(); @Override boolean containsKey(String key); @Override void addProperty(String key, Object value); @SuppressWarnings("unchecked") @Override void setProperty(String key, Object value); @Override void clearProperty(String key); @Override void clear(); @Override Object getProperty(String key); @Override Iterator<String> getKeys(String prefix); @Override Iterator<String> getKeys(); @Override boolean getBoolean(String key); @Override Boolean getBoolean(String key, Boolean defaultValue); @Override boolean getBoolean(String key, boolean defaultValue); @Override byte getByte(String key); @Override byte getByte(String key, byte defaultValue); @Override Byte getByte(String key, Byte defaultValue); @Override double getDouble(String key); @Override double getDouble(String key, double defaultValue); @Override Double getDouble(String key, Double defaultValue); @Override float getFloat(String key); @Override float getFloat(String key, float defaultValue); @Override Float getFloat(String key, Float defaultValue); @Override int getInt(String key); @Override int getInt(String key, int defaultValue); @Override Integer getInteger(String key, Integer defaultValue); @Override long getLong(String key); @Override Long getLong(String key, Long defaultValue); @Override long getLong(String key, long defaultValue); @Override short getShort(String key); @Override short getShort(String key, short defaultValue); @Override Short getShort(String key, Short defaultValue); @Override BigDecimal getBigDecimal(String key); @Override BigDecimal getBigDecimal(String key, BigDecimal defaultValue); @Override BigInteger getBigInteger(String key); @Override BigInteger getBigInteger(String key, BigInteger defaultValue); @Override String getString(String key); @Override String getString(String key, String defaultValue); @Override List<Object> getList(String key); @Override List<Object> getList(String key, List<?> defaultValue); @Override String[] getStringArray(String key); PropertyStore ff4jStore(); PropertyStore getFf4jStore(); void setFf4jStore(PropertyStore ff4jStore); }### Answer:
@Test public void testAddPropertyDirect() { Assert.assertFalse(ff4jConf.containsKey("myNewProp")); ff4jConf.addPropertyDirect("myNewProp", "hello"); Assert.assertTrue(ff4jConf.containsKey("myNewProp")); Assert.assertTrue(pStore.existProperty("myNewProp")); Assert.assertEquals("hello", pStore.readProperty("myNewProp").asString()); } |
### Question:
FF4jConfiguration extends AbstractConfiguration { @Override public void clearProperty(String key) { ff4jStore().deleteProperty(key); } FF4jConfiguration(); FF4jConfiguration(PropertyStore ff4jPropertyStore); @Override Configuration subset(String prefix); @Override Properties getProperties(String key); @Override boolean isEmpty(); @Override boolean containsKey(String key); @Override void addProperty(String key, Object value); @SuppressWarnings("unchecked") @Override void setProperty(String key, Object value); @Override void clearProperty(String key); @Override void clear(); @Override Object getProperty(String key); @Override Iterator<String> getKeys(String prefix); @Override Iterator<String> getKeys(); @Override boolean getBoolean(String key); @Override Boolean getBoolean(String key, Boolean defaultValue); @Override boolean getBoolean(String key, boolean defaultValue); @Override byte getByte(String key); @Override byte getByte(String key, byte defaultValue); @Override Byte getByte(String key, Byte defaultValue); @Override double getDouble(String key); @Override double getDouble(String key, double defaultValue); @Override Double getDouble(String key, Double defaultValue); @Override float getFloat(String key); @Override float getFloat(String key, float defaultValue); @Override Float getFloat(String key, Float defaultValue); @Override int getInt(String key); @Override int getInt(String key, int defaultValue); @Override Integer getInteger(String key, Integer defaultValue); @Override long getLong(String key); @Override Long getLong(String key, Long defaultValue); @Override long getLong(String key, long defaultValue); @Override short getShort(String key); @Override short getShort(String key, short defaultValue); @Override Short getShort(String key, Short defaultValue); @Override BigDecimal getBigDecimal(String key); @Override BigDecimal getBigDecimal(String key, BigDecimal defaultValue); @Override BigInteger getBigInteger(String key); @Override BigInteger getBigInteger(String key, BigInteger defaultValue); @Override String getString(String key); @Override String getString(String key, String defaultValue); @Override List<Object> getList(String key); @Override List<Object> getList(String key, List<?> defaultValue); @Override String[] getStringArray(String key); PropertyStore ff4jStore(); PropertyStore getFf4jStore(); void setFf4jStore(PropertyStore ff4jStore); }### Answer:
@Test public void testClearProperty() { Assert.assertTrue(ff4jConf.containsKey("propInt")); ff4jConf.clearProperty("propInt"); Assert.assertFalse(ff4jConf.containsKey("propInt")); Assert.assertFalse(pStore.existProperty("myNewProp")); } |
### Question:
FF4jConfiguration extends AbstractConfiguration { @Override public void clear() { ff4jStore().clear(); } FF4jConfiguration(); FF4jConfiguration(PropertyStore ff4jPropertyStore); @Override Configuration subset(String prefix); @Override Properties getProperties(String key); @Override boolean isEmpty(); @Override boolean containsKey(String key); @Override void addProperty(String key, Object value); @SuppressWarnings("unchecked") @Override void setProperty(String key, Object value); @Override void clearProperty(String key); @Override void clear(); @Override Object getProperty(String key); @Override Iterator<String> getKeys(String prefix); @Override Iterator<String> getKeys(); @Override boolean getBoolean(String key); @Override Boolean getBoolean(String key, Boolean defaultValue); @Override boolean getBoolean(String key, boolean defaultValue); @Override byte getByte(String key); @Override byte getByte(String key, byte defaultValue); @Override Byte getByte(String key, Byte defaultValue); @Override double getDouble(String key); @Override double getDouble(String key, double defaultValue); @Override Double getDouble(String key, Double defaultValue); @Override float getFloat(String key); @Override float getFloat(String key, float defaultValue); @Override Float getFloat(String key, Float defaultValue); @Override int getInt(String key); @Override int getInt(String key, int defaultValue); @Override Integer getInteger(String key, Integer defaultValue); @Override long getLong(String key); @Override Long getLong(String key, Long defaultValue); @Override long getLong(String key, long defaultValue); @Override short getShort(String key); @Override short getShort(String key, short defaultValue); @Override Short getShort(String key, Short defaultValue); @Override BigDecimal getBigDecimal(String key); @Override BigDecimal getBigDecimal(String key, BigDecimal defaultValue); @Override BigInteger getBigInteger(String key); @Override BigInteger getBigInteger(String key, BigInteger defaultValue); @Override String getString(String key); @Override String getString(String key, String defaultValue); @Override List<Object> getList(String key); @Override List<Object> getList(String key, List<?> defaultValue); @Override String[] getStringArray(String key); PropertyStore ff4jStore(); PropertyStore getFf4jStore(); void setFf4jStore(PropertyStore ff4jStore); }### Answer:
@Test public void testClear() { Assert.assertTrue(ff4jConf.containsKey("propInt")); ff4jConf.clear(); Assert.assertFalse(ff4jConf.containsKey("propInt")); Assert.assertTrue(ff4jConf.isEmpty()); Assert.assertTrue(pStore.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:
SimpleTextFormat implements Format { @Override public String format(@Nonnull final LogContext log) { final StringBuilder builder = new StringBuilder(); for (final Token token : tokens) { token.append(log, builder); } return builder.toString(); } SimpleTextFormat(@Nonnull final String format); SimpleTextFormat(@Nonnull final String format, @Nonnull final Pattern variablePattern); @Override String format(@Nonnull final LogContext log); @Override String toString(); }### Answer:
@Test public void testAttrs() { final LogContext ctx = Mockito.mock(LogContext.class); when(ctx.getAttr(eq("attr1"))).thenReturn("value1"); when(ctx.getAttr(eq("attr2"))).thenReturn(null); when(ctx.getAttr(eq("attr3"))).thenReturn(new Object() { @Override public String toString() { return "to-string"; } }); String result = new SimpleTextFormat("[${attr1}][${attr2}][${attr3}]").format(ctx); Assertions.assertThat(result).isEqualTo("[value1][][to-string]"); }
@Test public void testTitle() { final LogContext ctx = Mockito.mock(LogContext.class); when(ctx.title()).thenReturn("test-title"); String result = new SimpleTextFormat("[${title}]").format(ctx); Assertions.assertThat(result).isEqualTo("[test-title]"); }
@Test public void testResult() { final LogContext ctx = Mockito.mock(LogContext.class); when(ctx.result()).thenReturn("test-result"); String result = new SimpleTextFormat("[${result}]").format(ctx); Assertions.assertThat(result).isEqualTo("[test-result]"); }
@Test public void testResultNull() { final LogContext ctx = Mockito.mock(LogContext.class); when(ctx.result()).thenReturn(null); String result = new SimpleTextFormat("[${result}]").format(ctx); Assertions.assertThat(result).isEqualTo("[]"); }
@Test public void testResultToString() { final LogContext ctx = Mockito.mock(LogContext.class); when(ctx.result()).thenReturn(new Object() { @Override public String toString() { return "to-string"; } }); String result = new SimpleTextFormat("[${result}]").format(ctx); Assertions.assertThat(result).isEqualTo("[to-string]"); }
@Test public void testTrace() { final LogContext ctx = Mockito.mock(LogContext.class); when(ctx.trace()).thenReturn("test-trace"); String result = new SimpleTextFormat("[${trace}]").format(ctx); Assertions.assertThat(result).isEqualTo("[test-trace]"); }
@Test public void testTime() { final LogContext ctx = Mockito.mock(LogContext.class); when(ctx.startTime()).thenReturn(100L); when(ctx.endTime()).thenReturn(300L); String result = new SimpleTextFormat("[${time}]").format(ctx); Assertions.assertThat(result).isEqualTo("[200]"); } |
### 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:
SmartLog { public static void finish() { final Deque<LogContext> list = CONTEXTS.get(); if (!list.isEmpty()) { final LogContext ctx = list.pop(); final Object loggableObject = ctx.loggableObject(); if (loggableObject != null && loggableObject instanceof LoggableCallback) { final LoggableCallback callback = (LoggableCallback) loggableObject; try { callback.afterLoggable(); } catch (Exception e) { ctx.throwable(e); } } ctx.endTime(System.currentTimeMillis()); ctx.output() .write(ctx); ctx.clearMDC() .recoverThreadName(); } 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 finishThrowExceptionIfNoLogContext() throws Exception { try { SmartLog.finish(); } 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:
Arguments implements GenerationConfig { public Arguments parse(String[] args) { JCommander jCommander = new JCommander(this); jCommander.setProgramName("jsonschema2pojo"); try { jCommander.parse(args); if (this.showHelp) { jCommander.usage(); exit(EXIT_OKAY); } } catch (ParameterException e) { System.err.println(e.getMessage()); jCommander.usage(); exit(EXIT_ERROR); } return this; } Arguments parse(String[] args); @Override Iterator<URL> getSource(); @Override File getTargetDirectory(); @Override String getTargetPackage(); @Override boolean isGenerateBuilders(); @Override boolean isIncludeTypeInfo(); String getLogLevel(); @Override boolean isUseInnerClassBuilders(); @Override boolean isIncludeConstructorPropertiesAnnotation(); @Override boolean isUsePrimitives(); @Override char[] getPropertyWordDelimiters(); @Override boolean isUseLongIntegers(); @Override boolean isUseDoubleNumbers(); @Override boolean isIncludeHashcodeAndEquals(); @Override boolean isIncludeToString(); @Override String[] getToStringExcludes(); @Override AnnotationStyle getAnnotationStyle(); @Override boolean isUseTitleAsClassname(); @Override InclusionLevel getInclusionLevel(); @Override Class<? extends Annotator> getCustomAnnotator(); @Override Class<? extends RuleFactory> getCustomRuleFactory(); @Override boolean isIncludeJsr303Annotations(); @Override boolean isIncludeJsr305Annotations(); @Override boolean isUseOptionalForGetters(); @Override SourceType getSourceType(); @Override boolean isRemoveOldOutput(); @Override String getOutputEncoding(); @Override boolean isUseJodaDates(); @Override boolean isUseJodaLocalDates(); @Override boolean isUseJodaLocalTimes(); boolean isUseCommonsLang3(); @Override boolean isParcelable(); @Override boolean isSerializable(); @Override FileFilter getFileFilter(); @Override boolean isInitializeCollections(); @Override String getClassNamePrefix(); @Override String getClassNameSuffix(); @Override String[] getFileExtensions(); @Override boolean isIncludeConstructors(); @Override boolean isConstructorsRequiredPropertiesOnly(); boolean isPrintLogLevels(); @Override boolean isIncludeRequiredPropertiesConstructor(); @Override boolean isIncludeAllPropertiesConstructor(); @Override boolean isIncludeCopyConstructor(); @Override boolean isIncludeAdditionalProperties(); @Override boolean isIncludeGetters(); @Override boolean isIncludeSetters(); @Override String getTargetVersion(); @Override boolean isIncludeDynamicAccessors(); @Override boolean isIncludeDynamicGetters(); @Override boolean isIncludeDynamicSetters(); @Override boolean isIncludeDynamicBuilders(); @Override String getDateTimeType(); @Override String getDateType(); @Override String getTimeType(); @Override boolean isUseBigIntegers(); @Override boolean isUseBigDecimals(); @Override boolean isFormatDateTimes(); @Override boolean isFormatDates(); @Override boolean isFormatTimes(); @Override String getRefFragmentPathDelimiters(); @Override String getCustomDatePattern(); @Override String getCustomTimePattern(); @Override String getCustomDateTimePattern(); @Override SourceSortOrder getSourceSortOrder(); @Override Language getTargetLanguage(); @Override Map<String, String> getFormatTypeMapping(); @Parameter(names = { "-dg", "--disable-getters" }, description = "Whether to omit getter methods and create fields instead.")
private boolean disableGetters; @Parameter(names = { "-ds", "--disable-setters" }, description = "Whether to omit setter methods and create fields instead.")
private boolean disableSetters; }### Answer:
@Test public void missingArgsCausesHelp() throws IOException { ArgsForTest args = (ArgsForTest) new ArgsForTest().parse(new String[] {}); assertThat(args.status, is(1)); assertThat(new String(systemErrCapture.toByteArray(), StandardCharsets.UTF_8), is(containsString("--target"))); assertThat(new String(systemErrCapture.toByteArray(), StandardCharsets.UTF_8), is(containsString("--source"))); assertThat(new String(systemOutCapture.toByteArray(), StandardCharsets.UTF_8), is(containsString("Usage: jsonschema2pojo"))); }
@Test public void requestingHelpCausesHelp() throws IOException { ArgsForTest args = (ArgsForTest) new ArgsForTest().parse(new String[] { "--help" }); assertThat(args.status, is(notNullValue())); assertThat(new String(systemOutCapture.toByteArray(), StandardCharsets.UTF_8), is(containsString("Usage: jsonschema2pojo"))); } |
### 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:
NameHelper { public String getClassName(String propertyName, JsonNode node) { if (node != null) { if (node.has("javaName")) { propertyName = node.get("javaName").textValue(); } else if (generationConfig.isUseTitleAsClassname() && node.has("title")) { String title = node.get("title").textValue(); propertyName = WordUtils.capitalize(title).replaceAll(" ", ""); } } return 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 testClassNameCorrectly() { assertThat(nameHelper.getClassName("foo", NODE), is("foo")); assertThat(nameHelper.getClassName("foo", node("title", "bar")), is("foo")); assertThat(nameHelper.getClassName("foo", node("javaName", "bar")), is("bar")); assertThat(nameHelper.getClassName("foo", node("javaName", "bar").put("title", "abc")), is("bar")); NameHelper nameHelper = helper(true); assertThat(nameHelper.getClassName("foo", node("title", "bar")), is("Bar")); assertThat(nameHelper.getClassName("foo", node("title", "i am bar")), is("IAmBar")); assertThat(nameHelper.getClassName("foo", node("javaName", "bar")), is("bar")); assertThat(nameHelper.getClassName("foo", node("javaName", "bar").put("title", "abc")), is("bar")); } |
### 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:
AnnotatorFactory { public Annotator getAnnotator(AnnotationStyle style) { switch (style) { case JACKSON: case JACKSON2: return new Jackson2Annotator(generationConfig); case JACKSON1: return new Jackson1Annotator(generationConfig); case GSON: return new GsonAnnotator(generationConfig); case MOSHI1: return new Moshi1Annotator(generationConfig); case NONE: return new NoopAnnotator(); default: throw new IllegalArgumentException("Unrecognised annotation style: " + style); } } AnnotatorFactory(GenerationConfig generationConfig); Annotator getAnnotator(AnnotationStyle style); Annotator getAnnotator(Class<? extends Annotator> clazz); CompositeAnnotator getAnnotator( Annotator... annotators ); }### Answer:
@Test public void canCreateCorrectAnnotatorFromAnnotationStyle() { assertThat(factory.getAnnotator(JACKSON1), is(instanceOf(Jackson1Annotator.class))); assertThat(factory.getAnnotator(JACKSON), is(instanceOf(Jackson2Annotator.class))); assertThat(factory.getAnnotator(JACKSON2), is(instanceOf(Jackson2Annotator.class))); assertThat(factory.getAnnotator(GSON), is(instanceOf(GsonAnnotator.class))); assertThat(factory.getAnnotator(MOSHI1), is(instanceOf(Moshi1Annotator.class))); assertThat(factory.getAnnotator(NONE), is(instanceOf(NoopAnnotator.class))); }
@Test public void canCreateCorrectAnnotatorFromClass() { assertThat(factory.getAnnotator(Jackson1Annotator.class), is(instanceOf(Jackson1Annotator.class))); }
@Test public void canCreateCompositeAnnotator() { Annotator annotator1 = mock(Annotator.class); Annotator annotator2 = mock(Annotator.class); CompositeAnnotator composite = factory.getAnnotator(annotator1, annotator2); assertThat(composite.annotators.length, equalTo(2)); assertThat(composite.annotators[0], is(equalTo(annotator1))); assertThat(composite.annotators[1], is(equalTo(annotator2))); } |
### 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:
DigitsRule implements Rule<JFieldVar, JFieldVar> { @Override public JFieldVar apply(String nodeName, JsonNode node, JsonNode parent, JFieldVar field, Schema currentSchema) { if (ruleFactory.getGenerationConfig().isIncludeJsr303Annotations() && node.has("integerDigits") && node.has("fractionalDigits") && isApplicableType(field)) { JAnnotationUse annotation = field.annotate(Digits.class); annotation.param("integer", node.get("integerDigits").asInt()); annotation.param("fraction", node.get("fractionalDigits").asInt()); } return field; } protected DigitsRule(RuleFactory ruleFactory); @Override JFieldVar apply(String nodeName, JsonNode node, JsonNode parent, JFieldVar field, Schema currentSchema); }### Answer:
@Test public void testHasIntegerAndFractionalDigits() { when(config.isIncludeJsr303Annotations()).thenReturn(true); final int intValue = new Random().nextInt(); final int fractionalValue = new Random().nextInt(); when(subNodeInteger.asInt()).thenReturn(intValue); when(subNodeFractional.asInt()).thenReturn(fractionalValue); when(node.get("integerDigits")).thenReturn(subNodeInteger); when(node.get("fractionalDigits")).thenReturn(subNodeFractional); when(fieldVar.annotate(Digits.class)).thenReturn(annotation); when(node.has("integerDigits")).thenReturn(true); when(node.has("fractionalDigits")).thenReturn(true); 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(Digits.class); verify(annotation, times(isApplicable ? 1 : 0)).param("integer", intValue); verify(annotation, times(isApplicable ? 1 : 0)).param("fraction", fractionalValue); }
@Test public void testNotUsed() { when(config.isIncludeJsr303Annotations()).thenReturn(true); when(node.has("integerDigits")).thenReturn(false); when(node.has("fractionalDigits")).thenReturn(false); when(fieldVar.type().boxify().fullName()).thenReturn(fieldClass.getTypeName()); JFieldVar result = rule.apply("node", node, null, fieldVar, null); assertSame(fieldVar, result); verify(fieldVar, never()).annotate(Size.class); verify(annotation, never()).param(anyString(), anyInt()); }
@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(DecimalMin.class); verify(annotation, never()).param(anyString(), anyInt()); } |
### Question:
RequiredArrayRule implements Rule<JDefinedClass, JDefinedClass> { @Override public JDefinedClass apply(String nodeName, JsonNode node, JsonNode parent, JDefinedClass jclass, Schema schema) { List<String> requiredFieldMethods = new ArrayList<>(); JsonNode properties = schema.getContent().get("properties"); for (Iterator<JsonNode> iterator = node.elements(); iterator.hasNext(); ) { String requiredArrayItem = iterator.next().asText(); if (requiredArrayItem.isEmpty()) { continue; } JsonNode propertyNode = null; if (properties != null) { propertyNode = properties.findValue(requiredArrayItem); } String fieldName = ruleFactory.getNameHelper().getPropertyName(requiredArrayItem, propertyNode); JFieldVar field = jclass.fields().get(fieldName); if (field == null) { continue; } addJavaDoc(field); if (ruleFactory.getGenerationConfig().isIncludeJsr303Annotations()) { addNotNullAnnotation(field); } if (ruleFactory.getGenerationConfig().isIncludeJsr305Annotations()) { addNonnullAnnotation(field); } requiredFieldMethods.add(getGetterName(fieldName, field.type(), node)); requiredFieldMethods.add(getSetterName(fieldName, node)); } updateGetterSetterJavaDoc(jclass, requiredFieldMethods); return jclass; } protected RequiredArrayRule(RuleFactory ruleFactory); @Override JDefinedClass apply(String nodeName, JsonNode node, JsonNode parent, JDefinedClass jclass, Schema schema); static final String REQUIRED_COMMENT_TEXT; }### Answer:
@Test public void shouldUpdateJavaDoc() throws JClassAlreadyExistsException { JDefinedClass jclass = new JCodeModel()._class(TARGET_CLASS_NAME); jclass.field(JMod.PRIVATE, jclass.owner().ref(String.class), "fooBar"); jclass.field(JMod.PRIVATE, jclass.owner().ref(String.class), "foo"); ObjectMapper mapper = new ObjectMapper(); ArrayNode requiredNode = mapper.createArrayNode().add("fooBar"); rule.apply("Class", requiredNode, null, jclass, new Schema(null, requiredNode, null)); JDocComment fooBarJavaDoc = jclass.fields().get("fooBar").javadoc(); JDocComment fooJavaDoc = jclass.fields().get("foo").javadoc(); assertThat(fooBarJavaDoc.size(), is(1)); assertThat((String) fooBarJavaDoc.get(0), is("\n(Required)")); assertThat(fooJavaDoc.size(), is(0)); }
@Test public void shouldUpdateAnnotations() throws JClassAlreadyExistsException { setupRuleFactoryToIncludeJsr303(); JDefinedClass jclass = new JCodeModel()._class(TARGET_CLASS_NAME); jclass.field(JMod.PRIVATE, jclass.owner().ref(String.class), "fooBar"); jclass.field(JMod.PRIVATE, jclass.owner().ref(String.class), "foo"); ObjectMapper mapper = new ObjectMapper(); ArrayNode requiredNode = mapper.createArrayNode().add("foo_bar"); rule.apply("Class", requiredNode, null, jclass, new Schema(null, requiredNode, null)); Collection<JAnnotationUse> fooBarAnnotations = jclass.fields().get("fooBar").annotations(); Collection<JAnnotationUse> fooAnnotations = jclass.fields().get("foo").annotations(); assertThat(fooBarAnnotations.size(), is(1)); assertThat(fooBarAnnotations.iterator().next().getAnnotationClass().name(), is(NotNull.class.getSimpleName())); assertThat(fooAnnotations.size(), is(0)); } |
### Question:
Inflector { public String singularize(String word) { if (uncountables.contains(word.toLowerCase())) { return word; } return replaceWithFirstRule(word, singulars); } 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 testSingularize() { assertThat(Inflector.getInstance().singularize("dwarves"), is("dwarf")); assertThat(Inflector.getInstance().singularize("curves"), is("curve")); assertThat(Inflector.getInstance().singularize("halves"), is("half")); assertThat(Inflector.getInstance().singularize("vertices"), is("vertex")); assertThat(Inflector.getInstance().singularize("proofs"), is("proof")); assertThat(Inflector.getInstance().singularize("moths"), is("moth")); assertThat(Inflector.getInstance().singularize("houses"), is("house")); assertThat(Inflector.getInstance().singularize("rooves"), is("roof")); assertThat(Inflector.getInstance().singularize("elves"), is("elf")); assertThat(Inflector.getInstance().singularize("baths"), is("bath")); assertThat(Inflector.getInstance().singularize("leaves"), is("leaf")); assertThat(Inflector.getInstance().singularize("calves"), is("calf")); assertThat(Inflector.getInstance().singularize("lives"), is("life")); assertThat(Inflector.getInstance().singularize("knives"), is("knife")); assertThat(Inflector.getInstance().singularize("addresses"), is("address")); assertThat(Inflector.getInstance().singularize("mattresses"), is("mattress")); assertThat(Inflector.getInstance().singularize("databases"), is("database")); assertThat(Inflector.getInstance().singularize("bison"), is("bison")); assertThat(Inflector.getInstance().singularize("buffalo"), is("buffalo")); assertThat(Inflector.getInstance().singularize("deer"), is("deer")); assertThat(Inflector.getInstance().singularize("fish"), is("fish")); assertThat(Inflector.getInstance().singularize("sheep"), is("sheep")); assertThat(Inflector.getInstance().singularize("squid"), is("squid")); assertThat(Inflector.getInstance().singularize("mattress"), is("mattress")); assertThat(Inflector.getInstance().singularize("address"), is("address")); assertThat(Inflector.getInstance().singularize("men"), is("man")); assertThat(Inflector.getInstance().singularize("women"), is("woman")); assertThat(Inflector.getInstance().singularize("specimen"), is("specimen")); assertThat(Inflector.getInstance().singularize("children"), is("child")); assertThat(Inflector.getInstance().singularize("s"), is("s")); assertThat(Inflector.getInstance().singularize("status"), is("status")); assertThat(Inflector.getInstance().singularize("statuses"), is("status")); assertThat(Inflector.getInstance().singularize("LineItemTaxes"), is("LineItemTax")); assertThat(Inflector.getInstance().singularize("WidgetList"), is("Widget")); assertThat(Inflector.getInstance().singularize("slaves"), is("slave")); } |
### Question:
EnumRule implements Rule<JClassContainer, JType> { @Override public JType apply(String nodeName, JsonNode node, JsonNode parent, JClassContainer container, Schema schema) { JDefinedClass _enum; try { _enum = createEnum(node, nodeName, container); } catch (ClassAlreadyExistsException e) { ruleFactory.getLogger().error("Could not create enum.", e); return e.getExistingClass(); } schema.setJavaTypeIfEmpty(_enum); if (node.has("title")) { ruleFactory.getTitleRule().apply(nodeName, node.get("title"), node, _enum, schema); } if (node.has("description")) { ruleFactory.getDescriptionRule().apply(nodeName, node.get("description"), node, _enum, schema); } if (node.has("javaInterfaces")) { addInterfaces(_enum, node.get("javaInterfaces")); } ObjectNode typeNode = (ObjectNode)node.deepCopy(); typeNode.remove("javaType"); JType backingType = node.has("type") ? ruleFactory.getTypeRule().apply(nodeName, typeNode, parent, container, schema) : container.owner().ref(String.class); EnumDefinition enumDefinition = buildEnumDefinition(nodeName, node, backingType); JFieldVar valueField = addConstructorAndFields(enumDefinition, _enum); if(isString(backingType)){ addToString(_enum, valueField); } addFieldAccessors(_enum, valueField); addEnumConstants(enumDefinition, _enum, schema); addFactoryMethod(enumDefinition, _enum); applyCustomizations(enumDefinition, _enum); return _enum; } protected EnumRule(RuleFactory ruleFactory); @Override JType apply(String nodeName, JsonNode node, JsonNode parent, JClassContainer container, Schema schema); }### Answer:
@Test public void applyGeneratesUniqueEnumNamesForMultipleEnumNodesWithSameName() { Answer<String> firstArgAnswer = new FirstArgAnswer<>(); when(nameHelper.getClassName(anyString(), Matchers.any(JsonNode.class))).thenAnswer(firstArgAnswer); when(nameHelper.replaceIllegalCharacters(anyString())).thenAnswer(firstArgAnswer); when(nameHelper.normalizeName(anyString())).thenAnswer(firstArgAnswer); JPackage jpackage = new JCodeModel()._package(getClass().getPackage().getName()); ObjectMapper objectMapper = new ObjectMapper(); ArrayNode arrayNode = objectMapper.createArrayNode(); arrayNode.add("open"); arrayNode.add("closed"); ObjectNode enumNode = objectMapper.createObjectNode(); enumNode.put("type", "string"); enumNode.set("enum", arrayNode); when(typeRule.apply("status", enumNode, null, jpackage, schema)) .thenReturn(jpackage.owner()._ref(String.class)); JType result1 = rule.apply("status", enumNode, null, jpackage, schema); JType result2 = rule.apply("status", enumNode, null, jpackage, schema); assertThat(result1.fullName(), is("org.jsonschema2pojo.rules.Status")); assertThat(result2.fullName(), is("org.jsonschema2pojo.rules.Status_")); } |
### Question:
RequiredRule implements Rule<JDocCommentable, JDocCommentable> { @Override public JDocCommentable apply(String nodeName, JsonNode node, JsonNode parent, JDocCommentable generatableType, Schema schema) { if (node.asBoolean()) { generatableType.javadoc().append("\n(Required)"); if (ruleFactory.getGenerationConfig().isIncludeJsr303Annotations() && generatableType instanceof JFieldVar) { ((JFieldVar) generatableType).annotate(NotNull.class); } if (ruleFactory.getGenerationConfig().isIncludeJsr305Annotations() && generatableType instanceof JFieldVar) { ((JFieldVar) generatableType).annotate(Nonnull.class); } } else { if (ruleFactory.getGenerationConfig().isIncludeJsr305Annotations() && generatableType instanceof JFieldVar) { ((JFieldVar) generatableType).annotate(Nullable.class); } } return generatableType; } protected RequiredRule(RuleFactory ruleFactory); @Override JDocCommentable apply(String nodeName, JsonNode node, JsonNode parent, JDocCommentable generatableType, Schema schema); }### Answer:
@Test public void applyAddsTextWhenRequired() throws JClassAlreadyExistsException { JDefinedClass jclass = new JCodeModel()._class(TARGET_CLASS_NAME); ObjectMapper mapper = new ObjectMapper(); BooleanNode descriptionNode = mapper.createObjectNode().booleanNode(true); JDocCommentable result = rule.apply("fooBar", descriptionNode, null, jclass, null); assertThat(result.javadoc(), sameInstance(jclass.javadoc())); assertThat(result.javadoc().size(), is(1)); assertThat((String) result.javadoc().get(0), is("\n(Required)")); }
@Test public void applySkipsTextWhenNotRequired() throws JClassAlreadyExistsException { JDefinedClass jclass = new JCodeModel()._class(TARGET_CLASS_NAME); ObjectMapper mapper = new ObjectMapper(); BooleanNode descriptionNode = mapper.createObjectNode().booleanNode(false); JDocCommentable result = rule.apply("fooBar", descriptionNode, null, jclass, null); assertThat(result.javadoc(), sameInstance(jclass.javadoc())); assertThat(result.javadoc().size(), is(0)); } |
### 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:
Utils { public static boolean isImmutableMethod( Class<?> clazz, String methodName, ArrayList<Object> params) { if (clazz == null) { throw new NullPointerException("Class not specified"); } if (methodName == null || methodName.trim().isEmpty()) { throw new IllegalArgumentException("method name not specified"); } Class[] paramTypes = new Class[params.size()]; for (int i = 0; i < params.size(); i++) { paramTypes[i] = params.get(i).getClass(); } try { Method method = clazz.getMethod(methodName, paramTypes); return method.getDeclaredAnnotation(Immutable.class) != null; } catch (NoSuchMethodException e) { throw new IllegalStateException( String.format( "unable to find method %s in %s with param types %s", methodName, clazz, paramTypes), e); } } private Utils(); static final Runnable RunnerWrapper(final Runnable runnable); static final byte[] toBytes(Object object); static Object toObject(byte[] bytes); static boolean isImmutableMethod(
Class<?> clazz, String methodName, ArrayList<Object> params); static boolean isImmutableMethod(Method method); static A getAnnotation(
Annotation[] annotations, Class<A> annotationType); static Map<String, PolicyConfig> toPolicyConfig(Annotation[] annotations); static Map<String, Map<String, PolicyConfig>> fromDMSpecListToConfigMap(
List<DMSpec> dmSpecList); static Map<String, PolicyConfig> fromDMSpecListToFlatConfigMap(List<DMSpec> dmSpecList); static Context getGraalContext(Language language, String microServicePath); }### Answer:
@Test public void testIsImmutable() throws Exception { ArrayList<Object> params = new ArrayList<Object>(); params.add("hello"); Clazz clazz = new Clazz(); Assert.assertTrue(Utils.isImmutableMethod(clazz.getClass(), "immutable", params)); }
@Test public void testIsMutable() throws Exception { ArrayList<Object> params = new ArrayList<Object>(); params.add(5); Clazz clazz = new Clazz(); Assert.assertFalse(Utils.isImmutableMethod(clazz.getClass(), "mutable", params)); } |
### 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 { public int requestVote(int term, UUID candidate, int lastLogIndex, int lastLogTerm) throws InvalidTermException, AlreadyVotedException, CandidateBehindException { logger.fine( String.format( "%s received vote request from %s (term=%d, lastLogIndex=%d, lastLogTerm=%d)", pState.myServerID, candidate, term, lastLogIndex, lastLogTerm)); if (!candidate.equals( pState.myServerID)) { this.respondToRemoteTerm(term); } int localLogSize, currentTerm, myLastLogTerm = -1, myLastLogIndex; UUID votedFor; synchronized (pState) { currentTerm = pState.getCurrentTerm(); votedFor = pState.getVotedFor(); localLogSize = pState.log().size(); myLastLogIndex = this.lastLogIndex(); if (myLastLogIndex != -1) { myLastLogTerm = pState.log().get(myLastLogIndex).term; } } if (term < currentTerm) { throw new InvalidTermException( "Server: Received voting request for old leader term " + term + ", current term " + currentTerm + ". No vote granted.", currentTerm); } if (votedFor.equals(NO_LEADER) || votedFor.equals(candidate)) { logger.fine( String.format( "%s deciding whether to vote for %s: local log size = %d", pState.myServerID, candidate, localLogSize)); if (lastLogIndex >= myLastLogIndex && (localLogSize == 0 || lastLogTerm >= myLastLogTerm)) { logger.fine( String.format("%s decided to vote for %s", pState.myServerID, candidate)); pState.setVotedFor(candidate, votedFor); return currentTerm; } else { throw new CandidateBehindException( String.format( "Candidate is behind. Candidate last log index, term = (%d, %d), current last log index, term = (%d, %d)", lastLogIndex, lastLogTerm, myLastLogIndex, myLastLogTerm), currentTerm); } } else { throw new AlreadyVotedException( String.format( "Request to vote for %s but already voted for %s (current term = %d)", candidate, votedFor, currentTerm), currentTerm); } } 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 requestVote() throws Exception { } |
### 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:
TwoPCLocalParticipants implements Serializable { public Boolean allParticipantsVotedYes(UUID transactionId) throws TransactionExecutionException { ArrayList<Object> paramsVoteReq = TransactionWrapper.getTransactionRPCParams( transactionId, TwoPCPrimitive.VoteReq, null); TransactionContext.enterTransaction( transactionId, this.getParticipantManager(transactionId)); try { boolean isAllYes = true; for (ClientPolicy p : this.getParticipants(transactionId)) { if (TransactionContext.getProcessedClients().contains(p)) { continue; } try { TransactionContext.getProcessedClients().add(p); Object vote = p.onRPC(TransactionWrapper.txWrapperTag, paramsVoteReq); if (!TransactionManager.Vote.YES.equals(vote)) { isAllYes = false; break; } } catch (Exception e) { throw new TransactionExecutionException( "2PC transaction exception: vote_req", e); } } return isAllYes; } 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_on_all_yes_voted() throws Exception { when(part1.onRPC(eq("tx_rpc"), any(ArrayList.class))) .thenReturn(TransactionManager.Vote.YES); when(part2.onRPC(eq("tx_rpc"), any(ArrayList.class))) .thenReturn(TransactionManager.Vote.YES); Boolean isAllYes = participants.allParticipantsVotedYes(id); assertTrue(isAllYes); }
@Test public void test_on_any_not_yes_voted() throws Exception { when(part1.onRPC(eq("tx_rpc"), any(ArrayList.class))) .thenReturn(TransactionManager.Vote.YES); when(part2.onRPC(eq("tx_rpc"), any(ArrayList.class))) .thenReturn(TransactionManager.Vote.UNCERTIAN); Boolean isAllYes = participants.allParticipantsVotedYes(id); assertFalse(isAllYes); } |
### 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:
TLSTransactionManager implements TransactionManager, Serializable { @Override public Vote vote(UUID transactionId) throws TransactionExecutionException { LocalStatus status = this.localStatusManager.getStatus(transactionId); switch (status) { case YESVOTED: return Vote.YES; case NOVOTED: return Vote.NO; case BAD: case UNCERTAIN: this.localStatusManager.setStatus(transactionId, LocalStatus.NOVOTED); return Vote.NO; case GOOD: if (this.isLocalPromised(transactionId) && this.localParticipantsManager.allParticipantsVotedYes(transactionId)) { this.localStatusManager.setStatus(transactionId, LocalStatus.YESVOTED); return Vote.YES; } else { this.localStatusManager.setStatus(transactionId, LocalStatus.NOVOTED); return Vote.NO; } default: throw new IllegalStateException("illegal 2PC local status: " + status.toString()); } } 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_vote_yes_on_all_good() throws Exception { when(this.participantsManager.allParticipantsVotedYes(any(UUID.class))).thenReturn(true); when(this.txPromiser.promises(any(UUID.class))).thenReturn(true); TwoPCLocalStatus statusManager = mock(TwoPCLocalStatus.class); when(statusManager.getStatus(txId)).thenReturn(TwoPCLocalStatus.LocalStatus.GOOD); ReflectionTestUtil.setField(this.txManager, "localStatusManager", statusManager); TransactionManager.Vote result = txManager.vote(txId); assertEquals(TransactionManager.Vote.YES, result); }
@Test public void test_vote_no_on_any_nogood() throws Exception { when(this.participantsManager.allParticipantsVotedYes(any(UUID.class))).thenReturn(false); TwoPCLocalStatus statusManager = mock(TwoPCLocalStatus.class); when(statusManager.getStatus(txId)).thenReturn(TwoPCLocalStatus.LocalStatus.GOOD); ReflectionTestUtil.setField(this.txManager, "localStatusManager", statusManager); TransactionManager.Vote result = txManager.vote(txId); assertEquals(TransactionManager.Vote.NO, result); } |
### 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:
Wrapper { public Wrapper<T> wrap(T wrapped) { this.wrapped = wrapped; return this; } Wrapper<T> wrap(T wrapped); T getWrapped(); void setPosition(int position); int getPosition(); @Override int hashCode(); @Override @SuppressWarnings("unchecked") boolean equals(Object obj); @Override String toString(); abstract boolean safelyEquals(T actual, T expected); abstract String asString(T obj); }### Answer:
@Test public void testEqualsSymmetric() { Wrapper<Object> objectWrapper1 = createTestWrapper(); Wrapper<Object> objectWrapper2 = createTestWrapper().wrap(objectWrapper1); Wrapper<Object> objectWrapper3 = createTestWrapper().wrap(objectWrapper1); String errorMessage = "Equals method should be symmetric"; Assert.assertThat(errorMessage, objectWrapper2, equalTo(objectWrapper3)); Assert.assertThat(errorMessage, objectWrapper3, equalTo(objectWrapper2)); Assert.assertThat(errorMessage, objectWrapper1, not(equalTo(objectWrapper2))); Assert.assertThat(errorMessage, objectWrapper2, not(equalTo(objectWrapper1))); }
@Test public void testEqualsTransitive() { Wrapper<Object> objectWrapper1 = createTestWrapper(); Wrapper<Object> objectWrapper2 = createTestWrapper().wrap(objectWrapper1); Wrapper<Object> objectWrapper3 = createTestWrapper().wrap(objectWrapper1); Wrapper<Object> objectWrapper4 = createTestWrapper().wrap(objectWrapper1); String errorMessage = "Equals method should be transitive"; Assert.assertThat(errorMessage, objectWrapper2, equalTo(objectWrapper3)); Assert.assertThat(errorMessage, objectWrapper3, equalTo(objectWrapper4)); Assert.assertThat(errorMessage, objectWrapper2, equalTo(objectWrapper4)); }
@Test public void testEqualsConsistent() { Wrapper<Object> objectWrapper1 = createTestWrapper(); Wrapper<Object> objectWrapper2 = createTestWrapper().wrap(objectWrapper1); Wrapper<Object> objectWrapper3 = createTestWrapper().wrap(objectWrapper1); final int attempts = 10; for (int i = 0; i < attempts; i++) { Assert.assertThat( "Equals method should be consistent", objectWrapper2, equalTo(objectWrapper3) ); } } |
### Question:
HasSameItemsAsListMatcher extends TypeSafeDiagnosingMatcher<List<? extends T>> { @Factory public static <T> HasSameItemsAsListMatcher<T> hasSameItemsAsList(List<? extends T> correctList) { return new HasSameItemsAsListMatcher<>(correctList); } HasSameItemsAsListMatcher(List<? extends T> expect); HasSameItemsAsListMatcher<T> useWrapperFactory(WrapperFactory<T> wrapperFactory); HasSameItemsAsListMatcher<T> sameSorted(); @Override void describeTo(Description description); @Factory static HasSameItemsAsListMatcher<T> hasSameItemsAsList(List<? extends T> correctList); }### Answer:
@Test public void listNotSameOrderButEqual() throws Exception { List<String> actual = asList("1", "2", "3"); List<String> expected = asList("3", "2", "1"); assertThat(actual, HasSameItemsAsListMatcher.hasSameItemsAsList(expected)); }
@Test(expected = AssertionError.class) public void listNotEqualSortedAndContainsNewItems() throws Exception { List<Integer> actual = asList(1, 2, 3, 4); List<Integer> expected = asList(3, 2, 1); assertThat(actual, HasSameItemsAsListMatcher.hasSameItemsAsList(expected)); }
@Test(expected = AssertionError.class) public void listNotEqualSortedAndNotContainsSomeItems() throws Exception { List<String> actual = asList("1", "2", "3"); List<String> expected = asList("3", "2", "1", "4"); assertThat(actual, HasSameItemsAsListMatcher.hasSameItemsAsList(expected)); }
@Test(expected = AssertionError.class) public void actualListHasLastItemTwice() throws Exception { List<String> actual = asList("1", "2", "3", "3"); List<String> expected = asList("1", "2", "3"); assertThat(actual, HasSameItemsAsListMatcher.hasSameItemsAsList(expected)); }
@Test(expected = AssertionError.class) public void actualListHasNotLastItemTwice() throws Exception { List<String> actual = asList("1", "2", "2", "3"); List<String> expected = asList("1", "2", "3"); assertThat(actual, HasSameItemsAsListMatcher.hasSameItemsAsList(expected)); }
@Test(expected = AssertionError.class) public void expectedListHasNotLastItemTwice() throws Exception { List<String> actual = asList("1", "2", "3"); List<String> expected = asList("1", "2", "2", "3"); assertThat(actual, HasSameItemsAsListMatcher.hasSameItemsAsList(expected)); } |
### Question:
HasSameItemsAsCollectionMatcher extends TypeSafeDiagnosingMatcher<Collection<? extends T>> { @Factory public static <T> Matcher<Collection<? extends T>> hasSameItemsAsCollection(Collection<? extends T> correctList) { return new HasSameItemsAsCollectionMatcher<>(correctList); } HasSameItemsAsCollectionMatcher(Collection<? extends T> expected); @Override void describeTo(Description description); @Factory static Matcher<Collection<? extends T>> hasSameItemsAsCollection(Collection<? extends T> correctList); }### Answer:
@Test(expected = AssertionError.class) public void withOnlyOneCommonElement() throws Exception { List<String> actual = Arrays.asList("1", "2", "3", "4", "7"); List<String> expected = Arrays.asList("3", "4", "5"); assertThat(actual, hasSameItemsAsCollection(expected)); }
@Test(expected = AssertionError.class) public void withOnlyOneDifferElementInActual() throws Exception { List<String> actual = Arrays.asList("1", "2", "3", "4"); List<String> expected = Arrays.asList("1", "2", "3"); assertThat(actual, hasSameItemsAsCollection(expected)); }
@Test(expected = AssertionError.class) public void withOnlyOneDifferElementInExpected() throws Exception { List<String> actual = Arrays.asList("1", "2", "3"); List<String> expected = Arrays.asList("1", "2", "3", "4"); assertThat(actual, hasSameItemsAsCollection(expected)); }
@Test public void collectionsEquals() throws Exception { List<String> actual = Arrays.asList("1", "2", "3"); List<String> expected = Arrays.asList("1", "2", "3"); assertThat(actual, hasSameItemsAsCollection(expected)); }
@Test public void collectionsEqualsWithNotEqualOrder() throws Exception { List<String> actual = Arrays.asList("1", "2", "3"); List<String> expected = Arrays.asList("3", "2", "1"); assertThat(actual, hasSameItemsAsCollection(expected)); }
@Test(expected = AssertionError.class) public void collectionsNotEqualsWhenLastElTwiceInActual() throws Exception { List<String> actual = Arrays.asList("1", "2", "3", "3"); List<String> expected = Arrays.asList("1", "2", "3"); assertThat(actual, hasSameItemsAsCollection(expected)); }
@Test(expected = AssertionError.class) public void collectionsNotEqualsWhenLastElTwiceInExpected() throws Exception { List<String> actual = Arrays.asList("1", "2", "3"); List<String> expected = Arrays.asList("1", "2", "3", "3"); assertThat(actual, hasSameItemsAsCollection(expected)); }
@Test(expected = AssertionError.class) public void collectionsNotEqualsWhenNotLastElTwiceInActual() throws Exception { List<String> actual = Arrays.asList("1", "2", "2", "3"); List<String> expected = Arrays.asList("1", "2", "3"); assertThat(actual, hasSameItemsAsCollection(expected)); }
@Test(expected = AssertionError.class) public void collectionsNotEqualsWhenNotLastElTwiceInExpected() throws Exception { List<String> actual = Arrays.asList("1", "2", "3"); List<String> expected = Arrays.asList("1", "2", "2", "3"); assertThat(actual, hasSameItemsAsCollection(expected)); } |
### 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))); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.