method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
AtlasUtil { public static String getUriDataType(String atlasUri) { List<String> uriA = AtlasUtil.getUriPartsAsArray(atlasUri); if (uriA == null || uriA.size() < 3 || isEmpty(uriA.get(2))) { return null; } return uriA.get(2); } static Properties loadPropertiesFromURL(URL url); static boolean isEmpty(String string); static boolean matchUriModule(String uriA, String uriB); static String getUriScheme(String atlasUri); static String getUriModule(String atlasUri); static String getUriDataType(String atlasUri); static String getUriModuleVersion(String atlasUri); static String getUriParameterValue(String atlasUri, String key); static Map<String, String> getUriParameters(String atlasUri); static int countCharacters(String text, char match); static List<Class<?>> findClassesForPackage(String scannedPackage); static void addAudit(AtlasSession session, String docId, String message, String path, AuditStatus status,
String value); static Audit createAudit(AuditStatus status, String docId, String docName, String path, String value, String message); static void addAudit(AtlasSession session, Validation validation); static void addAudits(AtlasInternalSession session, String docId, List<Audit> audits); static AuditStatus toAuditStatus(ValidationStatus vstatus); static String getDocumentNameById(AtlasMapping mapping, String docId); static String getChainedMessage(Throwable t); static String escapeForUri(String source); static String unescapeFromUri(String uri); static void deleteDirectory(File targetDir); static void deleteDirectoryContents(File targetDir); static void copyFile(Path sourcePath, Path destPath); static final int SPLIT_LIMIT; static final String NEW_LINE_CHARS; }### Answer:
@Test public void testGetUriDataType() { assertEquals("util", AtlasUtil.getUriDataType("atlas:java:util?param1=value1¶m2=value2")); } |
### Question:
AtlasUtil { public static String getUriScheme(String atlasUri) { List<String> uriA = AtlasUtil.getUriPartsAsArray(atlasUri); if (uriA == null || uriA.size() < 1 || isEmpty(uriA.get(0))) { return null; } return uriA.get(0); } static Properties loadPropertiesFromURL(URL url); static boolean isEmpty(String string); static boolean matchUriModule(String uriA, String uriB); static String getUriScheme(String atlasUri); static String getUriModule(String atlasUri); static String getUriDataType(String atlasUri); static String getUriModuleVersion(String atlasUri); static String getUriParameterValue(String atlasUri, String key); static Map<String, String> getUriParameters(String atlasUri); static int countCharacters(String text, char match); static List<Class<?>> findClassesForPackage(String scannedPackage); static void addAudit(AtlasSession session, String docId, String message, String path, AuditStatus status,
String value); static Audit createAudit(AuditStatus status, String docId, String docName, String path, String value, String message); static void addAudit(AtlasSession session, Validation validation); static void addAudits(AtlasInternalSession session, String docId, List<Audit> audits); static AuditStatus toAuditStatus(ValidationStatus vstatus); static String getDocumentNameById(AtlasMapping mapping, String docId); static String getChainedMessage(Throwable t); static String escapeForUri(String source); static String unescapeFromUri(String uri); static void deleteDirectory(File targetDir); static void deleteDirectoryContents(File targetDir); static void copyFile(Path sourcePath, Path destPath); static final int SPLIT_LIMIT; static final String NEW_LINE_CHARS; }### Answer:
@Test public void testGetUriScheme() { assertNull(AtlasUtil.getUriScheme(null)); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { @Override public Class<AtlasModule> getModuleClass() { return moduleClass; } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testGetModuleClass() { assertNotNull(module.getModuleClass()); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { public Constructor<AtlasModule> getConstructor() { return constructor; } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testGetConstructor() { assertNull(module.getConstructor()); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { public List<String> getFormats() { return formats; } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testGetFormats() { assertNotNull(module.getFormats()); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { @Override public String[] getDataFormats() { if (formats != null) { return formats.toArray(new String[formats.size()]); } return new String[0]; } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testGetDataFormats() { assertNotNull(module.getDataFormats()); List<String> packageNames = new ArrayList<>(); packageNames.add("io.atlasmap.core"); DefaultAtlasModuleInfo moduleInfo = new DefaultAtlasModuleInfo("name", "atlas:java", AtlasModule.class, null, null, packageNames); assertNotNull(moduleInfo.getDataFormats()); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { @Override public String getModuleClassName() { if (moduleClass != null) { return moduleClass.getName(); } return null; } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testGetModuleClassName() { assertNotNull(module.getModuleClassName()); List<String> formats = new ArrayList<>(); formats.add("java"); List<String> packageNames = new ArrayList<>(); packageNames.add("io.atlasmap.core"); DefaultAtlasModuleInfo moduleInfo = new DefaultAtlasModuleInfo("name", "atlas:java", null, null, formats, packageNames); assertNull(moduleInfo.getModuleClassName()); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { @Override public String[] getPackageNames() { if (packageNames == null || packageNames.size() < 1) { return new String[0]; } return packageNames.toArray(new String[packageNames.size()]); } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testGetPackageNames() { assertNotNull(module.getPackageNames()); List<String> formats = new ArrayList<>(); formats.add("java"); List<String> packageNames = new ArrayList<>(); DefaultAtlasModuleInfo moduleInfo = new DefaultAtlasModuleInfo("name", "atlas:java", null, null, formats, packageNames); assertNotNull(moduleInfo.getPackageNames()); moduleInfo = new DefaultAtlasModuleInfo("name", "atlas:java", null, null, formats, null); assertNotNull(moduleInfo.getPackageNames()); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { @Override public String getName() { return name; } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testGetName() { assertNotNull(module.getName()); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { @Override public String getUri() { return uri; } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testGetUri() { assertNotNull(module.getUri()); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { @Override public Boolean isSourceSupported() { return sourceSupported; } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testIsSourceSupported() { assertNull(module.isSourceSupported()); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { @Override public Boolean isTargetSupported() { return targetSupported; } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testIsTargetSupported() { assertNull(module.isTargetSupported()); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { @Override public String getClassName() { return this.getClass().getName(); } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testGetClassName() { assertNotNull(module.getClassName()); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { @Override public String getVersion() { return this.getClass().getPackage().getImplementationVersion(); } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testGetVersion() { assertNull(module.getVersion()); } |
### Question:
DefaultAtlasModuleInfo implements AtlasModuleInfo, AtlasModuleInfoMXBean { @Override public String toString() { return "DefaultAtlasModuleInfo [name=" + name + ", uri=" + uri + ", sourceSupported=" + sourceSupported + ", targetSupported=" + targetSupported + ", moduleClass=" + moduleClass + ", constructor=" + constructor + ", formats=" + formats + ", packageNames=" + packageNames + "]"; } DefaultAtlasModuleInfo(String name, String uri, Class<AtlasModule> moduleClass, Constructor<AtlasModule> constructor,
List<String> formats, List<String> packageNames); @Override String getModuleClassName(); Constructor<AtlasModule> getConstructor(); List<String> getFormats(); @Override Class<AtlasModule> getModuleClass(); @Override String[] getDataFormats(); @Override String[] getPackageNames(); @Override String getName(); @Override String getUri(); @Override Boolean isSourceSupported(); @Override Boolean isTargetSupported(); @Override String getClassName(); @Override String getVersion(); @Override String toString(); }### Answer:
@Test public void testToString() { assertNotNull(module.toString()); } |
### Question:
PropertyModule extends BaseAtlasModule { @Override public void processPreValidation(AtlasInternalSession session) throws AtlasException { } PropertyModule(AtlasPropertyStrategy propertyStrategy); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override Boolean isSupportedField(Field field); @Override PropertyField cloneField(Field field); }### Answer:
@Test public void testProcessPreValidation() throws AtlasException { module.processPreValidation(null); } |
### Question:
PropertyModule extends BaseAtlasModule { @Override public void processPreSourceExecution(AtlasInternalSession session) throws AtlasException { } PropertyModule(AtlasPropertyStrategy propertyStrategy); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override Boolean isSupportedField(Field field); @Override PropertyField cloneField(Field field); }### Answer:
@Test public void testProcessPreSourceExecution() throws AtlasException { module.processPreSourceExecution(null); } |
### Question:
PropertyModule extends BaseAtlasModule { @Override public void processPostSourceExecution(AtlasInternalSession session) throws AtlasException { } PropertyModule(AtlasPropertyStrategy propertyStrategy); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override Boolean isSupportedField(Field field); @Override PropertyField cloneField(Field field); }### Answer:
@Test public void testProcessPostSourceExecution() throws AtlasException { module.processPostSourceExecution(null); } |
### Question:
PropertyModule extends BaseAtlasModule { @Override public void processPreTargetExecution(AtlasInternalSession session) throws AtlasException { } PropertyModule(AtlasPropertyStrategy propertyStrategy); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override Boolean isSupportedField(Field field); @Override PropertyField cloneField(Field field); }### Answer:
@Test public void testProcessPreTargetExecution() throws AtlasException { module.processPreTargetExecution(null); } |
### Question:
PropertyModule extends BaseAtlasModule { @Override public void writeTargetValue(AtlasInternalSession session) throws AtlasException { AtlasPropertyStrategy strategy = session.getAtlasPropertyStrategy() != null ? session.getAtlasPropertyStrategy() : this.defaultStrategy; Field targetField = session.head().getTargetField(); if (targetField instanceof PropertyField) { PropertyField targetPropertyField = (PropertyField)targetField; strategy.writeProperty(session, targetPropertyField); if (LOG.isDebugEnabled()) { LOG.debug("Processed target PropertyField: Name={} Value={} Strategy={}", targetPropertyField.getName(), targetPropertyField.getValue(), strategy.getClass().getName()); } } } PropertyModule(AtlasPropertyStrategy propertyStrategy); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override Boolean isSupportedField(Field field); @Override PropertyField cloneField(Field field); }### Answer:
@Test public void testProcessTargetFieldMapping() throws Exception { PropertyField field = mock(PropertyField.class); when(field.getName()).thenReturn("testProp"); when(field.getValue()).thenReturn("testValue"); Head head = mock(Head.class); when(head.getTargetField()).thenReturn(field); AtlasInternalSession session = mock(AtlasInternalSession.class); when(session.head()).thenReturn(head); Map<String, Object> targetProps = new HashMap<>(); when(session.getTargetProperties()).thenReturn(targetProps); DefaultAtlasConversionService atlasConversionService = mock(DefaultAtlasConversionService.class); when(atlasConversionService.fieldTypeFromClass(any(String.class))).thenReturn(FieldType.ANY); module.setConversionService(atlasConversionService); module.writeTargetValue(session); assertEquals("testValue", targetProps.get("testProp")); } |
### Question:
PropertyModule extends BaseAtlasModule { @Override public void processPostTargetExecution(AtlasInternalSession session) throws AtlasException { } PropertyModule(AtlasPropertyStrategy propertyStrategy); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override Boolean isSupportedField(Field field); @Override PropertyField cloneField(Field field); }### Answer:
@Test public void testProcessPostTargetExecution() throws AtlasException { module.processPostTargetExecution(null); } |
### Question:
PropertyModule extends BaseAtlasModule { @Override public void processPostValidation(AtlasInternalSession session) throws AtlasException { } PropertyModule(AtlasPropertyStrategy propertyStrategy); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override Boolean isSupportedField(Field field); @Override PropertyField cloneField(Field field); }### Answer:
@Test public void testProcessPostValidation() throws AtlasException { module.processPostValidation(null); } |
### Question:
PropertyModule extends BaseAtlasModule { @Override public Boolean isSupportedField(Field field) { return field instanceof PropertyField; } PropertyModule(AtlasPropertyStrategy propertyStrategy); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override Boolean isSupportedField(Field field); @Override PropertyField cloneField(Field field); }### Answer:
@Test public void testIsSupportedField() { assertFalse(module.isSupportedField(new MockField())); } |
### Question:
PropertyModule extends BaseAtlasModule { @Override public PropertyField cloneField(Field field) throws AtlasException { if (field == null || !(field instanceof PropertyField)) { return null; } PropertyField orig = (PropertyField)field; PropertyField clone = new PropertyField(); AtlasModelFactory.copyField(orig, clone, true); clone.setScope(orig.getScope()); return clone; } PropertyModule(AtlasPropertyStrategy propertyStrategy); @Override void processPreValidation(AtlasInternalSession session); @Override void processPreSourceExecution(AtlasInternalSession session); @Override void readSourceValue(AtlasInternalSession session); @Override void processPostSourceExecution(AtlasInternalSession session); @Override void processPreTargetExecution(AtlasInternalSession session); @Override void writeTargetValue(AtlasInternalSession session); @Override void processPostTargetExecution(AtlasInternalSession session); @Override void processPostValidation(AtlasInternalSession session); @Override Boolean isSupportedField(Field field); @Override PropertyField cloneField(Field field); }### Answer:
@Test public void testCloneField() throws AtlasException { assertNull(module.cloneField(new MockField())); } |
### Question:
AtlasModelFactory { public static AtlasMapping createAtlasMapping() { AtlasMapping mapping = new AtlasMapping(); mapping.setMappings(new Mappings()); mapping.setProperties(new Properties()); mapping.setLookupTables(new LookupTables()); return mapping; } private AtlasModelFactory(); @SuppressWarnings("unchecked") static T createMapping(MappingType type); static AtlasMapping createAtlasMapping(); static Collection createCollection(); static MockDocument createMockDocument(); static MockField createMockField(); static PropertyField createPropertyField(); static BaseMapping cloneMapping(BaseMapping baseMapping, boolean deepClone); static Field cloneField(Field f); static FieldGroup copyFieldGroup(FieldGroup fg); static SimpleField cloneFieldToSimpleField(Field field); static void copyField(Field from, Field to, boolean withActions); static FieldGroup createFieldGroupFrom(Field field, boolean withActions); static ArrayList<Action> cloneFieldActions(ArrayList<Action> actions); static Action cloneAction(Action action); static String toString(PropertyField f); static String toString(Field f); static Field wrapWithField(Object val); static Field wrapWithField(Object val, String parentPath); static Object unwrapField(Field f); static final String GENERATED_PATH; }### Answer:
@Test public void testCreateAtlasMapping() { AtlasMapping atlasMapping = AtlasModelFactory.createAtlasMapping(); assertNotNull(atlasMapping); } |
### Question:
AtlasModelFactory { public static ArrayList<Action> cloneFieldActions(ArrayList<Action> actions) { if (actions == null) { return null; } ArrayList<Action> n = new ArrayList<Action>(); if (actions == null || actions.isEmpty()) { return n; } for (Action a : actions) { n.add(cloneAction(a)); } return n; } private AtlasModelFactory(); @SuppressWarnings("unchecked") static T createMapping(MappingType type); static AtlasMapping createAtlasMapping(); static Collection createCollection(); static MockDocument createMockDocument(); static MockField createMockField(); static PropertyField createPropertyField(); static BaseMapping cloneMapping(BaseMapping baseMapping, boolean deepClone); static Field cloneField(Field f); static FieldGroup copyFieldGroup(FieldGroup fg); static SimpleField cloneFieldToSimpleField(Field field); static void copyField(Field from, Field to, boolean withActions); static FieldGroup createFieldGroupFrom(Field field, boolean withActions); static ArrayList<Action> cloneFieldActions(ArrayList<Action> actions); static Action cloneAction(Action action); static String toString(PropertyField f); static String toString(Field f); static Field wrapWithField(Object val); static Field wrapWithField(Object val, String parentPath); static Object unwrapField(Field f); static final String GENERATED_PATH; }### Answer:
@Test public void testCloneActions() { List<Action> actionsList = Arrays.asList(new Camelize(), new Capitalize(), new CurrentDate(), new CurrentDateTime(), new CurrentTime(), new CustomAction(), new GenerateUUID(), new Lowercase(), new LowercaseChar(), new PadStringLeft(), new PadStringRight(), new SeparateByDash(), new SeparateByUnderscore(), new Length(), new SubString(), new SubStringAfter(), new SubStringBefore(), new Trim(), new TrimLeft(), new TrimRight(), new Uppercase(), new UppercaseChar()); ArrayList<Action> actions = new ArrayList<Action>(); actions.addAll(actionsList); ArrayList<Action> clones = AtlasModelFactory.cloneFieldActions(actions); assertNotNull(clones); assertNotSame(actions, clones); } |
### Question:
StringComplexFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static String genareteUUID(GenerateUUID action) { return UUID.randomUUID().toString(); } @AtlasActionProcessor static String append(Append append, String input); @AtlasActionProcessor(sourceType = FieldType.ANY) static String concatenate(Concatenate concat, List<String> inputs); @AtlasActionProcessor static Boolean endsWith(EndsWith endsWith, String input); @AtlasActionProcessor static String format(Format format, List<Object> input); @AtlasActionProcessor static String genareteUUID(GenerateUUID action); @AtlasActionProcessor static Number indexOf(IndexOf indexOf, String input); @AtlasActionProcessor static Number lastIndexOf(LastIndexOf lastIndexOf, String input); @AtlasActionProcessor static String padStringRight(PadStringRight padStringRight, String input); @AtlasActionProcessor static String padStringLeft(PadStringLeft padStringLeft, String input); @AtlasActionProcessor static String prepend(Prepend action, String input); @AtlasActionProcessor static String replaceAll(ReplaceAll replaceAll, String input); @AtlasActionProcessor static String replaceFirst(ReplaceFirst replaceFirst, String input); @AtlasActionProcessor(sourceType = FieldType.ANY) static String[] split(Split split, String input); @AtlasActionProcessor(sourceType = FieldType.ANY) static String[] repeat(Repeat repeat, String input); @AtlasActionProcessor static Boolean startsWith(StartsWith startsWith, String input); @AtlasActionProcessor static String subString(SubString subString, String input); @AtlasActionProcessor static String subStringAfter(SubStringAfter subStringAfter, String input); @AtlasActionProcessor static String subStringBefore(SubStringBefore subStringBefore, String input); static final String STRING_SEPARATOR_REGEX; static final Pattern STRING_SEPARATOR_PATTERN; }### Answer:
@Test public void testGenareteUUID() { validateGeneratedUUID(StringComplexFieldActions.genareteUUID(new GenerateUUID())); } |
### Question:
AtlasModelFactory { public static Action cloneAction(Action action) { if (action == null) { return null; } try { ObjectMapper mapper = new ObjectMapper() .enable(MapperFeature.BLOCK_UNSAFE_POLYMORPHIC_BASE_TYPES); String s = mapper.writeValueAsString(action); System.out.println(s); return mapper.readerFor(Action.class).readValue(s); } catch (IOException e) { throw new RuntimeException(e); } } private AtlasModelFactory(); @SuppressWarnings("unchecked") static T createMapping(MappingType type); static AtlasMapping createAtlasMapping(); static Collection createCollection(); static MockDocument createMockDocument(); static MockField createMockField(); static PropertyField createPropertyField(); static BaseMapping cloneMapping(BaseMapping baseMapping, boolean deepClone); static Field cloneField(Field f); static FieldGroup copyFieldGroup(FieldGroup fg); static SimpleField cloneFieldToSimpleField(Field field); static void copyField(Field from, Field to, boolean withActions); static FieldGroup createFieldGroupFrom(Field field, boolean withActions); static ArrayList<Action> cloneFieldActions(ArrayList<Action> actions); static Action cloneAction(Action action); static String toString(PropertyField f); static String toString(Field f); static Field wrapWithField(Object val); static Field wrapWithField(Object val, String parentPath); static Object unwrapField(Field f); static final String GENERATED_PATH; }### Answer:
@Test public void testCloneAction() throws Exception { for (Action a : ModelTestUtil.getAllOOTBActions()) { assertNotNull(a); Action b = AtlasModelFactory.cloneAction((Action)a); assertNotNull(String.format("Add %s to AtlasModelFactory#cloneAction()", a.getClass().getSimpleName()), b); assertNotSame(a, b); assertEquals(a.getClass().getCanonicalName(), b.getClass().getCanonicalName()); } } |
### Question:
AtlasModelFactory { public static PropertyField createPropertyField() { return new PropertyField(); } private AtlasModelFactory(); @SuppressWarnings("unchecked") static T createMapping(MappingType type); static AtlasMapping createAtlasMapping(); static Collection createCollection(); static MockDocument createMockDocument(); static MockField createMockField(); static PropertyField createPropertyField(); static BaseMapping cloneMapping(BaseMapping baseMapping, boolean deepClone); static Field cloneField(Field f); static FieldGroup copyFieldGroup(FieldGroup fg); static SimpleField cloneFieldToSimpleField(Field field); static void copyField(Field from, Field to, boolean withActions); static FieldGroup createFieldGroupFrom(Field field, boolean withActions); static ArrayList<Action> cloneFieldActions(ArrayList<Action> actions); static Action cloneAction(Action action); static String toString(PropertyField f); static String toString(Field f); static Field wrapWithField(Object val); static Field wrapWithField(Object val, String parentPath); static Object unwrapField(Field f); static final String GENERATED_PATH; }### Answer:
@Test public void testCreatePropertyField() { PropertyField p = AtlasModelFactory.createPropertyField(); assertNotNull(p); assertNull(p.getActions()); } |
### Question:
AtlasModelFactory { public static Field cloneField(Field f) { throw new IllegalArgumentException("Use module specific factories to clone fields"); } private AtlasModelFactory(); @SuppressWarnings("unchecked") static T createMapping(MappingType type); static AtlasMapping createAtlasMapping(); static Collection createCollection(); static MockDocument createMockDocument(); static MockField createMockField(); static PropertyField createPropertyField(); static BaseMapping cloneMapping(BaseMapping baseMapping, boolean deepClone); static Field cloneField(Field f); static FieldGroup copyFieldGroup(FieldGroup fg); static SimpleField cloneFieldToSimpleField(Field field); static void copyField(Field from, Field to, boolean withActions); static FieldGroup createFieldGroupFrom(Field field, boolean withActions); static ArrayList<Action> cloneFieldActions(ArrayList<Action> actions); static Action cloneAction(Action action); static String toString(PropertyField f); static String toString(Field f); static Field wrapWithField(Object val); static Field wrapWithField(Object val, String parentPath); static Object unwrapField(Field f); static final String GENERATED_PATH; }### Answer:
@Test public void testCloneField() { PropertyField p = AtlasModelFactory.createPropertyField(); SimpleField s = AtlasModelFactory.cloneFieldToSimpleField(p); assertNotNull(s); } |
### Question:
DateFieldActions implements AtlasFieldAction { @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) public static ZonedDateTime addDays(AddDays addDays, ZonedDateTime input) { if (addDays == null) { throw new IllegalArgumentException("AddDays action must be specified"); } if (input == null) { return null; } return input.plusDays(addDays.getDays() == null ? 0L : addDays.getDays()); } @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addDays(AddDays addDays, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addSeconds(AddSeconds addSeconds, ZonedDateTime input); @AtlasActionProcessor static ZonedDateTime currentDate(CurrentDate action); @AtlasActionProcessor static ZonedDateTime currentDateTime(CurrentDateTime action); @AtlasActionProcessor static ZonedDateTime currentTime(CurrentTime action); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfMonth(DayOfMonth action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfWeek(DayOfWeek action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfYear(DayOfYear action, ZonedDateTime input); }### Answer:
@Test public void testAddDays() { AddDays action = new AddDays(); action.setDays(2); assertNull(DateFieldActions.addDays(action, null)); ZonedDateTime origDate = ZonedDateTime.now(); ZonedDateTime laterDate = origDate.plusDays(2); assertEquals(laterDate, DateFieldActions.addDays(action, origDate)); }
@Test(expected=IllegalArgumentException.class) public void testAddDaysWithNullAction() { DateFieldActions.addDays(null, ZonedDateTime.now()); } |
### Question:
DateFieldActions implements AtlasFieldAction { @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) public static ZonedDateTime addSeconds(AddSeconds addSeconds, ZonedDateTime input) { if (addSeconds == null) { throw new IllegalArgumentException("AddSeconds action must be specified"); } if (input == null) { return null; } return input.plusSeconds(addSeconds.getSeconds() == null ? 0L : addSeconds.getSeconds()); } @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addDays(AddDays addDays, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addSeconds(AddSeconds addSeconds, ZonedDateTime input); @AtlasActionProcessor static ZonedDateTime currentDate(CurrentDate action); @AtlasActionProcessor static ZonedDateTime currentDateTime(CurrentDateTime action); @AtlasActionProcessor static ZonedDateTime currentTime(CurrentTime action); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfMonth(DayOfMonth action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfWeek(DayOfWeek action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfYear(DayOfYear action, ZonedDateTime input); }### Answer:
@Test public void testAddSeconds() { AddSeconds action = new AddSeconds(); action.setSeconds(2); assertNull(DateFieldActions.addSeconds(action, null)); ZonedDateTime origDate = ZonedDateTime.now(); ZonedDateTime laterDate = origDate.plusSeconds(2); assertEquals(laterDate, DateFieldActions.addSeconds(action, origDate)); }
@Test(expected=IllegalArgumentException.class) public void testAddSecondsWithNullAction() { DateFieldActions.addSeconds(null, ZonedDateTime.now()); } |
### Question:
DateFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static ZonedDateTime currentDate(CurrentDate action) { return LocalDate.now().atStartOfDay(ZoneId.systemDefault()); } @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addDays(AddDays addDays, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addSeconds(AddSeconds addSeconds, ZonedDateTime input); @AtlasActionProcessor static ZonedDateTime currentDate(CurrentDate action); @AtlasActionProcessor static ZonedDateTime currentDateTime(CurrentDateTime action); @AtlasActionProcessor static ZonedDateTime currentTime(CurrentTime action); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfMonth(DayOfMonth action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfWeek(DayOfWeek action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfYear(DayOfYear action, ZonedDateTime input); }### Answer:
@Test public void testCurrentDate() { assertNotNull(DateFieldActions.currentDate(null)); } |
### Question:
DateFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static ZonedDateTime currentDateTime(CurrentDateTime action) { return LocalDate.now().atStartOfDay(ZoneId.systemDefault()); } @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addDays(AddDays addDays, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addSeconds(AddSeconds addSeconds, ZonedDateTime input); @AtlasActionProcessor static ZonedDateTime currentDate(CurrentDate action); @AtlasActionProcessor static ZonedDateTime currentDateTime(CurrentDateTime action); @AtlasActionProcessor static ZonedDateTime currentTime(CurrentTime action); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfMonth(DayOfMonth action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfWeek(DayOfWeek action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfYear(DayOfYear action, ZonedDateTime input); }### Answer:
@Test public void testCurrentDateTime() { assertNotNull(DateFieldActions.currentDateTime(null)); } |
### Question:
AtlasModelFactory { public static String toString(PropertyField f) { StringBuilder tmp = new StringBuilder("PropertyField [name="); if (f != null && f.getName() != null) { tmp.append(f.getName()); } tmp.append(baseFieldToString(f)); tmp.append("]"); return tmp.toString(); } private AtlasModelFactory(); @SuppressWarnings("unchecked") static T createMapping(MappingType type); static AtlasMapping createAtlasMapping(); static Collection createCollection(); static MockDocument createMockDocument(); static MockField createMockField(); static PropertyField createPropertyField(); static BaseMapping cloneMapping(BaseMapping baseMapping, boolean deepClone); static Field cloneField(Field f); static FieldGroup copyFieldGroup(FieldGroup fg); static SimpleField cloneFieldToSimpleField(Field field); static void copyField(Field from, Field to, boolean withActions); static FieldGroup createFieldGroupFrom(Field field, boolean withActions); static ArrayList<Action> cloneFieldActions(ArrayList<Action> actions); static Action cloneAction(Action action); static String toString(PropertyField f); static String toString(Field f); static Field wrapWithField(Object val); static Field wrapWithField(Object val, String parentPath); static Object unwrapField(Field f); static final String GENERATED_PATH; }### Answer:
@Test public void testSimpleFieldToString() { SimpleField s = new SimpleField(); System.out.println(AtlasModelFactory.toString(s)); } |
### Question:
DateFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static ZonedDateTime currentTime(CurrentTime action) { return LocalTime.now().atDate(LocalDate.now()).atZone(ZoneId.systemDefault()); } @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addDays(AddDays addDays, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addSeconds(AddSeconds addSeconds, ZonedDateTime input); @AtlasActionProcessor static ZonedDateTime currentDate(CurrentDate action); @AtlasActionProcessor static ZonedDateTime currentDateTime(CurrentDateTime action); @AtlasActionProcessor static ZonedDateTime currentTime(CurrentTime action); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfMonth(DayOfMonth action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfWeek(DayOfWeek action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfYear(DayOfYear action, ZonedDateTime input); }### Answer:
@Test public void testCurrentTime() { assertNotNull(DateFieldActions.currentTime(null)); } |
### Question:
DateFieldActions implements AtlasFieldAction { @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) public static Integer dayOfMonth(DayOfMonth action, ZonedDateTime input) { return input == null ? null : input.getDayOfMonth(); } @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addDays(AddDays addDays, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addSeconds(AddSeconds addSeconds, ZonedDateTime input); @AtlasActionProcessor static ZonedDateTime currentDate(CurrentDate action); @AtlasActionProcessor static ZonedDateTime currentDateTime(CurrentDateTime action); @AtlasActionProcessor static ZonedDateTime currentTime(CurrentTime action); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfMonth(DayOfMonth action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfWeek(DayOfWeek action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfYear(DayOfYear action, ZonedDateTime input); }### Answer:
@Test public void testDayOfMonth() { assertNull(DateFieldActions.dayOfMonth(null, null)); ZonedDateTime origDate = LocalDate.of(2018, 10, 3).atStartOfDay(ZoneId.systemDefault()); assertEquals(Integer.valueOf(3), DateFieldActions.dayOfMonth(null, origDate)); } |
### Question:
DateFieldActions implements AtlasFieldAction { @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) public static Integer dayOfWeek(DayOfWeek action, ZonedDateTime input) { return input == null ? null : input.getDayOfWeek().getValue(); } @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addDays(AddDays addDays, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addSeconds(AddSeconds addSeconds, ZonedDateTime input); @AtlasActionProcessor static ZonedDateTime currentDate(CurrentDate action); @AtlasActionProcessor static ZonedDateTime currentDateTime(CurrentDateTime action); @AtlasActionProcessor static ZonedDateTime currentTime(CurrentTime action); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfMonth(DayOfMonth action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfWeek(DayOfWeek action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfYear(DayOfYear action, ZonedDateTime input); }### Answer:
@Test public void testDayOfWeek() { assertNull(DateFieldActions.dayOfWeek(null, null)); ZonedDateTime origDate = LocalDate.of(2017, 12, 14).atStartOfDay(ZoneId.systemDefault()); assertEquals(Integer.valueOf(4), DateFieldActions.dayOfWeek(null, origDate)); } |
### Question:
DateFieldActions implements AtlasFieldAction { @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) public static Integer dayOfYear(DayOfYear action, ZonedDateTime input) { return input == null ? null : input.getDayOfYear(); } @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addDays(AddDays addDays, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static ZonedDateTime addSeconds(AddSeconds addSeconds, ZonedDateTime input); @AtlasActionProcessor static ZonedDateTime currentDate(CurrentDate action); @AtlasActionProcessor static ZonedDateTime currentDateTime(CurrentDateTime action); @AtlasActionProcessor static ZonedDateTime currentTime(CurrentTime action); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfMonth(DayOfMonth action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfWeek(DayOfWeek action, ZonedDateTime input); @AtlasActionProcessor(sourceType = FieldType.ANY_DATE) static Integer dayOfYear(DayOfYear action, ZonedDateTime input); }### Answer:
@Test public void testDayOfYear() { assertNull(DateFieldActions.dayOfYear(null, null)); ZonedDateTime origDate = LocalDate.of(2017, 12, 31).atStartOfDay(ZoneId.systemDefault()); assertEquals(Integer.valueOf(365), DateFieldActions.dayOfYear(null, origDate)); } |
### Question:
ObjectFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static Integer count(Count action, List<Object> inputs) { if (inputs == null) { return 0; } return inputs.size(); } @AtlasActionProcessor static Integer count(Count action, List<Object> inputs); @AtlasActionProcessor static Boolean contains(Contains contains, List<Object> inputs); @AtlasActionProcessor static Boolean equals(Equals equals, Object input); @AtlasActionProcessor static Boolean isNull(IsNull action, Object input); @AtlasActionProcessor static Object itemAt(ItemAt itemAt, List<Object> inputs); @AtlasActionProcessor static Integer length(Length length, Object input); }### Answer:
@Test public void testCount() { assertEquals(new Integer(0), ObjectFieldActions.count(new Count(), new ArrayList<>())); Object[] array = new Object[] {false, "foo", 2}; assertEquals(new Integer(3), ObjectFieldActions.count(new Count(), Arrays.asList(array))); } |
### Question:
ObjectFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static Boolean contains(Contains contains, List<Object> inputs) { if (contains == null) { throw new IllegalArgumentException("Contains action must be specified"); } if (inputs == null) { return contains.getValue() == null; } return collectionContains(inputs, contains); } @AtlasActionProcessor static Integer count(Count action, List<Object> inputs); @AtlasActionProcessor static Boolean contains(Contains contains, List<Object> inputs); @AtlasActionProcessor static Boolean equals(Equals equals, Object input); @AtlasActionProcessor static Boolean isNull(IsNull action, Object input); @AtlasActionProcessor static Object itemAt(ItemAt itemAt, List<Object> inputs); @AtlasActionProcessor static Integer length(Length length, Object input); }### Answer:
@Test public void testContains() { Contains action = new Contains(); assertTrue(ObjectFieldActions.contains(action, null)); assertFalse(ObjectFieldActions.contains(action, Arrays.asList(new Object[] {""}))); Object[] array = new Object[] {false, "foo", 2}; Object[] arrayWithNull = new Object[] {false, null, "foo", 2}; assertFalse(ObjectFieldActions.contains(action, Arrays.asList(array))); assertTrue(ObjectFieldActions.contains(action, Arrays.asList(arrayWithNull))); action.setValue("foo"); assertFalse(ObjectFieldActions.contains(action, null)); assertFalse(ObjectFieldActions.contains(action, Arrays.asList(new Object[] {""}))); assertFalse(ObjectFieldActions.contains(action, Arrays.asList(new Object[] {"foobar"}))); assertTrue(ObjectFieldActions.contains(action, Arrays.asList(array))); }
@Test(expected=IllegalArgumentException.class) public void testContainsWithNullAction() { ObjectFieldActions.contains(null, Arrays.asList(new Object[] {""})); } |
### Question:
ObjectFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static Boolean equals(Equals equals, Object input) { if (equals == null) { throw new IllegalArgumentException("Equals action must be specified"); } if (input == null) { return equals.getValue() == null; } return input.toString().equals(equals.getValue()); } @AtlasActionProcessor static Integer count(Count action, List<Object> inputs); @AtlasActionProcessor static Boolean contains(Contains contains, List<Object> inputs); @AtlasActionProcessor static Boolean equals(Equals equals, Object input); @AtlasActionProcessor static Boolean isNull(IsNull action, Object input); @AtlasActionProcessor static Object itemAt(ItemAt itemAt, List<Object> inputs); @AtlasActionProcessor static Integer length(Length length, Object input); }### Answer:
@Test public void testEquals() { Equals action = new Equals(); assertTrue(ObjectFieldActions.equals(action, null)); action.setValue("6"); assertFalse(ObjectFieldActions.equals(action, 169)); action.setValue("169"); assertTrue(ObjectFieldActions.equals(action, 169)); action.setValue("ru"); assertFalse(ObjectFieldActions.equals(action, true)); action.setValue("true"); assertTrue(ObjectFieldActions.equals(action, true)); action.setValue("b"); assertFalse(ObjectFieldActions.equals(action, 'a')); action.setValue("a"); assertTrue(ObjectFieldActions.equals(action, 'a')); }
@Test(expected=IllegalArgumentException.class) public void testEqualsWithNullAction() { ObjectFieldActions.equals(null, ""); } |
### Question:
ObjectFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static Boolean isNull(IsNull action, Object input) { return input == null; } @AtlasActionProcessor static Integer count(Count action, List<Object> inputs); @AtlasActionProcessor static Boolean contains(Contains contains, List<Object> inputs); @AtlasActionProcessor static Boolean equals(Equals equals, Object input); @AtlasActionProcessor static Boolean isNull(IsNull action, Object input); @AtlasActionProcessor static Object itemAt(ItemAt itemAt, List<Object> inputs); @AtlasActionProcessor static Integer length(Length length, Object input); }### Answer:
@Test public void testIsNull() { assertTrue(ObjectFieldActions.isNull(null, null)); assertFalse(ObjectFieldActions.isNull(null, "")); assertFalse(ObjectFieldActions.isNull(null, new Object[0])); } |
### Question:
ObjectFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static Object itemAt(ItemAt itemAt, List<Object> inputs) { if (inputs == null) { return null; } Integer index = itemAt.getIndex() == null ? 0 : itemAt.getIndex(); Object[] array = inputs.toArray(new Object[0]); if (array.length > index) { return array[index]; } else { throw new ArrayIndexOutOfBoundsException(String.format( "Collection '%s' has fewer (%s) than expected (%s)", array, array.length, index)); } } @AtlasActionProcessor static Integer count(Count action, List<Object> inputs); @AtlasActionProcessor static Boolean contains(Contains contains, List<Object> inputs); @AtlasActionProcessor static Boolean equals(Equals equals, Object input); @AtlasActionProcessor static Boolean isNull(IsNull action, Object input); @AtlasActionProcessor static Object itemAt(ItemAt itemAt, List<Object> inputs); @AtlasActionProcessor static Integer length(Length length, Object input); }### Answer:
@Test public void testItemAt() { ItemAt action = new ItemAt(); action.setIndex(0); assertEquals("one", ObjectFieldActions.itemAt(action, Arrays.asList(new Object[] {"one", "two"}))); action.setIndex(1); assertEquals("two", ObjectFieldActions.itemAt(action, Arrays.asList(new Object[] {"one", "two"}))); }
@Test(expected = ArrayIndexOutOfBoundsException.class) public void testItemAtOutOfBounds() { ItemAt action = new ItemAt(); action.setIndex(2); ObjectFieldActions.itemAt(action, Arrays.asList(new Object[] {"one", "two"})); } |
### Question:
ObjectFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static Integer length(Length length, Object input) { if (input == null) { return -1; } return input.toString().length(); } @AtlasActionProcessor static Integer count(Count action, List<Object> inputs); @AtlasActionProcessor static Boolean contains(Contains contains, List<Object> inputs); @AtlasActionProcessor static Boolean equals(Equals equals, Object input); @AtlasActionProcessor static Boolean isNull(IsNull action, Object input); @AtlasActionProcessor static Object itemAt(ItemAt itemAt, List<Object> inputs); @AtlasActionProcessor static Integer length(Length length, Object input); }### Answer:
@Test public void testLength() { assertEquals(new Integer(-1), ObjectFieldActions.length(new Length(), null)); assertEquals(new Integer(0), ObjectFieldActions.length(new Length(), "")); assertEquals(new Integer(5), ObjectFieldActions.length(new Length(), " foo ")); assertEquals(new Integer(4), ObjectFieldActions.length(new Length(), true)); assertEquals(new Integer(3), ObjectFieldActions.length(new Length(), 169)); } |
### Question:
StringSimpleFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static String fileExtension(FileExtension action, String input) { if (input == null) { return null; } int ndx = input.lastIndexOf('.'); return ndx < 0 ? null : input.substring(ndx + 1); } @AtlasActionProcessor static String capitalize(Capitalize action, String input); @AtlasActionProcessor static String fileExtension(FileExtension action, String input); @AtlasActionProcessor static String lowercase(Lowercase action, String input); @AtlasActionProcessor static Character lowercaseChar(LowercaseChar action, Character input); @AtlasActionProcessor static String normalize(Normalize action, String input); @AtlasActionProcessor static String removeFileExtension(RemoveFileExtension action, String input); @AtlasActionProcessor static String separateByDash(SeparateByDash action, String input); @AtlasActionProcessor static String separateByUnderscore(SeparateByUnderscore action, String input); @AtlasActionProcessor static String trim(Trim action, String input); @AtlasActionProcessor static String trimLeft(TrimLeft action, String input); @AtlasActionProcessor static String trimRight(TrimRight action, String input); @AtlasActionProcessor static String uppercase(Uppercase action, String input); @AtlasActionProcessor static Character uppercaseChar(UppercaseChar action, Character input); static final String STRING_SEPARATOR_REGEX; static final Pattern STRING_SEPARATOR_PATTERN; }### Answer:
@Test public void testFileExtension() { assertNull(StringSimpleFieldActions.fileExtension(null, null)); assertNull(StringSimpleFieldActions.fileExtension(null, "")); assertNull(StringSimpleFieldActions.fileExtension(null, "foo")); assertEquals("", StringSimpleFieldActions.fileExtension(null, ".")); assertEquals("", StringSimpleFieldActions.fileExtension(null, "foo.")); assertEquals("bar", StringSimpleFieldActions.fileExtension(null, "foo.bar")); assertEquals("bar", StringSimpleFieldActions.fileExtension(null, "foo.foo.bar")); } |
### Question:
StringSimpleFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static String lowercase(Lowercase action, String input) { if (input == null) { return null; } return input.toLowerCase(); } @AtlasActionProcessor static String capitalize(Capitalize action, String input); @AtlasActionProcessor static String fileExtension(FileExtension action, String input); @AtlasActionProcessor static String lowercase(Lowercase action, String input); @AtlasActionProcessor static Character lowercaseChar(LowercaseChar action, Character input); @AtlasActionProcessor static String normalize(Normalize action, String input); @AtlasActionProcessor static String removeFileExtension(RemoveFileExtension action, String input); @AtlasActionProcessor static String separateByDash(SeparateByDash action, String input); @AtlasActionProcessor static String separateByUnderscore(SeparateByUnderscore action, String input); @AtlasActionProcessor static String trim(Trim action, String input); @AtlasActionProcessor static String trimLeft(TrimLeft action, String input); @AtlasActionProcessor static String trimRight(TrimRight action, String input); @AtlasActionProcessor static String uppercase(Uppercase action, String input); @AtlasActionProcessor static Character uppercaseChar(UppercaseChar action, Character input); static final String STRING_SEPARATOR_REGEX; static final Pattern STRING_SEPARATOR_PATTERN; }### Answer:
@Test public void testLowerCase() { assertNull(StringSimpleFieldActions.lowercase(new Lowercase(), null)); assertEquals("", StringSimpleFieldActions.lowercase(new Lowercase(), "")); assertEquals("foo", StringSimpleFieldActions.lowercase(new Lowercase(), "foo")); assertEquals("foo", StringSimpleFieldActions.lowercase(new Lowercase(), "Foo")); assertEquals("foo", StringSimpleFieldActions.lowercase(new Lowercase(), "fOo")); assertEquals("foo", StringSimpleFieldActions.lowercase(new Lowercase(), "foO")); assertEquals("foo", StringSimpleFieldActions.lowercase(new Lowercase(), "FOO")); assertEquals("foo bar", StringSimpleFieldActions.lowercase(new Lowercase(), "FOO BAR")); } |
### Question:
StringSimpleFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static Character lowercaseChar(LowercaseChar action, Character input) { if (input == null) { return null; } return String.valueOf(input).toLowerCase().charAt(0); } @AtlasActionProcessor static String capitalize(Capitalize action, String input); @AtlasActionProcessor static String fileExtension(FileExtension action, String input); @AtlasActionProcessor static String lowercase(Lowercase action, String input); @AtlasActionProcessor static Character lowercaseChar(LowercaseChar action, Character input); @AtlasActionProcessor static String normalize(Normalize action, String input); @AtlasActionProcessor static String removeFileExtension(RemoveFileExtension action, String input); @AtlasActionProcessor static String separateByDash(SeparateByDash action, String input); @AtlasActionProcessor static String separateByUnderscore(SeparateByUnderscore action, String input); @AtlasActionProcessor static String trim(Trim action, String input); @AtlasActionProcessor static String trimLeft(TrimLeft action, String input); @AtlasActionProcessor static String trimRight(TrimRight action, String input); @AtlasActionProcessor static String uppercase(Uppercase action, String input); @AtlasActionProcessor static Character uppercaseChar(UppercaseChar action, Character input); static final String STRING_SEPARATOR_REGEX; static final Pattern STRING_SEPARATOR_PATTERN; }### Answer:
@Test public void testLowerCaseChar() { assertNull(StringSimpleFieldActions.lowercaseChar(new LowercaseChar(), null)); assertEquals('\0', StringSimpleFieldActions.lowercaseChar(new LowercaseChar(), '\0').charValue()); assertEquals('f', StringSimpleFieldActions.lowercaseChar(new LowercaseChar(), 'f').charValue()); assertEquals('f', StringSimpleFieldActions.lowercaseChar(new LowercaseChar(), 'F').charValue()); } |
### Question:
StringSimpleFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static String removeFileExtension(RemoveFileExtension action, String input) { if (input == null) { return null; } int ndx = input.lastIndexOf('.'); return ndx < 0 ? input : input.substring(0, ndx); } @AtlasActionProcessor static String capitalize(Capitalize action, String input); @AtlasActionProcessor static String fileExtension(FileExtension action, String input); @AtlasActionProcessor static String lowercase(Lowercase action, String input); @AtlasActionProcessor static Character lowercaseChar(LowercaseChar action, Character input); @AtlasActionProcessor static String normalize(Normalize action, String input); @AtlasActionProcessor static String removeFileExtension(RemoveFileExtension action, String input); @AtlasActionProcessor static String separateByDash(SeparateByDash action, String input); @AtlasActionProcessor static String separateByUnderscore(SeparateByUnderscore action, String input); @AtlasActionProcessor static String trim(Trim action, String input); @AtlasActionProcessor static String trimLeft(TrimLeft action, String input); @AtlasActionProcessor static String trimRight(TrimRight action, String input); @AtlasActionProcessor static String uppercase(Uppercase action, String input); @AtlasActionProcessor static Character uppercaseChar(UppercaseChar action, Character input); static final String STRING_SEPARATOR_REGEX; static final Pattern STRING_SEPARATOR_PATTERN; }### Answer:
@Test public void testRemoveFileExtension() { assertNull(StringSimpleFieldActions.removeFileExtension(null, null)); assertEquals("", StringSimpleFieldActions.removeFileExtension(null, "")); assertEquals("foo", StringSimpleFieldActions.removeFileExtension(null, "foo")); assertEquals("", StringSimpleFieldActions.removeFileExtension(null, ".")); assertEquals("foo", StringSimpleFieldActions.removeFileExtension(null, "foo.")); assertEquals("foo", StringSimpleFieldActions.removeFileExtension(null, "foo.bar")); assertEquals("foo.foo", StringSimpleFieldActions.removeFileExtension(null, "foo.foo.bar")); } |
### Question:
StringSimpleFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static String trim(Trim action, String input) { if (input == null || input.length() == 0) { return input; } return input.trim(); } @AtlasActionProcessor static String capitalize(Capitalize action, String input); @AtlasActionProcessor static String fileExtension(FileExtension action, String input); @AtlasActionProcessor static String lowercase(Lowercase action, String input); @AtlasActionProcessor static Character lowercaseChar(LowercaseChar action, Character input); @AtlasActionProcessor static String normalize(Normalize action, String input); @AtlasActionProcessor static String removeFileExtension(RemoveFileExtension action, String input); @AtlasActionProcessor static String separateByDash(SeparateByDash action, String input); @AtlasActionProcessor static String separateByUnderscore(SeparateByUnderscore action, String input); @AtlasActionProcessor static String trim(Trim action, String input); @AtlasActionProcessor static String trimLeft(TrimLeft action, String input); @AtlasActionProcessor static String trimRight(TrimRight action, String input); @AtlasActionProcessor static String uppercase(Uppercase action, String input); @AtlasActionProcessor static Character uppercaseChar(UppercaseChar action, Character input); static final String STRING_SEPARATOR_REGEX; static final Pattern STRING_SEPARATOR_PATTERN; }### Answer:
@Test public void testTrim() { assertNull(StringSimpleFieldActions.trim(new Trim(), null)); assertEquals("", StringSimpleFieldActions.trim(new Trim(), "")); assertEquals("foo", StringSimpleFieldActions.trim(new Trim(), " foo ")); assertEquals("Foo", StringSimpleFieldActions.trim(new Trim(), " Foo")); assertEquals("fOo", StringSimpleFieldActions.trim(new Trim(), "fOo ")); assertEquals("foO", StringSimpleFieldActions.trim(new Trim(), " foO ")); assertEquals("FOO", StringSimpleFieldActions.trim(new Trim(), "\t\n FOO")); assertEquals("FOO", StringSimpleFieldActions.trim(new Trim(), "\t\n FOO\f\r")); } |
### Question:
StringSimpleFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static String uppercase(Uppercase action, String input) { if (input == null) { return null; } return input.toUpperCase(); } @AtlasActionProcessor static String capitalize(Capitalize action, String input); @AtlasActionProcessor static String fileExtension(FileExtension action, String input); @AtlasActionProcessor static String lowercase(Lowercase action, String input); @AtlasActionProcessor static Character lowercaseChar(LowercaseChar action, Character input); @AtlasActionProcessor static String normalize(Normalize action, String input); @AtlasActionProcessor static String removeFileExtension(RemoveFileExtension action, String input); @AtlasActionProcessor static String separateByDash(SeparateByDash action, String input); @AtlasActionProcessor static String separateByUnderscore(SeparateByUnderscore action, String input); @AtlasActionProcessor static String trim(Trim action, String input); @AtlasActionProcessor static String trimLeft(TrimLeft action, String input); @AtlasActionProcessor static String trimRight(TrimRight action, String input); @AtlasActionProcessor static String uppercase(Uppercase action, String input); @AtlasActionProcessor static Character uppercaseChar(UppercaseChar action, Character input); static final String STRING_SEPARATOR_REGEX; static final Pattern STRING_SEPARATOR_PATTERN; }### Answer:
@Test public void testUpperCase() { assertNull(StringSimpleFieldActions.uppercase(new Uppercase(), null)); assertEquals("", StringSimpleFieldActions.uppercase(new Uppercase(), "")); assertEquals("FOO", StringSimpleFieldActions.uppercase(new Uppercase(), "foo")); assertEquals("FOO", StringSimpleFieldActions.uppercase(new Uppercase(), "Foo")); assertEquals("FOO", StringSimpleFieldActions.uppercase(new Uppercase(), "fOo")); assertEquals("FOO", StringSimpleFieldActions.uppercase(new Uppercase(), "foO")); assertEquals("FOO", StringSimpleFieldActions.uppercase(new Uppercase(), "FOO")); assertEquals("FOO BAR", StringSimpleFieldActions.uppercase(new Uppercase(), "foo bar")); } |
### Question:
StringSimpleFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static Character uppercaseChar(UppercaseChar action, Character input) { if (input == null) { return null; } return String.valueOf(input).toUpperCase().charAt(0); } @AtlasActionProcessor static String capitalize(Capitalize action, String input); @AtlasActionProcessor static String fileExtension(FileExtension action, String input); @AtlasActionProcessor static String lowercase(Lowercase action, String input); @AtlasActionProcessor static Character lowercaseChar(LowercaseChar action, Character input); @AtlasActionProcessor static String normalize(Normalize action, String input); @AtlasActionProcessor static String removeFileExtension(RemoveFileExtension action, String input); @AtlasActionProcessor static String separateByDash(SeparateByDash action, String input); @AtlasActionProcessor static String separateByUnderscore(SeparateByUnderscore action, String input); @AtlasActionProcessor static String trim(Trim action, String input); @AtlasActionProcessor static String trimLeft(TrimLeft action, String input); @AtlasActionProcessor static String trimRight(TrimRight action, String input); @AtlasActionProcessor static String uppercase(Uppercase action, String input); @AtlasActionProcessor static Character uppercaseChar(UppercaseChar action, Character input); static final String STRING_SEPARATOR_REGEX; static final Pattern STRING_SEPARATOR_PATTERN; }### Answer:
@Test public void testUpperCaseChar() { assertNull(StringSimpleFieldActions.uppercaseChar(new UppercaseChar(), null)); assertEquals('\0', StringSimpleFieldActions.uppercaseChar(new UppercaseChar(), '\0').charValue()); assertEquals('F', StringSimpleFieldActions.uppercaseChar(new UppercaseChar(), 'f').charValue()); assertEquals('F', StringSimpleFieldActions.uppercaseChar(new UppercaseChar(), 'F').charValue()); } |
### Question:
NumberFieldActions implements AtlasFieldAction { @AtlasActionProcessor public static Number average(Average action, List<Number> inputs) { if (inputs == null) { return 0; } return add(null, inputs).doubleValue() / inputs.size(); } @AtlasActionProcessor static Number absoluteValue(AbsoluteValue action, Number input); @AtlasActionProcessor static Number add(Add action, List<Number> inputs); @AtlasActionProcessor static Number average(Average action, List<Number> inputs); @AtlasActionProcessor static Number ceiling(Ceiling action, Number input); @AtlasActionProcessor static Number convertMassUnit(ConvertMassUnit convertMassUnit, Number input); @AtlasActionProcessor static Number convertDistanceUnit(ConvertDistanceUnit convertDistanceUnit, Number input); @AtlasActionProcessor static Number convertAreaUnit(ConvertAreaUnit convertAreaUnit, Number input); @AtlasActionProcessor static Number convertVolumeUnit(ConvertVolumeUnit convertVolumeUnit, Number input); @AtlasActionProcessor static Number divide(Divide divide, List<Number> inputs); @AtlasActionProcessor static Number floor(Floor floor, Number input); @AtlasActionProcessor static Number maximum(Maximum maximum, List<Number> inputs); @AtlasActionProcessor static Number minimum(Minimum minimum, List<Number> inputs); @AtlasActionProcessor static Number multiply(Multiply multiply, List<Number> inputs); @AtlasActionProcessor static Number round(Round action, Number input); @AtlasActionProcessor static Number subtract(Subtract subtract, List<Number> inputs); }### Answer:
@Test public void testAverage() { assertEquals(2.5, NumberFieldActions.average(new Average(), Arrays.asList(1.0, 2.0, 3.0, 4.0))); assertEquals(2.5, NumberFieldActions.average(new Average(), Arrays.asList(1, 2, 3, 4))); assertEquals(0, NumberFieldActions.average(new Average(), null)); } |
### Question:
CalendarConverter implements AtlasConverter<Calendar> { @AtlasConversionInfo(sourceType = FieldType.DATE_TIME_TZ, targetType = FieldType.DATE_TIME) public Date toDate(Calendar calendar) { return calendar != null ? calendar.getTime() : null; } @AtlasConversionInfo(sourceType = FieldType.DATE_TIME_TZ, targetType = FieldType.DATE_TIME) Date toDate(Calendar calendar); @AtlasConversionInfo(sourceType = FieldType.DATE_TIME_TZ, targetType = FieldType.DATE_TIME_TZ) ZonedDateTime toZonedDateTime(Calendar calendar); }### Answer:
@Test public void toDate() { Date date = converter.toDate(Calendar.getInstance()); assertNotNull(date); } |
### Question:
CalendarConverter implements AtlasConverter<Calendar> { @AtlasConversionInfo(sourceType = FieldType.DATE_TIME_TZ, targetType = FieldType.DATE_TIME_TZ) public ZonedDateTime toZonedDateTime(Calendar calendar) { return calendar == null ? null : DateTimeHelper.toZonedDateTime(calendar); } @AtlasConversionInfo(sourceType = FieldType.DATE_TIME_TZ, targetType = FieldType.DATE_TIME) Date toDate(Calendar calendar); @AtlasConversionInfo(sourceType = FieldType.DATE_TIME_TZ, targetType = FieldType.DATE_TIME_TZ) ZonedDateTime toZonedDateTime(Calendar calendar); }### Answer:
@Test public void toZonedDateTime() { ZonedDateTime date = converter.toZonedDateTime(Calendar.getInstance()); assertNotNull(date); } |
### Question:
ExponentialFeeItemsAlgorithm implements FeeItemsAlgorithm { @Override public int getMinPosition() { return minPosition; } ExponentialFeeItemsAlgorithm(long minValue, int minPosition, long maxValue, int maxPosition); @Override long computeValue(int position); @Override int getMinPosition(); @Override int getMaxPosition(); }### Answer:
@Test public void getMinPosition() throws Exception { assertEquals(MIN_POSITION, algorithm.getMinPosition()); } |
### Question:
ExponentialFeeItemsAlgorithm implements FeeItemsAlgorithm { @Override public int getMaxPosition() { return maxPosition; } ExponentialFeeItemsAlgorithm(long minValue, int minPosition, long maxValue, int maxPosition); @Override long computeValue(int position); @Override int getMinPosition(); @Override int getMaxPosition(); }### Answer:
@Test public void getMaxPosition() throws Exception { assertEquals(MAX_POSITION, algorithm.getMaxPosition()); } |
### Question:
MerkleTree { public static MerkleTree fromData(byte[] data){ return fromData(data, DEFAULT_CHUNK_SIZE); } MerkleTree(Sha256Hash root, ArrayList<byte[]> chunks); static MerkleTree fromData(byte[] data); static MerkleTree fromData(byte[] data, int chunkSize); Sha256Hash getRoot(); ArrayList<byte[]> getChunks(); @Override boolean equals(Object o); @Override int hashCode(); static final int DEFAULT_CHUNK_SIZE; }### Answer:
@Test public void testFromData() throws Exception { byte[] cipherText = HexUtils.toBytes("5edbaade9ba4ed528a8de36c95ece996189dedf4756fba2599f94b4f370d7013" + "66e2f0ba4e59111c0787708cf4b0b82de558b4d8bf5d90b3512f09814d605d4c" + "14f2f85b596211f83918c31c4bef19ea"); MerkleTree merkleTree = MerkleTree.fromData(cipherText); assertEquals("Merkle root", "9e913cd60f7df551b3baa320602bfba78489921d661362a64a03550a45add008", merkleTree.getRoot().toHex()); } |
### Question:
HexUtils { public static String toHex(byte[] bytes) { return toHex(bytes, null); } static String toHex(byte[] bytes); static String toHex(byte[] bytes, String separator); static String toHex(byte[] bytes, int offset, int length); static String toHex(byte b); static String toHex(byte[] bytes, int offset, int length, String separator); static byte[] toBytes(String hexString); static void appendByteAsHex(StringBuilder sb, byte b); static boolean isAllZero(byte[] bytes); }### Answer:
@Test public void toHex() throws Exception { for(byte[] bytes : bytess) { String hex = new String(Hex.encode(bytes)); assertEquals(hex, HexUtils.toHex(bytes)); } } |
### Question:
HexUtils { public static byte[] toBytes(String hexString) { if(hexString != null) { hexString = hexString.replace(" ", ""); } if (hexString == null || hexString.length() % 2 != 0) { throw new RuntimeException("Input string must contain an even number of characters"); } char[] hex = hexString.toCharArray(); int length = hex.length / 2; byte[] raw = new byte[length]; for (int i = 0; i < length; i++) { int high = Character.digit(hex[i * 2], 16); int low = Character.digit(hex[i * 2 + 1], 16); if (high < 0 || low < 0){ throw new RuntimeException("Invalid hex digit " + hex[i * 2] + hex[i * 2 + 1]); } int value = (high << 4) | low; if (value > 127) value -= 256; raw[i] = (byte) value; } return raw; } static String toHex(byte[] bytes); static String toHex(byte[] bytes, String separator); static String toHex(byte[] bytes, int offset, int length); static String toHex(byte b); static String toHex(byte[] bytes, int offset, int length, String separator); static byte[] toBytes(String hexString); static void appendByteAsHex(StringBuilder sb, byte b); static boolean isAllZero(byte[] bytes); }### Answer:
@Test public void toBytes() throws Exception { for(String string : strings) { byte [] bytes = Hex.decode(string); assertArrayEquals(bytes, HexUtils.toBytes(string)); } } |
### Question:
ScriptOutputOpReturn extends ScriptOutput implements Serializable { protected static boolean isScriptOutputOpReturn(byte[][] chunks) { return chunks.length == 2 && Script.isOP(chunks[0], OP_RETURN) && chunks[1] != null && chunks[1].length > 0; } protected ScriptOutputOpReturn(byte[][] chunks, byte[] scriptBytes); byte[] getDataBytes(); @Override byte[] getAddressBytes(); @Override Address getAddress(NetworkParameters network); }### Answer:
@Test public void isScriptOutputOpReturnTest() throws Exception { byte[][] chunks = new byte[2][]; chunks[0]=new byte[]{OP_RETURN}; assertFalse(isScriptOutputOpReturn(chunks)); assertTrue(isScriptOutputOpReturn(new byte[][]{{OP_RETURN}, "Hallotest".getBytes()})); assertFalse(isScriptOutputOpReturn(new byte[][]{{OP_RETURN}, null})); assertFalse(isScriptOutputOpReturn(new byte[][]{{OP_RETURN}, "".getBytes()})); assertFalse(isScriptOutputOpReturn(new byte[][]{null, "Hallo".getBytes()})); } |
### Question:
StandardTransactionBuilder { public static List<byte[]> generateSignatures(SigningRequest[] requests, IPrivateKeyRing keyRing) { List<byte[]> signatures = new LinkedList<>(); for (SigningRequest request : requests) { BitcoinSigner signer = keyRing.findSignerByPublicKey(request.getPublicKey()); if (signer == null) { throw new RuntimeException("Private key not found"); } byte[] signature = signer.makeStandardBitcoinSignature(request.getToSign()); signatures.add(signature); } return signatures; } StandardTransactionBuilder(NetworkParameters network); void addOutput(Address sendTo, long value); void addOutput(TransactionOutput output); void addOutputs(OutputList outputs); static TransactionOutput createOutput(Address sendTo, long value, NetworkParameters network); static List<byte[]> generateSignatures(SigningRequest[] requests, IPrivateKeyRing keyRing); UnsignedTransaction createUnsignedTransaction(Collection<UnspentTransactionOutput> inventory,
@Nonnull Address changeAddress, IPublicKeyRing keyRing,
NetworkParameters network, long minerFeeToUse); static Transaction finalizeTransaction(UnsignedTransaction unsigned, List<byte[]> signatures); static final int MAX_INPUT_SIZE; }### Answer:
@Test(timeout=500) @Ignore("This is not really a requirement but was meant to show the supperior performance of bitcoinJ") public void generateSignaturesBitlib() throws Exception { List<SigningRequest> requests = new ArrayList<>(); for(int i = 0; i<30; i++) { requests.add(new SigningRequest(PUBLIC_KEYS[i % COUNT], HashUtils.sha256(("bla" + i).getBytes()))); } StandardTransactionBuilder.generateSignatures(requests.toArray(new SigningRequest[]{}), PRIVATE_KEY_RING); } |
### Question:
Counter { public boolean isZero() { for (byte b : state) { if (b != 0) { return false; } } return true; } Counter(int bits); void increment(); byte[] getState(); boolean isZero(); }### Answer:
@Test public void shouldBeZero() throws Exception { assertTrue(counter.isZero()); } |
### Question:
PopRequest implements Serializable { public Long getAmountSatoshis() { return amountSatoshis; } PopRequest(String input); byte[] getN(); Long getAmountSatoshis(); String getLabel(); Sha256Hash getTxid(); String getP(); String getMessage(); String toString(); }### Answer:
@Test public void testCreateMaxBitcoin() { PopRequest uri = new PopRequest("btcpop:?p=a&n=1&amount=21000000.00000000"); assertEquals(2100000000000000L, uri.getAmountSatoshis().longValue()); } |
### Question:
Fortuna extends Random { public static Fortuna createInstance() { return createInstance(defaultSources()); } private Fortuna(Generator generator, Pool[] pools); static Fortuna createInstance(); static Fortuna createInstance(Iterable<EntropySource> sources); @Override synchronized void setSeed(long seed); }### Answer:
@Test public void shouldCreateInstanceAndWaitForInitialization() throws Exception { Fortuna fortuna = Fortuna.createInstance(); try { fortuna.nextInt(42); } catch (IllegalStateException ignored) { fail("Did not wait for initialization"); } }
@Ignore @Test public void shouldProduceEvenDistribution() throws Exception { int[] numbers = new int[10]; Fortuna fortuna = Fortuna.createInstance(); for (int i = 0; i < 1000000; i++) { numbers[fortuna.nextInt(10)]++; } int lowest = Integer.MAX_VALUE; int highest = Integer.MIN_VALUE; for (int number : numbers) { if (number > highest) { highest = number; } if (number < lowest) { lowest = number; } } System.out.println("numbers = " + Arrays.toString(numbers)); int percentage = (100 * (highest - lowest)) / lowest; System.out.println("percentage = " + percentage); assertEquals(0, percentage); } |
### Question:
ThreadTimeEntropySource implements EntropySource { @Override public void event(EventScheduler scheduler, EventAdder adder) { long threadTime = threadMXBean.getCurrentThreadCpuTime() + threadMXBean.getCurrentThreadUserTime(); adder.add(Util.twoLeastSignificantBytes(threadTime)); scheduler.schedule(100, TimeUnit.MILLISECONDS); } @Override void event(EventScheduler scheduler, EventAdder adder); }### Answer:
@Test public void shouldAddBytes() throws Exception { target.event( new EventScheduler() { @Override public void schedule(long delay, TimeUnit timeUnit) { assertEquals(100, timeUnit.toMillis(delay)); schedules++; } }, new EventAdder() { @Override public void add(byte[] event) { assertEquals(2, event.length); adds++; } } ); assertEquals(1, schedules); assertEquals(1, adds); } |
### Question:
PlatformEntropySource implements EntropySource { @Override public void event(EventScheduler scheduler, EventAdder adder) { try { InputStream inputStream = device2Stream(); try { int size = inputStream.read(bytes); Preconditions.checkState(size == bytes.length); adder.add(bytes); scheduler.schedule(100, TimeUnit.MILLISECONDS); } finally { inputStream.close(); } } catch (IOException e) { throw new IllegalStateException("unexpected error while obtaining entropy: ", e); } } @Override void event(EventScheduler scheduler, EventAdder adder); static final File URANDOM; }### Answer:
@Test public void shouldAddUptime() throws Exception { target.event( new EventScheduler() { @Override public void schedule(long delay, TimeUnit timeUnit) { assertEquals(100, timeUnit.toMillis(delay)); schedules++; } }, new EventAdder() { @Override public void add(byte[] event) { assertEquals(32, event.length); adds++; } } ); assertEquals(1, schedules); assertEquals(1, adds); } |
### Question:
SchedulingEntropySource implements EntropySource { @Override public void event(EventScheduler scheduler, EventAdder adder) { long now = System.nanoTime(); long elapsed = now - lastTime; lastTime = now; adder.add(Util.twoLeastSignificantBytes(elapsed)); scheduler.schedule(10, TimeUnit.MILLISECONDS); } @Override void event(EventScheduler scheduler, EventAdder adder); }### Answer:
@Test public void shouldUseTimeBetweenCallsToCreateEvents() throws Exception { target.event( new EventScheduler() { @Override public void schedule(long delay, TimeUnit timeUnit) { assertEquals(10, timeUnit.toMillis(delay)); schedules++; } }, new EventAdder() { @Override public void add(byte[] event) { assertEquals(2, event.length); adds++; } } ); assertEquals(1, schedules); assertEquals(1, adds); } |
### Question:
UptimeEntropySource implements EntropySource { @Override public void event(EventScheduler scheduler, EventAdder adder) { long uptime = runtimeMXBean.getUptime(); adder.add(Util.twoLeastSignificantBytes(uptime)); scheduler.schedule(1, TimeUnit.SECONDS); } @Override void event(EventScheduler scheduler, EventAdder adder); }### Answer:
@Test public void shouldAddUptime() throws Exception { target.event( new EventScheduler() { @Override public void schedule(long delay, TimeUnit timeUnit) { assertEquals(1000, timeUnit.toMillis(delay)); schedules++; } }, new EventAdder() { @Override public void add(byte[] event) { assertEquals(2, event.length); adds++; } } ); assertEquals(1, schedules); assertEquals(1, adds); } |
### Question:
LoadAverageEntropySource implements EntropySource { @Override public void event(EventScheduler scheduler, EventAdder adder) { double systemLoadAverage = operatingSystemMXBean.getSystemLoadAverage(); BigDecimal value = BigDecimal.valueOf(systemLoadAverage); long convertedValue = value.movePointRight(value.scale()).longValue(); adder.add(Util.twoLeastSignificantBytes(convertedValue)); scheduler.schedule(1000, TimeUnit.MILLISECONDS); } @Override void event(EventScheduler scheduler, EventAdder adder); }### Answer:
@Test public void shouldAddTwoBytesAndSchedule() throws Exception { target.event( new EventScheduler() { @Override public void schedule(long delay, TimeUnit timeUnit) { assertEquals(1000, timeUnit.toMillis(delay)); schedules++; } }, new EventAdder() { @Override public void add(byte[] event) { assertEquals(2, event.length); adds++; } } ); assertEquals(1, schedules); assertEquals(1, adds); } |
### Question:
GarbageCollectorEntropySource implements EntropySource { @Override public void event(EventScheduler scheduler, EventAdder adder) { long sum = 0; for (GarbageCollectorMXBean garbageCollectorMXBean : garbageCollectorMXBeans) { sum += garbageCollectorMXBean.getCollectionCount() + garbageCollectorMXBean.getCollectionTime(); } adder.add(Util.twoLeastSignificantBytes(sum)); scheduler.schedule(10, TimeUnit.SECONDS); } @Override void event(EventScheduler scheduler, EventAdder adder); }### Answer:
@Test public void shouldGetGarbageCollectionData() throws Exception { target.event( new EventScheduler() { @Override public void schedule(long delay, TimeUnit timeUnit) { assertEquals(TimeUnit.SECONDS.toMillis(10), timeUnit.toMillis(delay)); schedules++; } }, new EventAdder() { @Override public void add(byte[] event) { assertEquals(2, event.length); adds++; } } ); assertEquals(1, schedules); assertEquals(1, adds); } |
### Question:
FreeMemoryEntropySource implements EntropySource { @Override public void event(EventScheduler scheduler, EventAdder adder) { long freeMemory = Runtime.getRuntime().freeMemory(); adder.add(Util.twoLeastSignificantBytes(freeMemory)); scheduler.schedule(100, TimeUnit.MILLISECONDS); } @Override void event(EventScheduler scheduler, EventAdder adder); }### Answer:
@Test public void shouldReadFreeMemory() throws Exception { target.event( new EventScheduler() { @Override public void schedule(long delay, TimeUnit timeUnit) { assertEquals(100, timeUnit.toMillis(delay)); schedules++; } }, new EventAdder() { @Override public void add(byte[] event) { assertEquals(2, event.length); adds++; } } ); assertEquals(1, schedules); assertEquals(1, adds); } |
### Question:
Pool { public void add(int source, byte[] event) { writeLock.lock(); try { if (source < 0 || source > 255) { throw new IllegalArgumentException("Source needs to be in the range 0 to 255, it was " + source); } if (event.length < 1 || event.length > 32) { throw new IllegalArgumentException("The length of the event need to be in the range 1 to 32, it was " + event.length); } size += event.length + 2; poolDigest.update(new byte[]{(byte) source, (byte) event.length}); poolDigest.update(event); } finally { writeLock.unlock(); } } long size(); void add(int source, byte[] event); byte[] getAndClear(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void shouldFailIfSourceIsLessThanZero() throws Exception { pool.add(-1, "Hello".getBytes()); }
@Test(expected = IllegalArgumentException.class) public void shouldFailIfSourceIsGreaterThan255() throws Exception { pool.add(256, "Hello".getBytes()); }
@Test(expected = IllegalArgumentException.class) public void shouldFailIfEventIsEmpty() throws Exception { pool.add(0, new byte[0]); }
@Test(expected = IllegalArgumentException.class) public void shouldFailIfEventLengthIsGreaterThan32() throws Exception { pool.add(0, new byte[33]); } |
### Question:
PopRequest implements Serializable { public String getLabel() { return label; } PopRequest(String input); byte[] getN(); Long getAmountSatoshis(); String getLabel(); Sha256Hash getTxid(); String getP(); String getMessage(); String toString(); }### Answer:
@Test public void testCreateUrlDecode() throws UnsupportedEncodingException { String encoded = URLEncoder.encode("http: PopRequest uri = new PopRequest("btcpop:?label=a text&n=111&p=" + encoded); assertEquals("a text", uri.getLabel()); assertEquals("http: } |
### Question:
Pool { public byte[] getAndClear() { writeLock.lock(); try { size = 0; return poolDigest.digest(); } finally { writeLock.unlock(); } } long size(); void add(int source, byte[] event); byte[] getAndClear(); }### Answer:
@Test public void shouldGet32BytesOfSeedData() throws Exception { byte[] bytes = pool.getAndClear(); assertEquals(32, bytes.length); } |
### Question:
ExponentialFeeItemsAlgorithm implements FeeItemsAlgorithm { @Override public long computeValue(int position) { int step = position - minPosition; return round((double)minValue * pow(scale, step)); } ExponentialFeeItemsAlgorithm(long minValue, int minPosition, long maxValue, int maxPosition); @Override long computeValue(int position); @Override int getMinPosition(); @Override int getMaxPosition(); }### Answer:
@Test public void computeValue() throws Exception { assertEquals(MIN_VALUE, algorithm.computeValue(MIN_POSITION)); assertEquals(MAX_VALUE, algorithm.computeValue(MAX_POSITION)); assertTrue(algorithm.computeValue(MIN_POSITION + 1) > MIN_VALUE); assertTrue(algorithm.computeValue(MAX_POSITION - 1) < MAX_VALUE); } |
### Question:
MetadataExample implements Closeable { public void listProperties () throws IOException { for(Property property : dataset.getProperties()) { System.out.format("%s (%s) - %s%n", property.getName(), property.valueType.name(), property.getDescription()); StringBuilder propertyOutput = new StringBuilder(); for (Value value : property.getValues().getAll()) { propertyOutput.append("\t") .append(truncateToNl(value.getName())); if (value.getDescription() != null) { propertyOutput.append(" - ") .append(value.getDescription()); } propertyOutput.append("\n"); } System.out.println(propertyOutput); propertyOutput.setLength(0); } } MetadataExample(); void listProperties(); @Override void close(); static void main(String[] args); }### Answer:
@Test public void testListProperties() throws Exception { example.listProperties(); } |
### Question:
StronglyTypedValues implements Closeable { public boolean isMobile(String userAgent) throws IOException { Match match = provider.match(userAgent); return match.getValues("IsMobile").toBool(); } StronglyTypedValues(); boolean isMobile(String userAgent); static void main(String[] args); @Override void close(); }### Answer:
@Test public void testLiteGettingStartedMediahubUA() throws IOException { assertFalse(gs.isMobile(gs.mediaHubUserAgent)); }
@Test public void testLiteGettingStartedMobileUA() throws IOException { assertTrue(gs.isMobile(gs.mobileUserAgent)); }
@Test public void testLiteGettingStartedDesktopUA() throws IOException { assertFalse(gs.isMobile(gs.desktopUserAgent)); } |
### Question:
Benchmark { protected static byte[] fileAsBytes(String deviceDataFile) throws IOException { File file = new File(deviceDataFile); byte fileContent[] = new byte[(int) file.length()]; FileInputStream fin = new FileInputStream(file); try { int bytesRead = fin.read(fileContent); if (bytesRead != file.length()) { throw new IllegalStateException("File not completely read"); } } finally { fin.close(); } return fileContent; } Benchmark(String userAgentFile); double getAverageDetectionTimePerThread(); int getCount(); void run(Dataset dataSet, int numberOfThreads); static void main(String[] args); }### Answer:
@Test public void testStreamMemory() throws Exception { logger.info("Stream Array / Memory"); testDataSet(StreamFactory.create(Benchmark.fileAsBytes(Shared.getLitePatternV32()))); } |
### Question:
StreamFactory { public static IndirectDataset create(byte[] data) throws IOException { return DatasetBuilder.buffer() .configureDefaultCaches() .build(data); } static IndirectDataset create(byte[] data); static IndirectDataset create(String filePath); static IndirectDataset create(String filePath, boolean isTempFile); static IndirectDataset create(String filepath, Date lastModified,
boolean isTempFile); }### Answer:
@Test public void testCreate32FromFilename () throws Exception { File temp = File.createTempFile("Test",".dat"); File source = new File(Filename.LITE_PATTERN_V32); Files.copy(source, temp); Dataset dataset = StreamFactory.create(temp.getPath()); ViableProvider.ensureViableProvider(new Provider(dataset)); dataset.close(); assertTrue(temp.exists()); dataset = StreamFactory.create(temp.getPath(), true); ViableProvider.ensureViableProvider(new Provider(dataset)); dataset.close(); assertFalse(temp.exists()); }
@Test public void testCreate31FromFilename () throws Exception { Dataset dataset = StreamFactory.create(Filename.LITE_PATTERN_V31); ViableProvider.ensureViableProvider(new Provider(dataset)); }
@Test public void testMemoryStreamDatasetConsistentDefault () throws IOException { IndirectDataset indirectDataset = StreamFactory.create(Filename.LITE_PATTERN_V32); Dataset memoryDataset = MemoryFactory.create(Filename.LITE_PATTERN_V32); compareDatasets(indirectDataset, memoryDataset); }
@Test public void testDefaultCache () throws Exception { Dataset dataset = StreamFactory.create(Filename.LITE_PATTERN_V32); Provider provider = new Provider(dataset, 20); cacheTests(provider); } |
### Question:
FindProfiles implements Closeable { public FindProfiles() throws IOException { provider = new Provider(StreamFactory.create(Shared.getLitePatternV32(), false)); } FindProfiles(); static void main(String[] args); @Override void close(); }### Answer:
@Test public void FindProfilesExample() throws IOException { fp = new FindProfiles(); List<Profile> profiles = fp.provider.dataSet.findProfiles("IsMobile", "True", null); for (Profile profile : profiles) { assertEquals(profile.getValues("IsMobile").toString(), "True"); } profiles = fp.provider.dataSet.findProfiles("IsMobile", "False", null); for (Profile profile : profiles) { assertEquals(profile.getValues("IsMobile").toString(), "False"); } } |
### Question:
DynamicFilters { public ArrayList<Signature> filterBy(String propertyName, String propertyValue, ArrayList<Signature> listToFilter) throws IOException { if (propertyName.isEmpty() || propertyValue.isEmpty()) { throw new IllegalArgumentException("Property and Value can not be " + "empty or null."); } if (listToFilter == null) { listToFilter = signatures; } Property property = dataset.get(propertyName); if (property == null) { throw new IllegalArgumentException("Property you requested " + propertyName + " does not appear to exist in the current " + "data file."); } ArrayList<Signature> filterResults = new ArrayList<Signature>(); for (Signature sig : listToFilter) { Values vals = sig.getValues(property); if (vals.get(propertyValue) != null) { filterResults.add(sig); } } return filterResults; } DynamicFilters(); static void main(String[] args); void run(); ArrayList<Signature> filterBy(String propertyName,
String propertyValue,
ArrayList<Signature> listToFilter); static ArrayList<E> iterableToArrayList(Iterable<E> iter); void close(); }### Answer:
@Test public void dynamicFilter() throws IOException { ArrayList<Signature> signatures; int signaturesOriginal = df.signatures.size(); signatures = df.filterBy("IsMobile", "True", null); int signaturesIsMobile = signatures.size(); signatures = df.filterBy("PlatformName", "Android", signatures); int signaturesPlatformname = signatures.size(); signatures = df.filterBy("BrowserName", "Chrome", signatures); int signaturesBrowserName = signatures.size(); assertTrue(signaturesOriginal >= signaturesIsMobile); assertTrue(signaturesIsMobile >= signaturesPlatformname); assertTrue(signaturesPlatformname >= signaturesBrowserName); for (Signature sig : signatures) { assertTrue(sig.getDeviceId() != null); } } |
### Question:
AllProfiles implements Closeable { public AllProfiles() throws IOException { provider = new Provider(StreamFactory.create( Shared.getLitePatternV32(), false)); hardwareComponent = provider.dataSet.getComponent("HardwarePlatform"); hardwareProperties = hardwareComponent.getProperties(); hardwareProfiles = hardwareComponent.getProfiles(); } AllProfiles(); void run(String outputFilename); static void main(String[] args); @Override void close(); public String outputFilePath; }### Answer:
@Test public void testAllProfiles() throws Exception { assertEquals(outputFile.length(), 0); example.run(outputFile.getAbsolutePath()); assertNotEquals(outputFile.length(), 0); } |
### Question:
GettingStarted implements Closeable { public String detect(String userAgent) throws IOException { Match match = provider.match(userAgent); return match.getValues("IsMobile").toString(); } GettingStarted(); String detect(String userAgent); static void main(String[] args); @Override void close(); }### Answer:
@Test public void testLiteGettingStartedMobileUA() throws IOException { String result = gs.detect(gs.mobileUserAgent); System.out.println("Mobile User-Agent: " + gs.mobileUserAgent); System.out.println("IsMobile: " + result); assertTrue(result.equals("True")); }
@Test public void testLiteGettingStartedDesktopUA() throws IOException { String result = gs.detect(gs.desktopUserAgent); System.out.println("Desktop User-Agent: " + gs.desktopUserAgent); System.out.println("IsMobile: " + result); assertTrue(result.equals("False")); }
@Test public void testLiteGettingStartedMediahubUA() throws IOException { String result = gs.detect(gs.mediaHubUserAgent); System.out.println("MediaHub User-Agent: " + gs.mediaHubUserAgent); System.out.println("IsMobile: " + result); assertTrue(result.equals("False")); } |
### Question:
OfflineProcessingExample implements Closeable { public void processCsv(String inputFileName, String outputFilename) throws IOException { BufferedReader bufferedReader = new BufferedReader(new FileReader(inputFileName)); try { FileWriter fileWriter = new FileWriter(outputFilename); try { Match match = provider.createMatch(); for (int i = 0; i < 20; i++) { String userAgentString = bufferedReader.readLine(); provider.match(userAgentString, match); Values isMobile = match.getValues("IsMobile"); Values platformName = match.getValues("PlatformName"); Values platformVersion = match.getValues("PlatformVersion"); fileWriter.append("\"") .append(userAgentString) .append("\", ") .append(getValueForDisplay(isMobile)) .append(", ") .append(getValueForDisplay(platformName)) .append(", ") .append(getValueForDisplay(platformVersion)) .append('\n') .flush(); } } finally { fileWriter.close(); } } finally { bufferedReader.close(); } } OfflineProcessingExample(); void processCsv(String inputFileName, String outputFilename); @Override void close(); static void main(String[] args); public String outputFilePath; }### Answer:
@Test public void testProcessCsv() throws Exception { assertEquals(outputFile.length(), 0); example.processCsv(Shared.getGoodUserAgentsFile(), outputFile.getAbsolutePath()); assertNotEquals(outputFile.length(), 0); } |
### Question:
ContentSummary implements Writable { public static String getHeader(boolean qOption) { return qOption ? QUOTA_HEADER : HEADER; } @Deprecated ContentSummary(); @Deprecated ContentSummary(long length, long fileCount, long directoryCount); @Deprecated ContentSummary(
long length, long fileCount, long directoryCount, long quota,
long spaceConsumed, long spaceQuota); private ContentSummary(
long length, long fileCount, long directoryCount, long quota,
long spaceConsumed, long spaceQuota, long typeConsumed[],
long typeQuota[]); long getLength(); long getDirectoryCount(); long getFileCount(); long getQuota(); long getSpaceConsumed(); long getSpaceQuota(); long getTypeQuota(StorageType type); long getTypeConsumed(StorageType type); boolean isTypeQuotaSet(); boolean isTypeConsumedAvailable(); @Override @InterfaceAudience.Private void write(DataOutput out); @Override @InterfaceAudience.Private void readFields(DataInput in); static String getHeader(boolean qOption); static String[] getHeaderFields(); static String[] getQuotaHeaderFields(); @Override String toString(); String toString(boolean qOption); String toString(boolean qOption, boolean hOption); }### Answer:
@Test public void testGetHeaderWithQuota() { String header = " QUOTA REM_QUOTA SPACE_QUOTA " + "REM_SPACE_QUOTA DIR_COUNT FILE_COUNT CONTENT_SIZE "; assertEquals(header, ContentSummary.getHeader(true)); }
@Test public void testGetHeaderNoQuota() { String header = " DIR_COUNT FILE_COUNT CONTENT_SIZE "; assertEquals(header, ContentSummary.getHeader(false)); } |
### Question:
TrafficController { public int getClassIdFromFileContents(String input) { String classIdStr = String.format("%08x", Integer.parseInt(input)); if (LOG.isDebugEnabled()) { LOG.debug("ClassId hex string : " + classIdStr); } return Integer.parseInt(classIdStr.substring(4)); } TrafficController(Configuration conf, PrivilegedOperationExecutor exec); void bootstrap(String device, int rootBandwidthMbit, int
yarnBandwidthMbit, int containerBandwidthMbit, boolean strictMode); Map<Integer, Integer> readStats(); int getNextClassId(); void releaseClassId(int classId); String getStringForNetClsClassId(int classId); int getClassIdFromFileContents(String input); }### Answer:
@Test public void testClassIdFileContentParsing() { conf.setBoolean(YarnConfiguration.NM_RECOVERY_ENABLED, false); TrafficController trafficController = new TrafficController(conf, privilegedOperationExecutorMock); int parsedClassId = trafficController.getClassIdFromFileContents (TEST_CLASS_ID_DECIMAL_STR); Assert.assertEquals(TEST_CLASS_ID, parsedClassId); } |
### Question:
DockerStopCommand extends DockerCommand { public DockerStopCommand setGracePeriod(int value) { super.addCommandArguments("--time=" + Integer.toString(value)); return this; } DockerStopCommand(String containerName); DockerStopCommand setGracePeriod(int value); }### Answer:
@Test public void testSetGracePeriod() throws Exception { dockerStopCommand.setGracePeriod(GRACE_PERIOD); assertEquals("stop foo --time=10", dockerStopCommand.getCommandWithArguments()); } |
### Question:
DockerInspectCommand extends DockerCommand { public DockerInspectCommand getContainerStatus() { super.addCommandArguments("--format='{{.State.Status}}'"); super.addCommandArguments(containerName); return this; } DockerInspectCommand(String containerName); DockerInspectCommand getContainerStatus(); }### Answer:
@Test public void testGetContainerStatus() throws Exception { dockerInspectCommand.getContainerStatus(); assertEquals("inspect --format='{{.State.Status}}' foo", dockerInspectCommand.getCommandWithArguments()); } |
### Question:
OwnLocalResources { public static Set<String> getLocalResourcesAllTags(){ Set<String> all = new HashSet<>(); all.add(LR_TAG_CENTOS6); all.add(LR_TAG_CENTOS7); all.add(LR_TAG_MACOS10); return all; } OwnLocalResources(String thisNodeTag); OwnLocalResources(); static Set<String> getLocalResourcesAllTags(); static String getThisLocalResourceTag(); Pair<String,Path> splitTagAndBasename(Path path); Map<Path,List<String>> filterLocalResources(Map<Path,List<String>> originLocalResources); static final String LR_PREFIX; static final String LR_TAG_CENTOS6; static final String LR_TAG_CENTOS7; static final String LR_TAG_MACOS10; static final String LR_TAG_DELIM; }### Answer:
@Test public void testGetLocalResourcesAllTags() throws Exception { Set<String> all = OwnLocalResources.getLocalResourcesAllTags(); assertTrue(all.contains("centos6")); assertTrue(all.contains("centos7")); assertTrue(all.contains("macos10")); } |
### Question:
Count extends FsCommand { @Override protected void processOptions(LinkedList<String> args) { CommandFormat cf = new CommandFormat(1, Integer.MAX_VALUE, OPTION_QUOTA, OPTION_HUMAN, OPTION_HEADER); cf.parse(args); if (args.isEmpty()) { args.add("."); } showQuotas = cf.getOpt(OPTION_QUOTA); humanReadable = cf.getOpt(OPTION_HUMAN); if (cf.getOpt(OPTION_HEADER)) { out.println(ContentSummary.getHeader(showQuotas) + "PATHNAME"); } } Count(); @Deprecated Count(String[] cmd, int pos, Configuration conf); static void registerCommands(CommandFactory factory); static final String NAME; static final String USAGE; static final String DESCRIPTION; }### Answer:
@Test public void processOptionsHeaderNoQuotas() { LinkedList<String> options = new LinkedList<String>(); options.add("-v"); options.add("dummy"); PrintStream out = mock(PrintStream.class); Count count = new Count(); count.out = out; count.processOptions(options); String noQuotasHeader = " DIR_COUNT FILE_COUNT CONTENT_SIZE PATHNAME"; verify(out).println(noQuotasHeader); verifyNoMoreInteractions(out); }
@Test public void processOptionsHeaderWithQuotas() { LinkedList<String> options = new LinkedList<String>(); options.add("-q"); options.add("-v"); options.add("dummy"); PrintStream out = mock(PrintStream.class); Count count = new Count(); count.out = out; count.processOptions(options); String withQuotasHeader = " QUOTA REM_QUOTA SPACE_QUOTA REM_SPACE_QUOTA " + " DIR_COUNT FILE_COUNT CONTENT_SIZE PATHNAME"; verify(out).println(withQuotasHeader); verifyNoMoreInteractions(out); } |
### Question:
GroovyWorld extends GroovyObjectSupport { public void registerWorld(Object world) { if (world instanceof GroovyObject) { worlds.add((GroovyObject) world); } else { throw new RuntimeException("Only GroovyObject supported"); } } GroovyWorld(); void registerWorld(Object world); Object getProperty(String property); void setProperty(String property, Object newValue); Object invokeMethod(String name, Object args); }### Answer:
@Test(expected = RuntimeException.class) public void should_not_register_pure_java_object() { world.registerWorld("JAVA"); } |
### Question:
Hooks { public static void Before(Object... args) { addHook(args, true, false); } static void World(Closure body); static void Before(Object... args); static void After(Object... args); static void AfterStep(Object... args); static void BeforeStep(Object... args); }### Answer:
@Test public void only_allows_arguments_string_integer_closure() { try { Hooks.Before("TAG", 10D, 100, new MethodClosure(this, "dummyClosureCall"), 0.0); fail("CucumberException was not thrown"); } catch (CucumberException e) { assertEquals("An argument of the type java.lang.Double found, Before only allows the argument types " + "String - Tag, Integer - order, and Closure", e.getMessage()); } }
@Test public void only_allows_one_timeout_argument() { try { Hooks.Before(1L, 2L); fail("CucumberException was not thrown"); } catch (CucumberException e) { assertEquals("An argument of the type java.lang.Long found, Before only allows the argument types String - Tag, Integer - order, and Closure", e.getMessage()); } }
@Test public void only_allows_one_order_argument() { try { Hooks.Before(1, 2); fail("CucumberException was not thrown"); } catch (CucumberException e) { assertEquals("Two order (Integer) arguments found; 1, and; 2", e.getMessage()); } } |
### Question:
XQueryRunConfig { public String getMainFile() { return getExpressionValue(mainFileExpression); } XQueryRunConfig(String xml); String getMainFile(); boolean isContextItemEnabled(); boolean isContextItemFromEditorEnabled(); String getContextItemFile(); String getContextItemText(); List<XQueryRunnerVariable> getVariables(); XQueryDataSourceType getDataSourceType(); String getHost(); String getPort(); String getUsername(); String getPassword(); boolean isConfigFileEnabled(); String getConfigFile(); String getDatabaseName(); String getContextItemType(); boolean isDebugEnabled(); String getDebugPort(); }### Answer:
@Test public void shouldReturnMainFileValue() { String result = config.getMainFile(); assertThat(result, is(MAIN_FILE_NAME)); } |
### Question:
XQueryRunConfig { public String getHost() { return getExpressionValue(hostExpression); } XQueryRunConfig(String xml); String getMainFile(); boolean isContextItemEnabled(); boolean isContextItemFromEditorEnabled(); String getContextItemFile(); String getContextItemText(); List<XQueryRunnerVariable> getVariables(); XQueryDataSourceType getDataSourceType(); String getHost(); String getPort(); String getUsername(); String getPassword(); boolean isConfigFileEnabled(); String getConfigFile(); String getDatabaseName(); String getContextItemType(); boolean isDebugEnabled(); String getDebugPort(); }### Answer:
@Test public void shouldReturnHostValue() { String result = config.getHost(); assertThat(result, is(HOST)); } |
### Question:
XQueryRunConfig { public String getPort() { return getExpressionValue(portExpression); } XQueryRunConfig(String xml); String getMainFile(); boolean isContextItemEnabled(); boolean isContextItemFromEditorEnabled(); String getContextItemFile(); String getContextItemText(); List<XQueryRunnerVariable> getVariables(); XQueryDataSourceType getDataSourceType(); String getHost(); String getPort(); String getUsername(); String getPassword(); boolean isConfigFileEnabled(); String getConfigFile(); String getDatabaseName(); String getContextItemType(); boolean isDebugEnabled(); String getDebugPort(); }### Answer:
@Test public void shouldReturnPortValue() { String result = config.getPort(); assertThat(result, is(PORT)); } |
### Question:
XQueryRunConfig { public String getUsername() { return getExpressionValue(usernameExpression); } XQueryRunConfig(String xml); String getMainFile(); boolean isContextItemEnabled(); boolean isContextItemFromEditorEnabled(); String getContextItemFile(); String getContextItemText(); List<XQueryRunnerVariable> getVariables(); XQueryDataSourceType getDataSourceType(); String getHost(); String getPort(); String getUsername(); String getPassword(); boolean isConfigFileEnabled(); String getConfigFile(); String getDatabaseName(); String getContextItemType(); boolean isDebugEnabled(); String getDebugPort(); }### Answer:
@Test public void shouldReturnUsernameValue() { String result = config.getUsername(); assertThat(result, is(USERNAME)); } |
### Question:
XQueryRunConfig { public String getPassword() { return getExpressionValue(passwordExpression); } XQueryRunConfig(String xml); String getMainFile(); boolean isContextItemEnabled(); boolean isContextItemFromEditorEnabled(); String getContextItemFile(); String getContextItemText(); List<XQueryRunnerVariable> getVariables(); XQueryDataSourceType getDataSourceType(); String getHost(); String getPort(); String getUsername(); String getPassword(); boolean isConfigFileEnabled(); String getConfigFile(); String getDatabaseName(); String getContextItemType(); boolean isDebugEnabled(); String getDebugPort(); }### Answer:
@Test public void shouldReturnPasswordValue() { String result = config.getPassword(); assertThat(result, is(PASSWORD)); } |
### Question:
XQueryRunConfig { public boolean isConfigFileEnabled() { return Boolean.parseBoolean(getExpressionValue(configFileEnabledExpression)); } XQueryRunConfig(String xml); String getMainFile(); boolean isContextItemEnabled(); boolean isContextItemFromEditorEnabled(); String getContextItemFile(); String getContextItemText(); List<XQueryRunnerVariable> getVariables(); XQueryDataSourceType getDataSourceType(); String getHost(); String getPort(); String getUsername(); String getPassword(); boolean isConfigFileEnabled(); String getConfigFile(); String getDatabaseName(); String getContextItemType(); boolean isDebugEnabled(); String getDebugPort(); }### Answer:
@Test public void shouldReturnConfigEnabledValue() { boolean result = config.isConfigFileEnabled(); assertThat(result, is(CONFIG_FILE_ENABLED)); } |
### Question:
XQueryRunConfig { public String getConfigFile() { return getExpressionValue(configFileExpression); } XQueryRunConfig(String xml); String getMainFile(); boolean isContextItemEnabled(); boolean isContextItemFromEditorEnabled(); String getContextItemFile(); String getContextItemText(); List<XQueryRunnerVariable> getVariables(); XQueryDataSourceType getDataSourceType(); String getHost(); String getPort(); String getUsername(); String getPassword(); boolean isConfigFileEnabled(); String getConfigFile(); String getDatabaseName(); String getContextItemType(); boolean isDebugEnabled(); String getDebugPort(); }### Answer:
@Test public void shouldReturnConfigFileValue() { String result = config.getConfigFile(); assertThat(result, is(CONFIG_FILE)); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.