method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
Strings { public static int[] codePoints(String s) { int length = s.length(); int arrayPointer = 0; int stringPointer = 0; int[] codepoints = new int[length]; while (stringPointer < length) { int codepoint = s.codePointAt(stringPointer); codepoints[arrayPointer++] = codepoint; stringPointer += Character.charCount(codepoint); } return arrayPointer == stringPointer ? codepoints : Arrays.copyOf(codepoints, arrayPointer); } private Strings(); static int[] codePoints(String s); static boolean isNullOrEmpty(String s); static String nullToEmpty(String value); static String sanitizeWhitespace(String str); }### Answer:
@Test public void codepoints() { assertArrayEquals(new int[]{65536}, Strings.codePoints("\uD800\uDC00")); assertArrayEquals(new int[]{9731}, Strings.codePoints("☃")); } |
### Question:
Strings { public static boolean isNullOrEmpty(String s) { return s == null || s.isEmpty(); } private Strings(); static int[] codePoints(String s); static boolean isNullOrEmpty(String s); static String nullToEmpty(String value); static String sanitizeWhitespace(String str); }### Answer:
@Test public void isNullOrEmpty() { assertTrue(Strings.isNullOrEmpty(null)); assertTrue(Strings.isNullOrEmpty("")); assertFalse(Strings.isNullOrEmpty("a")); } |
### Question:
Strings { public static String sanitizeWhitespace(String str) { int start = 0; int end = str.length(); while (start < end && CodepointMatcher.ASCII_WHITESPACE.matches(str.charAt(start))) { start++; } if (start == end) { return ""; } while (end > start && CodepointMatcher.ASCII_WHITESPACE.matches(str.charAt(end - 1))) { end--; } int firstNewline = -1; for (int i = start; i < end; i++) { if (CodepointMatcher.ASCII_NEWLINE.matches(str.charAt(i))) { firstNewline = i; break; } } if (firstNewline == -1) { if (start == 0 && end == str.length()) { return str; } else { return str.substring(start, end); } } char[] chars = str.toCharArray(); int p = firstNewline; for (int i = firstNewline; i < end; i++) { if (CodepointMatcher.ASCII_NEWLINE.matches(str.charAt(i))) { i++; while (i < end && CodepointMatcher.ASCII_WHITESPACE.matches(str.charAt(i))) { i++; } } chars[p++] = str.charAt(i); } return new String(chars, start, p - start); } private Strings(); static int[] codePoints(String s); static boolean isNullOrEmpty(String s); static String nullToEmpty(String value); static String sanitizeWhitespace(String str); }### Answer:
@Test public void santizeWhitespace() { assertEquals("", Strings.sanitizeWhitespace(" ")); assertEquals("a", Strings.sanitizeWhitespace(" a ")); assertEquals("ab", Strings.sanitizeWhitespace(" a\nb ")); assertEquals("ab", Strings.sanitizeWhitespace(" a\n b ")); assertEquals("ab", Strings.sanitizeWhitespace("a\n b")); assertEquals("ab c", Strings.sanitizeWhitespace("a\n b c")); assertEquals("ab c", Strings.sanitizeWhitespace("a\n b c")); assertEquals("a", Strings.sanitizeWhitespace("a\n ")); } |
### Question:
Ip4 implements Host { @Nullable static Ip4 parse(String hostname) { String[] segments = hostname.split("\\."); if (segments.length != 4) { return null; } byte[] addr = new byte[4]; for (int i = 0; i < segments.length; i++) { int val; String segment = segments[i]; if (segment.length() > 1 && segment.startsWith("0")) { return null; } try { val = Integer.parseInt(segment); } catch (NumberFormatException e) { return null; } if (val < 0 || val > 255) { return null; } addr[i] = (byte) val; } return fromAddress(addr); } }### Answer:
@Test public void removeTrailingPeriod() { assertEquals("255.255.255.255", Hosts.parse("255.255.255.255.").name()); }
@Test public void percentDecodeBeforeParsing() { assertEquals("1.1.1.1", Hosts.parse("%31.%31.%31.%31").name()); assertEquals("1.1.1.1", Hosts.parse("1%2e1%2e1%2e1").name()); }
@Test public void disambiguateUnicodeFirst() { assertEquals("1.1.1.1", Hosts.parse("１。１。１。１").name()); }
@Test public void ipv4() { assertEquals("1.1.1.1", Hosts.parse("1.1.1.1").name()); assertEquals("0.0.0.1", Hosts.parse("0.0.0.1").name()); assertEquals("0.0.0.0", Hosts.parse("0.0.0.0").name()); assertEquals("255.255.255.255", Hosts.parse("255.255.255.255").name()); } |
### Question:
Authority { public static Authority split(String authority) { int lastColon = -1; int numColons = 0; int start = authority.length(); int end = authority.length(); int port = -1; while (--start >= 0) { char b = authority.charAt(start); if (b == '@') { break; } else if (b == ':') { if (numColons++ == 0) { lastColon = start; } } } start++; if (start == end || start == lastColon) { throw new IllegalArgumentException("URL missing host. Input: " + authority); } if (numColons == 1) { port = parseAndValidatePort(authority, lastColon); end = lastColon; } else if (numColons > 1) { if (authority.charAt(lastColon - 1) == ']') { port = parseAndValidatePort(authority, lastColon); end = lastColon; } } return new AutoValue_Authority(port, Hosts.parse(authority.substring(start, end))); } abstract int port(); abstract Host host(); static Authority split(String authority); @Override String toString(); }### Answer:
@Test public void supportUnicodePeriods() { assertEquals("host.com", Authority.split("host。com").host().display()); assertEquals("host.com", Authority.split("host．com").host().display()); assertEquals("host.com", Authority.split("host｡com").host().display()); } |
### Question:
Dns implements Host { static Dns parse(String hostname) { int lastDot = -1; for (int i = 0; i < hostname.length(); i++) { char c = hostname.charAt(i); if (!DNS.matches(c)) { throw new InvalidHostException(hostname, i); } else if (c == '.') { if (lastDot == i - 1) { throw new InvalidHostException(hostname, i); } lastDot = i; } } String lower = hostname.toLowerCase(Locale.US); return new AutoValue_Dns(lower, IDN.toUnicode(lower)); } }### Answer:
@Test public void convertToLowerCase() { assertEquals(Dns.parse("example.com"), Dns.parse("EXAMPLE.com")); } |
### Question:
Hosts { @Nonnull static Host parse(String hostname) { String ascii = validateAndConvertToAscii(hostname); Host host; if (Ip6.isIpv6(ascii)) { host = Ip6.parse(ascii); } else { if (ascii.endsWith(".")) { ascii = ascii.substring(0, ascii.length() - 1); } if (Ip4.isIpv4(ascii)) { host = Ip4.parse(ascii); } else { host = Dns.parse(ascii); } } if (host == null) { throw new IllegalArgumentException("Invalid hostname: " + hostname); } return host; } }### Answer:
@Test public void allowTrailingDot() { assertEquals(Hosts.parse("example.com"), Hosts.parse("example.com.")); assertEquals(Hosts.parse("example"), Hosts.parse("example.")); assertEquals(Hosts.parse("1.1.1.1"), Hosts.parse("1.1.1.1.")); }
@Test public void convertToLowerCase() { assertEquals(Hosts.parse("example.com"), Hosts.parse("Example.com")); assertEquals(Hosts.parse("ökonom.de"), Hosts.parse("Ökonom.de")); assertEquals(Hosts.parse("ли.ru"), Hosts.parse("Ли.ru")); } |
### Question:
SplitUrl { public static SplitUrl split(String url) { String trim = CodepointMatcher.ASCII_WHITESPACE.trim(url); if (trim.isEmpty()) { return SplitUrl.builder() .path("") .urlType(Type.PATH_RELATIVE) .build(); } Builder builder; if (CodepointMatcher.ALPHA.matches(trim.charAt(0))) { builder = fullUrlOrRelativePath(trim); } else if (slash.matches(trim.charAt(0))) { if (trim.length() == 2 && slash.matches(trim.charAt(1))) { return SplitUrl.builder() .urlType(Type.PROTOCOL_RELATIVE) .build(); } else if (trim.length() > 1 && slash.matches(trim.charAt(1))) { builder = authority(trim, 0).urlType(Type.PROTOCOL_RELATIVE); } else { builder = path(trim, 0).urlType(Type.PATH_ABSOLUTE); } } else if (trim.charAt(0) == '#') { builder = fragment(trim, 0).urlType(Type.FRAGMENT); } else { builder = path(trim, 0).urlType(Type.PATH_RELATIVE); } return builder.build(); } @Nullable abstract String scheme(); @Nullable abstract String authority(); @Nullable abstract String path(); @Nullable abstract String query(); @Nullable abstract String fragment(); @Nullable abstract Type urlType(); static SplitUrl split(String url); }### Answer:
@Test public void length1() { assertEquals(onlyPath("/"), SplitUrl.split("/")); assertEquals(onlyPath("p"), SplitUrl.split("p")); assertEquals(onlyPath(":"), SplitUrl.split(":")); assertEquals(onlyQuery(""), SplitUrl.split("?")); assertEquals(onlyFragment(""), SplitUrl.split("#")); }
@Test public void invalidOrMissingScheme() { assertEquals(onlyPath(":host"), SplitUrl.split(":host")); assertEquals(onlyPath("bad@scheme: assertEquals(onlyPath(": }
@Test public void onlyScheme() { try { SplitUrl.split("http:"); } catch (IllegalArgumentException expected) { assertThat(expected.getMessage(), containsString("missing host")); } }
@Test public void onlyPath() { assertEquals(onlyPath(""), SplitUrl.split("")); assertEquals(onlyPath("/"), SplitUrl.split("/")); assertEquals(onlyPath("/"), SplitUrl.split("/")); assertEquals(onlyPath("a"), SplitUrl.split("a")); assertEquals(onlyPath("/a"), SplitUrl.split("/a")); assertEquals(onlyPath("/a/"), SplitUrl.split("/a/")); }
@Test public void onlyQuery() { assertEquals(onlyQuery(""), SplitUrl.split("?")); assertEquals(onlyQuery("?"), SplitUrl.split("??")); assertEquals(onlyQuery("/path"), SplitUrl.split("?/path")); assertEquals(onlyQuery("http: }
@Test public void onlyFragment() { assertEquals(onlyFragment(""), SplitUrl.split("#")); assertEquals(onlyFragment("/path"), SplitUrl.split("#/path")); assertEquals(onlyFragment("?query"), SplitUrl.split("#?query")); } |
### Question:
OpenIBANValidationClient extends RestGatewaySupport implements IBANValidationClient { @Override public IBANValidationResult validate(String iban) { return getRestTemplate().getForObject(URL_TEMPLATE, IBANValidationResult.class, iban); } @Override IBANValidationResult validate(String iban); }### Answer:
@Test public void validIban() { mockRestServiceServer .expect(requestTo("https: .andRespond(withSuccess(new ClassPathResource("NL87TRIO0396451440-result.json"), MediaType.APPLICATION_JSON)); IBANValidationResult result = client.validate("NL87TRIO0396451440"); assertTrue(result.isValid()); }
@Test public void invalidIban() { mockRestServiceServer .expect(requestTo("https: .andRespond(withSuccess(new ClassPathResource("NL28XXXX389242218-result.json"), MediaType.APPLICATION_JSON)); IBANValidationResult result = client.validate("NL28XXXX389242218"); assertFalse(result.isValid()); } |
### Question:
ProjectManager { private String getRootProjectName(String name){ if(name.contains("--")){ String type = null; if(name.endsWith("column")) type = "column"; else if(name.endsWith("row")) type = "row"; String subset = name.substring(name.indexOf("--"), name.length()-type.length()); name = name.replace(subset, ""); } return name; } protected ProjectManager(); void setWorkspace(Workspace workspace); Workspace getWorkspace(); void setDatasetBuilder(PresetDatasetBuilder datasetBuilder); PresetDatasetBuilder getDatasetBuilder(); void setProbeAnnotationPlatforms(ProbeAnnotationPlatforms probeAnnotations); ProbeAnnotationPlatforms getProbeAnnotationPlatforms(); void setDimensionBuilder(PresetDimensionBuilder dimensionBuilder); PresetDimensionBuilder getDimensionBuilder(); static ProjectManager getSingleton(); static void setSingleton(ProjectManager pm); void dispose(); void registerProject(Project project, ProjectMetadata projectMetadata); abstract boolean loadProjectMetadata(long projectID); abstract void importProject(long projectID, InputStream inputStream, boolean gziped); abstract void exportProject(long projectId, TarOutputStream tos); void ensureProjectSaved(long id); void save(boolean allModified); InterProjectModel getInterProjectModel(); ProjectMetadata getProjectMetadata(long id); ProjectMetadata getProjectMetadata(String name); long getProjectID(String name); Map<Long, ProjectMetadata> getAllProjectMetadata(); Project getProject(long id); PreferenceStore getPreferenceStore(); List<String> getExpressions(); abstract HistoryEntryManager getHistoryEntryManager(); void deleteProject(Project project); abstract void deleteProject(long projectID); void setBusy(boolean busy); void addLatestExpression(String s); }### Answer:
@Test public void testColumn() { String name = getRootProjectName("mouse_test_data.tsv--s1column"); assertThat(name, is("mouse_test_data.tsvcolumn")); }
@Test public void testColumnNoop() { String name = getRootProjectName("mouse_test_data.tsvcolumn"); assertThat(name, is("mouse_test_data.tsvcolumn")); }
@Test public void testRow() { String name = getRootProjectName("mouse_test_data.tsv--s1row"); assertThat(name, is("mouse_test_data.tsvrow")); }
@Test public void testRowNoop() { String name = getRootProjectName("mouse_test_data.tsvrow"); assertThat(name, is("mouse_test_data.tsvrow")); } |
### Question:
CliRScriptEngine extends AbstractScriptEngine { @Override public Object eval (String script, ScriptContext context) throws ScriptException { return eval (new StringReader (script), context); } @Override Object eval(String script, ScriptContext context); @Override Object eval(Reader reader, ScriptContext context); @Override Bindings createBindings(); @Override ScriptEngineFactory getFactory(); }### Answer:
@Test public void helloWorld () throws ScriptException { r.eval ("cat('hello world\\n')"); } |
### Question:
DataSubset extends AbstractDataset implements Dataset { @Override public Values values () { return new ValuesSubset (parent.values (), columns.keys (), rows.keys (), false); } @SneakyThrows(value = {InvalidDimensionTypeException.class}) DataSubset(String name, Dataset parent, List<String> columns, List<String> rows); @SneakyThrows({InvalidDimensionTypeException.class}) DataSubset(Dataset parent, List<String> columns, List<String> rows); @Override Values values(); @Override Dimension dimension(Type type); @Override void set(Dimension dimension); @Override Analyses analyses(); @Override void exportSelection(String name,
Type dimension,
String selection,
Workspace workspace,
DatasetBuilder datasetBuilder); @Override void close(); }### Answer:
@Test public void testValues () throws InvalidCoordinateException { assertThat(subset.values ().get ("g2", "sb"), equalTo (2.2)); assertThat(subset.values ().get ("g2", "sc"), equalTo (2.3)); assertThat(subset.values ().get ("g3", "sb"), equalTo (3.2)); assertThat(subset.values ().get ("g3", "sc"), equalTo (3.3)); assertThat(subset.values ().skipJson (), equalTo(false)); thrown.expect (InvalidCoordinateException.class); subset.values ().get ("g1", "sa"); thrown.expect (InvalidCoordinateException.class); subset.values ().get ("g1", "sd"); thrown.expect (InvalidCoordinateException.class); subset.values ().get ("g2", "sa"); thrown.expect (InvalidCoordinateException.class); subset.values ().get ("g2", "sd"); thrown.expect (InvalidCoordinateException.class); subset.values ().get ("g3", "sa"); thrown.expect (InvalidCoordinateException.class); subset.values ().get ("g3", "sd"); thrown.expect (InvalidCoordinateException.class); subset.values ().get ("g4", "sa"); thrown.expect (InvalidCoordinateException.class); subset.values ().get ("g4", "sd"); } |
### Question:
FlatFileValues extends AbstractValues implements Closeable, IFlatFileValues, Iterable<Value> { @Override public double get (String row, String column) throws InvalidCoordinateException { int x = columns.get (column); int y = rows.get (row); long position = (((long) y) * width + x) * 8; return mappings.get ((int) (position / MAPPING_SIZE)).getDouble ((int) (position % MAPPING_SIZE)); } FlatFileValues(File file, Map<String, Integer> rows, Map<String, Integer> columns, int height, int width); @Override boolean skipJson(); @Override InputStream asInputStream(); @Override double get(String row, String column); @Override void close(); @Override Iterator<Value> iterator(); }### Answer:
@Test public void builder () throws Exception { try (FlatFileValueStoreBuilder builder = new FlatFileValueStoreBuilder ()) { builder.add (.1, "r1", "c1"); builder.add (.2, "r1", "c2"); builder.add (.3, "r2", "c1"); builder.add (.4, "r2", "c2"); builder.add (.5, "r3", "c1"); builder.add (.6, "r3", "c2"); Map<String, Integer> rowKeys = new LinkedHashMap<String, Integer> (2); rowKeys.put ("r1", 0); rowKeys.put ("r2", 1); rowKeys.put ("r3", 2); Map<String, Integer> columnKeys = new LinkedHashMap<String, Integer> (2); columnKeys.put ("c1", 0); columnKeys.put ("c2", 1); Values values = builder.build (rowKeys, columnKeys); assertThat (values.get ("r1", "c1"), is (.1)); assertThat (values.get ("r2", "c1"), is (.3)); assertThat (values.get ("r3", "c1"), is (.5)); assertThat (values.get ("r1", "c2"), is (.2)); assertThat (values.get ("r2", "c2"), is (.4)); assertThat (values.get ("r3", "c2"), is (.6)); } } |
### Question:
SuperCsvParserFactory extends AbstractParserFactory { @Override public SuperCsvParser parse (InputStream input) throws DatasetBuilderException { return new SuperCsvParser (new CsvListReader (new InputStreamReader (input), new Builder (quoteChar, separatorChar, endOfLineSymbols).skipComments (new CommentMatcher () { @Override public boolean isComment (String line) { for (Pattern pattern : commentRegExpressions) if (pattern.matcher (line).matches ()) return true; return false; } }).build ()), rowIdParser); } SuperCsvParserFactory(SuperCsvParser.RowIdParser rowIdParser); SuperCsvParserFactory quoteChar(char quoteChar); @Override void addCommentRegExpression(String regex); SuperCsvParserFactory separatorChar(int separatorChar); SuperCsvParserFactory endOfLineSymbols(String endOfLineSymbols); SuperCsvParserFactory commentRegExpressions(String... commentRegExpressions); @Override String contentType(); @Override SuperCsvParser parse(InputStream input); }### Answer:
@Test public void testParser () throws Exception { Parser p = new SuperCsvParserFactory ().parse (new ByteArrayInputStream (("\t\tsa\tsb\tsc\n" + "g1\tp1\t.1\t.2\t.3\n" + "g2\tp2\t.4\t.5\t.6").getBytes ())); for (int index = 1; index < 7; index++) { assertTrue (p.next ()); assertEquals (index / 10.0, p.value (), 0.0); } assertFalse (p.next ()); List<String> expectedColumns = new ArrayList<String>(){ private static final long serialVersionUID = 1L; { add("sa"); add("sb"); add("sc"); }}; assertThat(p.columnKeys (), is(expectedColumns)); List<String> expectedRows= new ArrayList<String>(){ private static final long serialVersionUID = 1L; { add("g1"); add("g2"); }}; assertThat(p.rowKeys (), is(expectedRows)); }
@Test public void testGEOParser () throws Exception { URL url = this.getClass ().getResource ("geods/geo.gds.soft.txt"); Parser p = new SuperCsvParserFactory ().parse (new UrlTsvInput (url).input ()); while(p.next ()) { } List<String> expectedRows = new ArrayList<String>(){ private static final long serialVersionUID = 1L; { add("1007_s_at"); add("1053_at"); add("117_at"); } }; assertFalse(p.next ()); assertThat(p.rowKeys (), is(expectedRows)); List<String> expectedColumns = Arrays.asList ("GSM564960\tGSM564961\tGSM564952\tGSM564958\tGSM564953\tGSM564959\tGSM564956\tGSM564957\tGSM564950\tGSM564954\tGSM564951\tGSM564955".split ("\t")); assertThat(p.columnKeys (), is(expectedColumns)); } |
### Question:
GzipTsvInput extends AbstractRawInput { @Override public InputStream input () throws IOException { if (log.isDebugEnabled ()) log.debug (url); GZIPInputStream zis = null; BufferedOutputStream dest = null; BufferedInputStream bis = null; File unzipped = new TemporaryFile (); try { URLConnection urlc = url.openConnection (); zis = new GZIPInputStream (urlc.getInputStream ()); int count; byte data[] = new byte[BUFFER]; FileOutputStream fos = new FileOutputStream (unzipped); if (log.isDebugEnabled ()) log.debug ("Unzipping SOFT file to " + unzipped.getAbsolutePath ()); dest = new BufferedOutputStream (fos, BUFFER); while ((count = zis.read (data, 0, BUFFER)) != -1) { dest.write (data, 0, count); } dest.flush (); dest.close (); return new FileInputStream (unzipped); } finally { if (bis != null) { try { bis.close (); } catch (IOException ioe) {} } if (dest != null) { try { dest.close (); } catch (IOException ioe) {} } if (zis != null) { try { zis.close (); } catch (IOException ioe) {} } } } GzipTsvInput(URL url); @Override String contentType(); @Override String name(); @Override InputStream input(); @Override long size(); }### Answer:
@Test public void testInput () throws IOException, DatasetBuilderException, InvalidDimensionTypeException { RawInput gzip = new GzipTsvInput (this.getClass ().getResource ("geo.gds.soft.txt.gz")); Parser p = new SuperCsvParserFactory ().parse (gzip.input ()); while(p.next ()) { } List<String> expectedRows = new ArrayList<String>(){ private static final long serialVersionUID = 1L; { add("1007_s_at"); add("1053_at"); add("117_at"); } }; assertFalse(p.next ()); assertThat(p.rowKeys (), is(expectedRows)); List<String> expectedColumns = Arrays.asList ("GSM564960\tGSM564961\tGSM564952\tGSM564958\tGSM564953\tGSM564959\tGSM564956\tGSM564957\tGSM564950\tGSM564954\tGSM564951\tGSM564955".split ("\t")); assertThat(p.columnKeys (), is(expectedColumns)); } |
### Question:
DatasetBuilderZip extends AbstractDatasetBuilder { @Override public Dataset build (RawInput zip) throws DatasetBuilderException { try{ DatasetZipHelper dszip = new DatasetZipHelper(); File dir = dszip.extract(zip.input(), zip.name()); File datasetFile = Paths.get(dir.getPath(), "dataset.json").toFile(); JsonNode datasetNode = mapper.readTree(datasetFile); JsonNode columnNode = datasetNode.get("column"); List<String> columns = getKeys(columnNode); Selection[] columnSelections = mapper.treeToValue(columnNode.get("selections"), Selection[].class); JsonNode rowNode = datasetNode.get("row"); List<String> rows = getKeys(rowNode); Selection[] rowSelections = mapper.treeToValue(rowNode.get("selections"), Selection[].class); File valuesFile = Paths.get(dir.getPath(), "values.bin").toFile(); RawInput values = new FileBinaryInput(valuesFile); DatasetBuilderFlatFile builder = new DatasetBuilderFlatFile(); Dataset dataset = builder.build(values, formatDatasetName(zip.name()), columns, rows, Arrays.asList(columnSelections), Arrays.asList(rowSelections)); for(File analysisFile : dir.listFiles(new FilenameFilter() { @Override public boolean accept(File dir, String name) { return name.startsWith("analysis_"); } })){ JsonNode analysisNode = mapper.readTree(analysisFile); dataset.analyses().put( new AnalysisJson(analysisFile) ); } for(File annotationFile : dir.listFiles(new FilenameFilter() { @Override public boolean accept(File dir, String name) { return name.startsWith("annotations_"); } })){ if(annotationFile.getName().endsWith("column.tar.gz")) dataset.dimension(Dimension.Type.COLUMN).annotation( new OpenRefineAnnotation(annotationFile) ); else if(annotationFile.getName().endsWith("row.tar.gz")) dataset.dimension(Dimension.Type.ROW).annotation( new OpenRefineAnnotation(annotationFile) ); } return dataset; }catch(IOException | DatasetException e){ throw new DatasetBuilderException (String.format("Error while building dataset name from zip: %s", zip)); } } @Override Dataset build(RawInput zip); }### Answer:
@Test public void testBuild() throws URISyntaxException, IOException, DatasetException { Dataset dataset = builder.build(new ZipBinaryInput(Paths.get(inputUri).toFile())); log.debug(String.format("dataset: %s", dataset)); assertThat(dataset.name(), is(FilenameUtils.getBaseName(inputUri.toURL().getFile()))); assertThat(dataset.analyses().list().size(), is(11)); Dimension column = dataset.dimension(Dimension.Type.COLUMN); assertThat(column.keys().size(), is(6)); Dimension row = dataset.dimension(Dimension.Type.ROW); assertThat(row.keys().size(), is(39)); Analysis pca = dataset.analyses().get("PCA"); log.debug(String.format("analysis PCA analysis: %s", pca)); String pcaJson = mapper.writeValueAsString(pca); log.debug(String.format("analysis PCA json: %s", pcaJson)); assertThat(pcaJson, containsString("\"sdev\"")); assertTrue(dataset.dimension(Dimension.Type.COLUMN).annotation() instanceof OpenRefineAnnotation ); assertTrue(dataset.dimension(Dimension.Type.ROW).annotation() instanceof OpenRefineAnnotation ); } |
### Question:
GremlinQueryEngine implements QueryEngine<Object> { @Override public QueryResult<Object> query(String statement, Map<String, Object> params) { try { Iterable<Object> result = gremlinExecutor.query(statement, params); return new QueryResultBuilder<Object>(result,resultConverter); } catch (Exception e) { throw new InvalidDataAccessResourceUsageException("Error executing statement " + statement, e); } } GremlinQueryEngine(GraphDatabaseService graphDatabaseService); GremlinQueryEngine(GraphDatabaseService graphDatabaseService, ResultConverter resultConverter); @Override QueryResult<Object> query(String statement, Map<String, Object> params); }### Answer:
@Test @Transactional public void testQueryList() throws Exception { final String queryString = "t = new Table(); [g.v(michael),g.v(david)].each{ n -> n.as('person.name').as('person.age').table(t,['person.name','person.age']){ it.age }{ it.name } >> -1}; t;" ; final Collection<Object> result = IteratorUtil.asCollection(queryEngine.query(queryString, MapUtil.map("michael", idFor(michael), "david", idFor(testTeam.david)))); assertEquals(asList(testTeam.simpleRowFor(michael, "person"), testTeam.simpleRowFor(testTeam.david, "person")), result); } |
### Question:
EntityMapper implements PathMapper<T> { public abstract T mapPath(EntityPath<S,E> entityPath); protected EntityMapper(GraphDatabaseContext graphDatabaseContext); abstract T mapPath(EntityPath<S,E> entityPath); @Override T mapPath(Path path); }### Answer:
@Test @Transactional public void entityMapperShouldForwardEntityPath() throws Exception { Person michael = new Person("Michael", 36).persist(); EntityMapper<Person, Person, String> mapper = new EntityMapper<Person, Person, String>(ctx) { @Override public String mapPath(EntityPath<Person, Person> entityPath) { return entityPath.<Person>startEntity().getName(); } }; String name = mapper.mapPath(new NodePath(michael.getPersistentState())); Assert.assertEquals(michael.getName(), name); } |
### Question:
PathMappingIterator { public <T> Iterable<T> mapPaths(final Iterable<Path> paths, final PathMapper<T> pathMapper) { assert paths != null; assert pathMapper != null; IterationController.IterationMode mode = getIterationControl(pathMapper); switch (mode) { case EAGER: case EAGER_STOP_ON_NULL: List<T> result = new ArrayList<T>(); try { for (Path path : paths) { T mapped = pathMapper.mapPath(path); if (mapped == null && mode == IterationController.IterationMode.EAGER_STOP_ON_NULL) break; result.add(mapped); } } finally { close(paths); } return result; case EAGER_IGNORE_RESULTS: try { for (Path path : paths) { pathMapper.mapPath(path); } } finally { close(paths); } return null; case LAZY: return new IterableWrapper<T, Path>(paths) { @Override protected T underlyingObjectToObject(Path path) { return pathMapper.mapPath(path); } }; default: throw new IllegalStateException("Unknown IterationControl " + mode); } } Iterable<T> mapPaths(final Iterable<Path> paths, final PathMapper<T> pathMapper); }### Answer:
@Test public void defaultPathMapperIsLazy() { final AtomicInteger counter=new AtomicInteger(); PathMapper<Integer> pathMapper = new PathMapper<Integer>() { @Override public Integer mapPath(Path path) { return counter.incrementAndGet(); } }; Iterable<Integer> result = new PathMappingIterator().mapPaths(paths(), pathMapper); assertEquals(0, counter.get()); for (Integer integer : result) ; assertEquals(PATHS_COUNT, counter.get()); }
@Test public void defaultPathCallbackIsEagerAndIgnoresResult() { final AtomicInteger counter=new AtomicInteger(); PathMapper.WithoutResult pathMapper = new PathMapper.WithoutResult() { @Override public void eachPath(Path path) { counter.incrementAndGet(); } }; Iterable<Void> result = new PathMappingIterator().mapPaths(paths(), pathMapper); assertEquals(PATHS_COUNT, counter.get()); assertNull("no result",result); assertEquals(PATHS_COUNT, counter.get()); } |
### Question:
Sequence { public SequenceNumber nextSequenceNumber() { synchronized (lock) { final long tick = updateCounter(); return new SequenceNumber(tick, sequenceToByteArray()); } } Sequence(final SequenceConfig config); SequenceNumber nextSequenceNumber(); }### Answer:
@Test public void nextSequenceNumberShouldIncreaseSequenceNumberLinearly() { final Sequence provider = new Sequence(useDefaults(65536)); final Map<Long, List<SequenceNumber>> groupedByTick = Stream.iterate(0, i -> i + 1) .limit(100) .map(i -> provider.nextSequenceNumber()) .collect(Collectors.groupingBy(SequenceNumber::getTimestamp)); assertFalse(groupedByTick.isEmpty()); for (Long tick : groupedByTick.keySet()) { final List<SequenceNumber> numbers = groupedByTick.get(tick); assertFalse(numbers.isEmpty()); int expectedSequenceNumber = 0; for (SequenceNumber number : numbers) { assertThat(number.getSequenceNumber(), is(toByteArray(expectedSequenceNumber))); expectedSequenceNumber++; } } }
@Test(expected = OutOfSequenceNumbersException.class) public void nextSequenceNumberShouldThrowOutOfSequenceNumbersExceptionIfPoolIsExhausted() { final SequenceConfig config = create(1) .withMaxWaitTime(0, TimeUnit.MILLISECONDS) .build(); final Sequence provider = new Sequence(config); provider.nextSequenceNumber(); provider.nextSequenceNumber(); provider.nextSequenceNumber(); provider.nextSequenceNumber(); }
@Test(expected = BackwardsClockDriftException.class) public void nextSequenceNumberShouldThrowBackwardsClockDriftExceptionIfDriftIsDetected() { final SequenceConfig config = SequenceConfig.create(65536) .withTimeProvider(new DriftingTimeProvider()) .build(); final Sequence provider = new Sequence(config); provider.nextSequenceNumber(); provider.nextSequenceNumber(); } |
### Question:
Base62Encoder implements Encoder<ByteBuffer, String> { @Override public String encode(final ByteBuffer unencodedData) { final int maxBytes = unencodedData.limit(); final StringBuilder sb = new StringBuilder(); int bitSource = nextByte(unencodedData); int unencodedBits = bitSource >> 2; int bitIndex = 1; int bitsRead = 6; boolean carryOverLsb = false; while (!bitsExhausted(bitsRead, maxBytes)) { carryOverLsb = appendBitsAsBase62Character(unencodedBits, sb); int bitsForAlignment; if (carryOverLsb) { unencodedBits &= BIT_MASK_LSB; bitsForAlignment = 5; } else { unencodedBits = 0; bitsForAlignment = 6; } for (int i = 0; i < bitsForAlignment; i++) { unencodedBits = appendBit(bitSource, unencodedBits, bitIndex); bitsRead++; bitIndex--; if (bitIndex == -1) { if (bitsExhausted(bitsRead, maxBytes)) { break; } bitSource = nextByte(unencodedData); bitIndex = 7; } } } while (bitIndex >= 0) { unencodedBits = appendBit(bitSource, unencodedBits, bitIndex); bitIndex--; } carryOverLsb = appendBitsAsBase62Character(unencodedBits, sb); if (carryOverLsb) { unencodedBits &= BIT_MASK_LSB; appendBitsAsBase62Character(unencodedBits, sb); } return sb.toString(); } @Override String encode(final ByteBuffer unencodedData); }### Answer:
@Test public void encodeWithNoRemainingBitsYieldsCorrectResult() { final ByteBuffer byteBuffer = ByteBuffer.allocate(6); byteBuffer .put((byte) 0x00) .put((byte) 0x00) .put((byte) 0x00) .put((byte) 0x00) .put((byte) 0x00) .put((byte) 0x01) .flip(); assertThat(encoder.encode(byteBuffer), is("AAAAAAAB")); }
@Test public void encodeShouldYieldValidBase62StringForPaperExample() { final ByteBuffer byteBuffer = ByteBuffer.allocate(3); byteBuffer .put((byte) 0x53) .put((byte) 0xFE) .put((byte) 0x92) .flip(); assertThat(encoder.encode(byteBuffer), is("U98kC")); }
@Test public void encodeWithSpecialCharacterAtEndPadsCorrectlyToNextCharacter() { final ByteBuffer byteBuffer = ByteBuffer.allocate(6); byteBuffer .put((byte) 0x07) .put((byte) 0x59) .put((byte) 0x06) .put((byte) 0x61) .put((byte) 0x47) .put((byte) 0xFE) .flip(); assertThat(encoder.encode(byteBuffer), is("B1kGYUf9A")); }
@Test public void encodeShouldYieldValidBase62CharacterSimpleSubstitution() { final ByteBuffer byteBuffer = ByteBuffer.allocate(1); byteBuffer .put((byte) 0x53) .flip(); assertThat(encoder.encode(byteBuffer), is("UD")); }
@Test public void encodeByteWithFiveLeadingSetOnesYieldsCorrectResult() { final ByteBuffer byteBuffer = ByteBuffer.allocate(1); byteBuffer .put((byte) 0xF9) .flip(); assertThat(encoder.encode(byteBuffer), is("9B")); final ByteBuffer byteBuffer2 = ByteBuffer.allocate(1); byteBuffer2 .put((byte) 0xF8) .flip(); assertThat(encoder.encode(byteBuffer2), is("9A")); }
@Test public void encodeByteWithFourLeadingOnesYieldsCorrectResult() { final ByteBuffer byteBuffer = ByteBuffer.allocate(1); byteBuffer .put((byte) 0xF0) .flip(); assertThat(encoder.encode(byteBuffer), is("8A")); }
@Test public void encodeByteWithZeroValuedRemainingBitsYieldsCorrectResult() { final ByteBuffer byteBuffer = ByteBuffer.allocate(1); byteBuffer .put((byte) 0xF8) .flip(); assertThat(encoder.encode(byteBuffer), is("9A")); } |
### Question:
Flake64L extends Flake64<Long> { @Override public Long nextId() { final SequenceNumber sequenceNumber = getSequence().nextSequenceNumber(); final ByteBuffer bb = (ByteBuffer) toByteBuffer(sequenceNumber); return encoder.encode(bb); } Flake64L(final TimeProvider timeProvider,
final WorkerIdProvider workerIdProvider); Flake64L(final TimeProvider timeProvider,
final WorkerIdProvider workerIdProvider,
final Encoder<ByteBuffer, Long> encoder); @Override Long nextId(); }### Answer:
@Test public void generatedIdsShouldBeLinearlyIncreasingAcrossTimeSlots() { List<Long> generatedIds = new ArrayList<>(); long started = System.nanoTime(); while (System.nanoTime() - started < 200_000_000L) { generatedIds.add(flake.nextId()); } assertFalse(generatedIds.isEmpty()); assertThatListIsStrictlyOrdered(generatedIds); }
@Test public void idsThatHaveBeenGeneratedASecondApartAlsoAreASecondApartInIdSpace() throws InterruptedException { Long id1 = flake.nextId(); Wait.delay(1, TimeUnit.SECONDS); Long id2 = flake.nextId(); long timestampFromId1 = id1 >> 22; long timestampFromId2 = id2 >> 22; long timeBetween = timestampFromId2 - timestampFromId1; assertTrue(timeBetween > 900L && timeBetween < 1_800L); } |
### Question:
AuditMessagePullFilter implements ObjectFilter { @Override public boolean shouldObjectBeSynced(Object object, String action) { AuditMessage auditMessage = (AuditMessage) object; return checkIfEntryAlreadyExists(auditMessage); } @Override boolean shouldObjectBeSynced(Object object, String action); }### Answer:
@Test public void shouldObjectBeSynced_shouldReturnTrueIfEntryAlreadyExists() { boolean fetched = auditMessagePullFilter.shouldObjectBeSynced(prepareDummyAuditMessage( EXISTING_ENTRY_UUID), SAMPLE_ACTION); Assert.assertTrue(fetched); }
@Test public void shouldObjectBeSynced_shouldReturnFalseIfEntryDoesNotExist() { boolean fetched = auditMessagePullFilter.shouldObjectBeSynced(prepareDummyAuditMessage( NEW_ENTRY_UUID2), SAMPLE_ACTION); Assert.assertFalse(fetched); } |
### Question:
RestrictConflictMergeBehaviourImpl implements MergeBehaviour<SyncObject> { @Override public MergeResult<SyncObject> resolveDiff(Class<? extends SyncObject> clazz, SyncObject local, SyncObject foreign) { return revolveConflict(local, foreign); } @Override MergeResult<SyncObject> resolveDiff(Class<? extends SyncObject> clazz, SyncObject local, SyncObject foreign); }### Answer:
@Test public void resolveDiff_shouldReturnSuccessAndChooseLocalIfOnlyLocalChanged() { SyncObject localObj = getSyncObject(SimpleObjectMother.createInstance(VALID_UUID, TEST_VALUE)); SyncObject foreignObj = getSyncObject(SimpleObjectMother.createInstance(VALID_UUID, TEST_VALID_HASHCODE_VALUE)); MergeResult actual = conflictMergeBehaviour.resolveDiff(SyncObject.class, localObj, foreignObj); Assert.assertTrue(actual instanceof MergeSuccess); Assert.assertEquals(MergeMessageEnum.LOCAL_SAVE_MESSAGE, actual.getMessage()); Assert.assertTrue(((MergeSuccess) actual).shouldUpdateLocal()); Assert.assertFalse(((MergeSuccess) actual).shouldUpdateForeign()); }
@Test public void resolveDiff_shouldReturnSuccessAndChooseForeignIfOnlyForeignChanged() { SyncObject localObj = getSyncObject(SimpleObjectMother.createInstance(VALID_UUID, TEST_VALID_HASHCODE_VALUE)); SyncObject foreignObj = getSyncObject(SimpleObjectMother.createInstance(VALID_UUID, TEST_VALUE_2)); MergeResult actual = conflictMergeBehaviour.resolveDiff(SyncObject.class, localObj, foreignObj); Assert.assertTrue(actual instanceof MergeSuccess); Assert.assertEquals(MergeMessageEnum.FOREIGN_SAVE_MESSAGE, actual.getMessage()); Assert.assertFalse(((MergeSuccess) actual).shouldUpdateLocal()); Assert.assertTrue(((MergeSuccess) actual).shouldUpdateForeign()); }
@Test public void resolveDiff_shouldReturnConflictWhenBothObjectsChanged() { SyncObject localObj = getSyncObject(SimpleObjectMother.createInstance(VALID_UUID, TEST_VALUE)); SyncObject foreignObj = getSyncObject(SimpleObjectMother.createInstance(VALID_UUID, TEST_VALUE_2)); MergeResult actual = conflictMergeBehaviour.resolveDiff(SyncObject.class, localObj, foreignObj); Assert.assertTrue(actual instanceof MergeConflict); Assert.assertEquals(MergeMessageEnum.CONFLICT, actual.getMessage()); }
@Test public void resolveDiff_shouldReturnSuccessAndChooseLocalIfParentHashcodeNotExist() { SyncObject localObj = getSyncObject(SimpleObjectMother.createInstance(INVALID_UUID, TEST_VALUE)); SyncObject foreignObj = getSyncObject(SimpleObjectMother.createInstance(INVALID_UUID, TEST_VALUE_2)); MergeResult actual = conflictMergeBehaviour.resolveDiff(SyncObject.class, localObj, foreignObj); Assert.assertTrue(actual instanceof MergeSuccess); Assert.assertEquals(MergeMessageEnum.LOCAL_SAVE_MESSAGE, actual.getMessage()); Assert.assertTrue(((MergeSuccess) actual).shouldUpdateLocal()); Assert.assertFalse(((MergeSuccess) actual).shouldUpdateForeign()); } |
### Question:
ConflictDetectionImpl implements ConflictDetection { @Override public boolean detectConflict(SimpleObject currentObject, SimpleObject newObject) { boolean conflictDetect = false; if (currentObject != null && newObject != null) { String currentHashCode = SyncHashcodeUtils.getHashcode(currentObject); String newHashCode = SyncHashcodeUtils.getHashcode(newObject); String objectUuid = currentObject.get(UUID_KEY); ParentObjectHashcode previousHashCode = parentObjectHashcodeService.getByObjectUuid(objectUuid); if (previousHashCode != null && (!previousHashCode.getHashcode().equalsIgnoreCase(newHashCode) || !previousHashCode.getHashcode().equalsIgnoreCase(currentHashCode))) { conflictDetect = true; } } return conflictDetect; } @Override boolean detectConflict(SimpleObject currentObject, SimpleObject newObject); }### Answer:
@Test public void detectConflict_shouldReturnFalseIfParentHashcodeNotExist() { SimpleObject currentObj = SimpleObjectMother.createInstance(INVALID_UUID, INVALID_HASHCODE_VALUE); SimpleObject newObj = SimpleObjectMother.createInstance(INVALID_UUID, INVALID_HASHCODE_VALUE); Assert.assertFalse(conflictDetection.detectConflict(currentObj, newObj)); }
@Test public void detectConflict_shouldReturnFalseIfObjectsHaveNotChanged() { SimpleObject currentObj = SimpleObjectMother.createInstance(VALID_UUID, VALID_HASHCODE_VALUE); SimpleObject newObj = SimpleObjectMother.createInstance(VALID_UUID, VALID_HASHCODE_VALUE); Assert.assertFalse(conflictDetection.detectConflict(currentObj, newObj)); }
@Test public void detectConflict_shouldReturnTrueIfCurrentObjectChanged() { SimpleObject currentObj = SimpleObjectMother.createInstance(VALID_UUID, INVALID_HASHCODE_VALUE); SimpleObject newObj = SimpleObjectMother.createInstance(VALID_UUID, VALID_HASHCODE_VALUE); Assert.assertTrue(conflictDetection.detectConflict(currentObj, newObj)); }
@Test public void detectConflict_shouldReturnTrueIfNewObjectChanged() { SimpleObject currentObj = SimpleObjectMother.createInstance(VALID_UUID, VALID_HASHCODE_VALUE); SimpleObject newObj = SimpleObjectMother.createInstance(VALID_UUID, INVALID_HASHCODE_VALUE); Assert.assertTrue(conflictDetection.detectConflict(currentObj, newObj)); } |
### Question:
AtomfeedEventConfigurationServiceImpl implements EventConfigurationService { @Override public EventConfiguration getEventConfigurationByCategory(SyncCategory categoryEnum) { FeedConfiguration feedConfiguration = feedConfigurationService .getFeedConfigurationByCategory(categoryEnum.getCategory()); return eventConfigurationMapper.map(feedConfiguration); } @Override EventConfiguration getEventConfigurationByCategory(SyncCategory categoryEnum); @Override String extractUuidFromResourceLinks(Map<String, String> eventResourceLinks, String eventCategory,
String preferredClient); }### Answer:
@Test public void getEventConfigurationByCategory_shouldReturnCorrectConfiguration() { EventConfiguration expected = new EventConfiguration(createPatientLinkTemplates()); EventConfiguration actual = atomFeedEventConfigurationService.getEventConfigurationByCategory( new SyncCategory(CategoryEnum.PATIENT.getCategory(), CategoryEnum.PATIENT.getClazz())); Assert.assertNotNull(actual); Assert.assertEquals(expected, actual); } |
### Question:
AtomfeedEventConfigurationServiceImpl implements EventConfigurationService { @Override public String extractUuidFromResourceLinks(Map<String, String> eventResourceLinks, String eventCategory, String preferredClient) { String uuid = extractBasedOnLinkTemplates(eventResourceLinks, eventCategory, preferredClient); if (StringUtils.isBlank(uuid)) { uuid = extractBasedOnResourceLinks(eventResourceLinks, preferredClient); } return uuid; } @Override EventConfiguration getEventConfigurationByCategory(SyncCategory categoryEnum); @Override String extractUuidFromResourceLinks(Map<String, String> eventResourceLinks, String eventCategory,
String preferredClient); }### Answer:
@Test public void extractUuidFromResourceLinks_shouldExtractUuidBasedOnLinkTemplate() { String category = CategoryEnum.PERSON_ADDRESS.getCategory(); Mockito.when(feedConfigurationService.getFeedConfigurationByCategory(category)) .thenReturn(createPersonAddressFeedConfiguration(true)); String uuid = atomFeedEventConfigurationService.extractUuidFromResourceLinks( createResourceLinks(true), category, REST_CLIENT); Assert.assertNotNull(uuid); Assert.assertEquals(ADDRESS_UUID, uuid); }
@Test public void extractUuidFromResourceLinks_shouldExtractUuidBasedOnResourceLink() { String category = CategoryEnum.PERSON_ADDRESS.getCategory(); Mockito.when(feedConfigurationService.getFeedConfigurationByCategory(category)) .thenReturn(createPersonAddressFeedConfiguration(false)); String uuid = atomFeedEventConfigurationService.extractUuidFromResourceLinks( createResourceLinks(false), category, null); Assert.assertNotNull(uuid); Assert.assertEquals(ADDRESS_UUID_FROM_OTHER, uuid); }
@Test public void extractUuidFromResourceLinks_shouldExtractUuidFromPreferredClient() { String category = CategoryEnum.PERSON_ADDRESS.getCategory(); Mockito.when(feedConfigurationService.getFeedConfigurationByCategory(category)) .thenReturn(createPersonAddressFeedConfiguration(true)); String uuid = atomFeedEventConfigurationService.extractUuidFromResourceLinks( createResourceLinks(true), category, OTHER_CLIENT); Assert.assertNotNull(uuid); Assert.assertEquals(ADDRESS_UUID_FROM_OTHER, uuid); }
@Test public void extractUuidFromResourceLinks_shouldExtractUuidFromFirstMatchingIfClientNotExist() { String category = CategoryEnum.PERSON_ADDRESS.getCategory(); Mockito.when(feedConfigurationService.getFeedConfigurationByCategory(category)) .thenReturn(createPersonAddressFeedConfiguration(true)); String uuid = atomFeedEventConfigurationService.extractUuidFromResourceLinks( createResourceLinks(true), category, NOT_EXIST_CLIENT); Assert.assertNotNull(uuid); Assert.assertEquals(ADDRESS_UUID, uuid); }
@Test public void extractUuidFromResourceLinks_shouldExtractUuidFromFirstMatchingIfClientNull() { String category = CategoryEnum.PERSON_ADDRESS.getCategory(); Mockito.when(feedConfigurationService.getFeedConfigurationByCategory(category)) .thenReturn(createPersonAddressFeedConfiguration(true)); String uuid = atomFeedEventConfigurationService.extractUuidFromResourceLinks( createResourceLinks(true), category, null); Assert.assertNotNull(uuid); Assert.assertEquals(ADDRESS_UUID, uuid); }
@Test public void extractUuidFromResourceLinks_shouldExtractUuidWhenMissingUuidPattern() { String category = CategoryEnum.PERSON_ADDRESS.getCategory(); Mockito.when(feedConfigurationService.getFeedConfigurationByCategory(category)) .thenReturn(createPersonAddressFeedConfiguration(true)); String uuid = atomFeedEventConfigurationService.extractUuidFromResourceLinks( createResourceLinks(true), category, CLIENT_WITH_DIFFERENT_PATTERN); Assert.assertNotNull(uuid); Assert.assertEquals(ADDRESS_UUID_FROM_DIFFERENT_CLIENT, uuid); } |
### Question:
MergeConflictServiceImpl extends BaseOpenmrsService implements MergeConflictService { @Override public MergeConflict save(MergeConflict mergeConflict) { return mergeConflictDao.save(mergeConflict); } @Override MergeConflict getById(Integer id); @Override MergeConflict getByUuid(String uuid); @Override MergeConflict save(MergeConflict mergeConflict); @Override void delete(MergeConflict mergeConflict, String reason); }### Answer:
@Test public void save_shouldSaveObject() { MergeConflict expected = MergeConflictMother.createInstance(MERGE_CONFLICT_ID); MergeConflict actual = mergeConflictService.save(mergeConflict); Assert.assertEquals(expected, actual); } |
### Question:
MergeConflictServiceImpl extends BaseOpenmrsService implements MergeConflictService { @Override public MergeConflict getById(Integer id) { return mergeConflictDao.getById(id); } @Override MergeConflict getById(Integer id); @Override MergeConflict getByUuid(String uuid); @Override MergeConflict save(MergeConflict mergeConflict); @Override void delete(MergeConflict mergeConflict, String reason); }### Answer:
@Test public void getById_shouldFetchCorrectObject() { MergeConflict expected = MergeConflictMother.createInstance(MERGE_CONFLICT_ID); MergeConflict actual = mergeConflictService.getById(MERGE_CONFLICT_ID); Assert.assertEquals(expected, actual); } |
### Question:
MergeConflictServiceImpl extends BaseOpenmrsService implements MergeConflictService { @Override public MergeConflict getByUuid(String uuid) { return mergeConflictDao.getByUuid(uuid); } @Override MergeConflict getById(Integer id); @Override MergeConflict getByUuid(String uuid); @Override MergeConflict save(MergeConflict mergeConflict); @Override void delete(MergeConflict mergeConflict, String reason); }### Answer:
@Test public void getByUuid_shouldFetchCorrectObject() { MergeConflict expected = MergeConflictMother.createInstance(MERGE_CONFLICT_ID); MergeConflict actual = mergeConflictService.getByUuid(MergeConflictMother.UUID); Assert.assertEquals(expected, actual); } |
### Question:
SyncAuditServiceImpl extends BaseOpenmrsService implements SyncAuditService { @Override public AuditMessage getMessageById(Integer id) throws APIException { return dao.getMessageById(id); } void setDao(SyncAuditDao dao); @Override AuditMessage getMessageByUuid(String uuid); @Override AuditMessage getMessageById(Integer id); @Override String getJsonMessageByUuid(String uuid); @Override String getJsonMessageById(Integer id); @Override String getPaginatedMessages(Integer page, Integer pageSize, Boolean success, String operation,
String resourceName, String creatorInstanceId); @Override AuditMessage saveAuditMessageDuringSync(AuditMessage auditMessage); @Override AuditMessage saveAuditMessage(AuditMessage auditMessage); @Override AuditMessage setNextAudit(AuditMessage current, AuditMessage next); @Override Set<String> getAllCreatorIds(); @Override AuditMessage getMessageByMergeConflictUuid(String uuid); @Override String getJsonMessage(AuditMessage message); }### Answer:
@Test public void getMessageById() throws ParseException { Integer id = 1; AuditMessage expected = prepareAuditMessage(true); when(dao.getMessageById(id)).thenReturn(expected); AuditMessage fetched = auditService.getMessageById(id); Assert.assertEquals(expected, fetched); } |
### Question:
SyncAuditServiceImpl extends BaseOpenmrsService implements SyncAuditService { @Override public AuditMessage getMessageByUuid(String uuid) throws APIException { return dao.getMessageByUuid(uuid); } void setDao(SyncAuditDao dao); @Override AuditMessage getMessageByUuid(String uuid); @Override AuditMessage getMessageById(Integer id); @Override String getJsonMessageByUuid(String uuid); @Override String getJsonMessageById(Integer id); @Override String getPaginatedMessages(Integer page, Integer pageSize, Boolean success, String operation,
String resourceName, String creatorInstanceId); @Override AuditMessage saveAuditMessageDuringSync(AuditMessage auditMessage); @Override AuditMessage saveAuditMessage(AuditMessage auditMessage); @Override AuditMessage setNextAudit(AuditMessage current, AuditMessage next); @Override Set<String> getAllCreatorIds(); @Override AuditMessage getMessageByMergeConflictUuid(String uuid); @Override String getJsonMessage(AuditMessage message); }### Answer:
@Test public void getMessageByUuid() throws ParseException { AuditMessage expected = prepareAuditMessage(true); when(dao.getMessageByUuid(AUDIT_UUID)).thenReturn(expected); AuditMessage fetched = auditService.getMessageByUuid(AUDIT_UUID); Assert.assertEquals(expected, fetched); } |
### Question:
SyncAuditServiceImpl extends BaseOpenmrsService implements SyncAuditService { @Override public String getJsonMessageById(Integer id) throws APIException, JsonParseException { AuditMessage auditMessage = dao.getMessageById(id); if (auditMessage == null) { return null; } else { return serializeResultsWithAuditMessage(auditMessage); } } void setDao(SyncAuditDao dao); @Override AuditMessage getMessageByUuid(String uuid); @Override AuditMessage getMessageById(Integer id); @Override String getJsonMessageByUuid(String uuid); @Override String getJsonMessageById(Integer id); @Override String getPaginatedMessages(Integer page, Integer pageSize, Boolean success, String operation,
String resourceName, String creatorInstanceId); @Override AuditMessage saveAuditMessageDuringSync(AuditMessage auditMessage); @Override AuditMessage saveAuditMessage(AuditMessage auditMessage); @Override AuditMessage setNextAudit(AuditMessage current, AuditMessage next); @Override Set<String> getAllCreatorIds(); @Override AuditMessage getMessageByMergeConflictUuid(String uuid); @Override String getJsonMessage(AuditMessage message); }### Answer:
@Test public void getJsonMessageById() throws Exception { when(dao.getMessageById(AUDIT_ID)).thenReturn(prepareAuditMessage(false)); String expected = readJsonFromFile(AUDIT_MESSAGE_JSON); String fetched = auditService.getJsonMessageById(AUDIT_ID) + System.getProperty("line.separator"); Assert.assertEquals(expected, fetched); } |
### Question:
AuditMessagePushFilter implements ObjectFilter { @Override public boolean shouldObjectBeSynced(Object object, String action) { AuditMessage auditMessage = (AuditMessage) object; return checkIfEntryDoesNotDescribeAuditMessage(auditMessage); } @Override boolean shouldObjectBeSynced(Object object, String action); }### Answer:
@Test public void shouldObjectBeSynced_shouldReturnTrueIfEntryDoesNotDescribeAuditMessage() { boolean fetched = auditMessagePushFilter.shouldObjectBeSynced(prepareDummyAuditMessage( SyncCategoryConstants.CATEGORY_PATIENT), SAMPLE_ACTION); Assert.assertTrue(fetched); }
@Test public void shouldObjectBeSynced_shouldReturnFalseIfEntryDescribesAuditMessage() { boolean fetched = auditMessagePushFilter.shouldObjectBeSynced(prepareDummyAuditMessage( SyncCategoryConstants.CATEGORY_AUDIT_MESSAGE), SAMPLE_ACTION); Assert.assertFalse(fetched); } |
### Question:
SyncAuditServiceImpl extends BaseOpenmrsService implements SyncAuditService { @Override public String getJsonMessageByUuid(String uuid) throws APIException, JsonParseException { AuditMessage auditMessage = dao.getMessageByUuid(uuid); if (auditMessage == null) { return null; } else { return serializeResultsWithAuditMessage(auditMessage); } } void setDao(SyncAuditDao dao); @Override AuditMessage getMessageByUuid(String uuid); @Override AuditMessage getMessageById(Integer id); @Override String getJsonMessageByUuid(String uuid); @Override String getJsonMessageById(Integer id); @Override String getPaginatedMessages(Integer page, Integer pageSize, Boolean success, String operation,
String resourceName, String creatorInstanceId); @Override AuditMessage saveAuditMessageDuringSync(AuditMessage auditMessage); @Override AuditMessage saveAuditMessage(AuditMessage auditMessage); @Override AuditMessage setNextAudit(AuditMessage current, AuditMessage next); @Override Set<String> getAllCreatorIds(); @Override AuditMessage getMessageByMergeConflictUuid(String uuid); @Override String getJsonMessage(AuditMessage message); }### Answer:
@Test public void getJsonMessageByUuid() throws Exception { when(dao.getMessageByUuid(AUDIT_UUID)).thenReturn(prepareAuditMessage(false)); String expected = readJsonFromFile(AUDIT_MESSAGE_JSON); String fetched = auditService.getJsonMessageByUuid(AUDIT_UUID) + System.getProperty("line.separator"); Assert.assertEquals(expected, fetched); } |
### Question:
SyncAuditServiceImpl extends BaseOpenmrsService implements SyncAuditService { @Override public String getPaginatedMessages(Integer page, Integer pageSize, Boolean success, String operation, String resourceName, String creatorInstanceId) throws APIException { PaginatedAuditMessages paginatedAuditMessages = dao.getPaginatedAuditMessages(page, pageSize, success, operation, resourceName, creatorInstanceId); return serializeResultsWithAuditMessage(paginatedAuditMessages); } void setDao(SyncAuditDao dao); @Override AuditMessage getMessageByUuid(String uuid); @Override AuditMessage getMessageById(Integer id); @Override String getJsonMessageByUuid(String uuid); @Override String getJsonMessageById(Integer id); @Override String getPaginatedMessages(Integer page, Integer pageSize, Boolean success, String operation,
String resourceName, String creatorInstanceId); @Override AuditMessage saveAuditMessageDuringSync(AuditMessage auditMessage); @Override AuditMessage saveAuditMessage(AuditMessage auditMessage); @Override AuditMessage setNextAudit(AuditMessage current, AuditMessage next); @Override Set<String> getAllCreatorIds(); @Override AuditMessage getMessageByMergeConflictUuid(String uuid); @Override String getJsonMessage(AuditMessage message); }### Answer:
@Test public void getPaginatedMessages() throws Exception { Integer page = 1; Integer pageSize = 100; PaginatedAuditMessages messages = preparePaginatedAuditMessages(); when(dao.getPaginatedAuditMessages(page, pageSize, null, "", "", "")) .thenReturn(messages); String expected = readJsonFromFile(PAGINATED_AUDIT_MESSAGE_RESPONSE_JSON); String fetched = auditService.getPaginatedMessages( page, pageSize, null, "", "", "") + System.getProperty("line.separator"); Assert.assertEquals(expected, fetched); } |
### Question:
ParentObjectHashcodeServiceImpl extends BaseOpenmrsService implements ParentObjectHashcodeService { @Override public ParentObjectHashcode save(ParentObjectHashcode newParentObjectHashcode) { ParentObjectHashcode parentObjectHashcode = getByObjectUuid(newParentObjectHashcode.getObjectUuid()); if (parentObjectHashcode != null) { parentObjectHashcode.setHashcode(newParentObjectHashcode.getHashcode()); } else { parentObjectHashcode = newParentObjectHashcode; } return parentObjectHashcodeDao.save(parentObjectHashcode); } @Override ParentObjectHashcode getById(Integer id); @Override ParentObjectHashcode getByUuid(String uuid); @Override ParentObjectHashcode getByObjectUuid(String objectUuid); @Override ParentObjectHashcode save(ParentObjectHashcode newParentObjectHashcode); @Override ParentObjectHashcode save(String uuid, String hashCode); @Override void delete(ParentObjectHashcode parentObjectHashcode, String reason); }### Answer:
@Test public void save_shouldSaveObject() { ParentObjectHashcode expected = ParentObjectHashcodeMother.createInstance(OBJECT_ID); ParentObjectHashcode actual = parentObjectHashcodeService.save(parentObjectHashcode); Assert.assertEquals(expected, actual); } |
### Question:
ParentObjectHashcodeServiceImpl extends BaseOpenmrsService implements ParentObjectHashcodeService { @Override public ParentObjectHashcode getById(Integer id) { return parentObjectHashcodeDao.getById(id); } @Override ParentObjectHashcode getById(Integer id); @Override ParentObjectHashcode getByUuid(String uuid); @Override ParentObjectHashcode getByObjectUuid(String objectUuid); @Override ParentObjectHashcode save(ParentObjectHashcode newParentObjectHashcode); @Override ParentObjectHashcode save(String uuid, String hashCode); @Override void delete(ParentObjectHashcode parentObjectHashcode, String reason); }### Answer:
@Test public void getById_shouldFetchCorrectObject() { ParentObjectHashcode expected = ParentObjectHashcodeMother.createInstance(OBJECT_ID); ParentObjectHashcode actual = parentObjectHashcodeService.getById(OBJECT_ID); Assert.assertEquals(expected, actual); } |
### Question:
ParentObjectHashcodeServiceImpl extends BaseOpenmrsService implements ParentObjectHashcodeService { @Override public ParentObjectHashcode getByUuid(String uuid) { return parentObjectHashcodeDao.getByUuid(uuid); } @Override ParentObjectHashcode getById(Integer id); @Override ParentObjectHashcode getByUuid(String uuid); @Override ParentObjectHashcode getByObjectUuid(String objectUuid); @Override ParentObjectHashcode save(ParentObjectHashcode newParentObjectHashcode); @Override ParentObjectHashcode save(String uuid, String hashCode); @Override void delete(ParentObjectHashcode parentObjectHashcode, String reason); }### Answer:
@Test public void getByUuid_shouldFetchCorrectObject() { ParentObjectHashcode expected = ParentObjectHashcodeMother.createInstance(OBJECT_ID); ParentObjectHashcode actual = parentObjectHashcodeService.getByUuid(ParentObjectHashcodeMother.UUID); Assert.assertEquals(expected, actual); } |
### Question:
ParentObjectHashcodeServiceImpl extends BaseOpenmrsService implements ParentObjectHashcodeService { @Override public ParentObjectHashcode getByObjectUuid(String objectUuid) { return parentObjectHashcodeDao.getByObjectUuid(objectUuid); } @Override ParentObjectHashcode getById(Integer id); @Override ParentObjectHashcode getByUuid(String uuid); @Override ParentObjectHashcode getByObjectUuid(String objectUuid); @Override ParentObjectHashcode save(ParentObjectHashcode newParentObjectHashcode); @Override ParentObjectHashcode save(String uuid, String hashCode); @Override void delete(ParentObjectHashcode parentObjectHashcode, String reason); }### Answer:
@Test public void getByObjectUuid_shouldFetchCorrectObject() { ParentObjectHashcode expected = ParentObjectHashcodeMother.createInstance(OBJECT_ID); ParentObjectHashcode actual = parentObjectHashcodeService.getByObjectUuid(ParentObjectHashcodeMother.OBJECT_UUID); Assert.assertEquals(expected, actual); } |
### Question:
AbstractSynchronizationService { protected List<String> determineActions(Object objToUpdate, Object baseObj) { List<String> result = new ArrayList<>(); if (baseObj instanceof BaseOpenmrsData && ((BaseOpenmrsData) baseObj).isVoided()) { result.add(ACTION_VOIDED); } if (objToUpdate == null) { result.add(0, ACTION_CREATED); } else { result.add(0, ACTION_UPDATED); } return result; } }### Answer:
@Test public void determineActions_shouldReturnCREATED() { List<String> actual = abstractSynchronizationService.determineActions( null, createPatientInstance(false)); Assert.assertTrue(actual.contains(SyncConstants.ACTION_CREATED)); }
@Test public void determineActions_shouldReturnUPDATED() { List<String> actual = abstractSynchronizationService.determineActions( createPatientInstance(false), createPatientInstance(false)); Assert.assertTrue(actual.contains(SyncConstants.ACTION_UPDATED)); }
@Test public void determineActions_shouldReturnVOIDED() { List<String> actual = abstractSynchronizationService.determineActions( createPatientInstance(false), createPatientInstance(true)); Assert.assertTrue(actual.contains(SyncConstants.ACTION_VOIDED)); } |
### Question:
NewIsTheBestMergeBehaviourImpl implements MergeBehaviour<SyncObject> { @Override public MergeResult<SyncObject> resolveDiff(Class<? extends SyncObject> clazz, SyncObject local, SyncObject foreign) { return resolveConflict(local, foreign); } @Override MergeResult<SyncObject> resolveDiff(Class<? extends SyncObject> clazz, SyncObject local, SyncObject foreign); }### Answer:
@Test public void resolveDiff_shouldReturnSuccessIfDateChangedNotExitAndChooseTheLocal() { SyncObject localObj = getSyncObject(SimpleObjectMother.createInstanceWithDateChanged (null, false, false)); SyncObject foreignObj = getSyncObject(SimpleObjectMother.createInstanceWithDateChanged( null, false, false)); MergeResult actual = newIsTheBestMergeBehaviour.resolveDiff(SyncObject.class, localObj, foreignObj); Assert.assertTrue(actual instanceof MergeSuccess); Assert.assertEquals(MergeMessageEnum.LOCAL_SAVE_MESSAGE, actual.getMessage()); Assert.assertTrue(((MergeSuccess) actual).shouldUpdateLocal()); Assert.assertFalse(((MergeSuccess) actual).shouldUpdateForeign()); }
@Test public void resolveDiff_shouldReturnSuccessIfOnlyLocalHasDateChanged() { SyncObject localObj = getSyncObject(SimpleObjectMother.createInstanceWithDateChanged( LATER_DATE, true, false)); SyncObject foreignObj = getSyncObject(SimpleObjectMother.createInstanceWithDateChanged( null, false, false)); MergeResult actual = newIsTheBestMergeBehaviour.resolveDiff(SyncObject.class, localObj, foreignObj); Assert.assertTrue(actual instanceof MergeSuccess); Assert.assertEquals(MergeMessageEnum.LOCAL_SAVE_MESSAGE, actual.getMessage()); Assert.assertTrue(((MergeSuccess) actual).shouldUpdateLocal()); Assert.assertFalse(((MergeSuccess) actual).shouldUpdateForeign()); }
@Test public void resolveDiff_shouldReturnSuccessAndChooseTheNewest() { SyncObject localObj = getSyncObject(SimpleObjectMother.createInstanceWithDateChanged( LATER_DATE, true, false)); SyncObject foreignObj = getSyncObject(SimpleObjectMother.createInstanceWithDateChanged( EARLIER_DATE, true, false)); MergeResult actual = newIsTheBestMergeBehaviour.resolveDiff(SyncObject.class, localObj, foreignObj); Assert.assertTrue(actual instanceof MergeSuccess); Assert.assertEquals(MergeMessageEnum.LOCAL_SAVE_MESSAGE, actual.getMessage()); Assert.assertTrue(((MergeSuccess) actual).shouldUpdateLocal()); Assert.assertFalse(((MergeSuccess) actual).shouldUpdateForeign()); }
@Test public void resolveDiff_shouldReturnSuccessAndChooseLocalIfDatesAreTheSame() { SyncObject localObj = getSyncObject(SimpleObjectMother.createInstanceWithDateChanged( EARLIER_DATE, true, false)); SyncObject foreignObj = getSyncObject(SimpleObjectMother.createInstanceWithDateChanged( EARLIER_DATE, true, false)); MergeResult actual = newIsTheBestMergeBehaviour.resolveDiff(SyncObject.class, localObj, foreignObj); Assert.assertTrue(actual instanceof MergeSuccess); Assert.assertEquals(MergeMessageEnum.LOCAL_SAVE_MESSAGE, actual.getMessage()); Assert.assertTrue(((MergeSuccess) actual).shouldUpdateLocal()); Assert.assertFalse(((MergeSuccess) actual).shouldUpdateForeign()); }
@Test public void resolveDiff_shouldReturnMergeConflictIfInvalidDateFormat() { SyncObject localObj = getSyncObject(SimpleObjectMother.createInstanceWithDateChanged( EARLIER_DATE, true, false)); SyncObject foreignObj = getSyncObject(SimpleObjectMother.createInstanceWithDateChanged( INVALID_DATE, true, false)); MergeResult actual = newIsTheBestMergeBehaviour.resolveDiff(SyncObject.class, localObj, foreignObj); Assert.assertTrue(actual instanceof MergeConflict); Assert.assertEquals(MergeMessageEnum.CONFLICT, actual.getMessage()); } |
### Question:
AtomfeedEventConfigurationMapperImpl implements EventConfigurationMapper<FeedConfiguration> { @Override public EventConfiguration map(FeedConfiguration feedConfiguration) { return new EventConfiguration(feedConfiguration.getLinkTemplates()); } @Override EventConfiguration map(FeedConfiguration feedConfiguration); }### Answer:
@Test public void map_shouldReturnCorrectEventConfiguration() { EventConfiguration expected = new EventConfiguration(createLinkTemplates()); EventConfiguration actual = eventConfigurationMapper.map(feedConfiguration); Assert.assertNotNull(actual); Assert.assertEquals(expected, actual); } |
### Question:
SyncUtils { public static boolean checkIfParamIsEventAction(String actionName) { try { EventAction.valueOf(actionName); } catch (IllegalArgumentException ex) { return false; } return true; } static Map<String, String> getLinks(String json); static String getParentBaseUrl(String clientName); static String getSpecificClientAddress(String clientName); static boolean clientHasSpecificAddress(String clientName, OpenMRSSyncInstance instance); static String getLocalBaseUrl(); static String getLocalInstanceId(); static String getPullUrl(Map<String, String> resourceLinks, String clientName, OpenMRSSyncInstance instance); static String getPushUrl(Map<String, String> resourceLinks, String clientName, OpenMRSSyncInstance instance); static String getClientSpecificLogin(String clientName); static String getClientSpecificPassword(String clientName); static boolean clientHasSpecificCridentials(String clientName, OpenMRSSyncInstance instance); static String getClientLogin(String clientName, OpenMRSSyncInstance instance); static String getClientPassword(String clientName, OpenMRSSyncInstance instance); static String getValueOfAtomfeedEventTag(List tags, AtomfeedTagContent atomfeedTagContent); static String getFullUrl(String baseAddress, String path); static String selectAppropriateClientName(Map<String, String> availableResourceLinks, String category,
SyncOperation operation); static String getClassPreferredClient(ClassConfiguration classConfiguration); static String getGlobalPreferredClient(); static String extractUUIDFromResourceLinks(Map<String, String> resourceLinks, String category,
String preferredClient); static boolean compareLocalAndPulled(String clientName, String category, Object from, Object dest); static String prettySerialize(Map<T, T> map); static String serialize(T object); static T deserialize(String object, Class<T> clazz); static Map<String, String> deserializeJsonToStringsMap(String json); static boolean checkIfParamIsFeedFilter(Object tag); static boolean checkIfParamIsEventAction(String actionName); static SyncConfigurationService getSyncConfigurationService(); static Gson createDefaultGson(); static MergeBehaviour getMergeBehaviour(); static String getEventHandlerName(); static boolean parentInstanceUriIsEmpty(); static boolean isDeleteAction(String action); static boolean isUpdateAction(String action); static boolean isCreateAction(String action); static boolean isUnauthorizedException(Throwable e); static boolean isAuditMessageCategory(SyncCategory category); }### Answer:
@Test public void checkIfParamIsEventAction_shouldReturnTrueIfParamIsEventAction() { Assert.assertTrue(SyncUtils.checkIfParamIsEventAction("UPDATED")); Assert.assertTrue(SyncUtils.checkIfParamIsEventAction("CREATED")); Assert.assertTrue(SyncUtils.checkIfParamIsEventAction("RETIRED")); Assert.assertTrue(SyncUtils.checkIfParamIsEventAction("UNRETIRED")); Assert.assertTrue(SyncUtils.checkIfParamIsEventAction("UNVOIDED")); Assert.assertTrue(SyncUtils.checkIfParamIsEventAction("DELETED")); }
@Test public void checkIfParamIsEventAction_shouldReturnFalseIfParamIsNotEventAction() { Assert.assertFalse(SyncUtils.checkIfParamIsEventAction("updated")); Assert.assertFalse(SyncUtils.checkIfParamIsEventAction("somethingElse")); } |
### Question:
SyncUtils { public static String getValueOfAtomfeedEventTag(List tags, AtomfeedTagContent atomfeedTagContent) { for (Object tag : tags) { if (checkIfParamIsFeedFilter(tag)) { continue; } String tagValue = getTagValue(tag); boolean isTagEventAction = checkIfParamIsEventAction(tagValue); if (atomfeedTagContent == AtomfeedTagContent.EVENT_ACTION && isTagEventAction) { return tagValue; } if (atomfeedTagContent == AtomfeedTagContent.CATEGORY && !isTagEventAction) { return tagValue; } } throw new SyncException(String.format("'%s' enum not found in tag list", atomfeedTagContent.name())); } static Map<String, String> getLinks(String json); static String getParentBaseUrl(String clientName); static String getSpecificClientAddress(String clientName); static boolean clientHasSpecificAddress(String clientName, OpenMRSSyncInstance instance); static String getLocalBaseUrl(); static String getLocalInstanceId(); static String getPullUrl(Map<String, String> resourceLinks, String clientName, OpenMRSSyncInstance instance); static String getPushUrl(Map<String, String> resourceLinks, String clientName, OpenMRSSyncInstance instance); static String getClientSpecificLogin(String clientName); static String getClientSpecificPassword(String clientName); static boolean clientHasSpecificCridentials(String clientName, OpenMRSSyncInstance instance); static String getClientLogin(String clientName, OpenMRSSyncInstance instance); static String getClientPassword(String clientName, OpenMRSSyncInstance instance); static String getValueOfAtomfeedEventTag(List tags, AtomfeedTagContent atomfeedTagContent); static String getFullUrl(String baseAddress, String path); static String selectAppropriateClientName(Map<String, String> availableResourceLinks, String category,
SyncOperation operation); static String getClassPreferredClient(ClassConfiguration classConfiguration); static String getGlobalPreferredClient(); static String extractUUIDFromResourceLinks(Map<String, String> resourceLinks, String category,
String preferredClient); static boolean compareLocalAndPulled(String clientName, String category, Object from, Object dest); static String prettySerialize(Map<T, T> map); static String serialize(T object); static T deserialize(String object, Class<T> clazz); static Map<String, String> deserializeJsonToStringsMap(String json); static boolean checkIfParamIsFeedFilter(Object tag); static boolean checkIfParamIsEventAction(String actionName); static SyncConfigurationService getSyncConfigurationService(); static Gson createDefaultGson(); static MergeBehaviour getMergeBehaviour(); static String getEventHandlerName(); static boolean parentInstanceUriIsEmpty(); static boolean isDeleteAction(String action); static boolean isUpdateAction(String action); static boolean isCreateAction(String action); static boolean isUnauthorizedException(Throwable e); static boolean isAuditMessageCategory(SyncCategory category); }### Answer:
@Test public void getValueOfAtomfeedEventTag_shouldReturnCategoryDespiteItsOrderInList() { final String expected = "patient"; String result1 = SyncUtils.getValueOfAtomfeedEventTag(prepareDummyAtomfeedTags1(), AtomfeedTagContent.CATEGORY); String result2 = SyncUtils.getValueOfAtomfeedEventTag(prepareDummyAtomfeedTags2(), AtomfeedTagContent.CATEGORY); Assert.assertEquals(expected, result1); Assert.assertEquals(expected, result2); }
@Test public void getValueOfAtomfeedEventTag_shouldReturnEventActionDespiteItsOrderInList() { final String expected = "CREATED"; String result1 = SyncUtils.getValueOfAtomfeedEventTag(prepareDummyAtomfeedTags1(), AtomfeedTagContent.EVENT_ACTION); String result2 = SyncUtils.getValueOfAtomfeedEventTag(prepareDummyAtomfeedTags2(), AtomfeedTagContent.EVENT_ACTION); Assert.assertEquals(expected, result1); Assert.assertEquals(expected, result2); } |
### Question:
SyncUtils { public static String selectAppropriateClientName(Map<String, String> availableResourceLinks, String category, SyncOperation operation) { ClassConfiguration classConfiguration = getSyncConfigurationService().getClassConfiguration(category, operation); String preferredClient = getClassPreferredClient(classConfiguration); if (StringUtils.isBlank(preferredClient)) { preferredClient = getGlobalPreferredClient(); } if (availableResourceLinks.containsKey(preferredClient)) { return preferredClient; } else { return getFirstKey(availableResourceLinks); } } static Map<String, String> getLinks(String json); static String getParentBaseUrl(String clientName); static String getSpecificClientAddress(String clientName); static boolean clientHasSpecificAddress(String clientName, OpenMRSSyncInstance instance); static String getLocalBaseUrl(); static String getLocalInstanceId(); static String getPullUrl(Map<String, String> resourceLinks, String clientName, OpenMRSSyncInstance instance); static String getPushUrl(Map<String, String> resourceLinks, String clientName, OpenMRSSyncInstance instance); static String getClientSpecificLogin(String clientName); static String getClientSpecificPassword(String clientName); static boolean clientHasSpecificCridentials(String clientName, OpenMRSSyncInstance instance); static String getClientLogin(String clientName, OpenMRSSyncInstance instance); static String getClientPassword(String clientName, OpenMRSSyncInstance instance); static String getValueOfAtomfeedEventTag(List tags, AtomfeedTagContent atomfeedTagContent); static String getFullUrl(String baseAddress, String path); static String selectAppropriateClientName(Map<String, String> availableResourceLinks, String category,
SyncOperation operation); static String getClassPreferredClient(ClassConfiguration classConfiguration); static String getGlobalPreferredClient(); static String extractUUIDFromResourceLinks(Map<String, String> resourceLinks, String category,
String preferredClient); static boolean compareLocalAndPulled(String clientName, String category, Object from, Object dest); static String prettySerialize(Map<T, T> map); static String serialize(T object); static T deserialize(String object, Class<T> clazz); static Map<String, String> deserializeJsonToStringsMap(String json); static boolean checkIfParamIsFeedFilter(Object tag); static boolean checkIfParamIsEventAction(String actionName); static SyncConfigurationService getSyncConfigurationService(); static Gson createDefaultGson(); static MergeBehaviour getMergeBehaviour(); static String getEventHandlerName(); static boolean parentInstanceUriIsEmpty(); static boolean isDeleteAction(String action); static boolean isUpdateAction(String action); static boolean isCreateAction(String action); static boolean isUnauthorizedException(Throwable e); static boolean isAuditMessageCategory(SyncCategory category); }### Answer:
@Test public void selectAppropriateClientName_shouldReturnClassClientIfExist() throws Exception { String expected = LOCATION_PREFERRED_CLIENT; String actual = SyncUtils.selectAppropriateClientName(prepareDummyLinksTemplate(), "location", SyncOperation.PULL); Assert.assertNotNull(actual); Assert.assertEquals(expected, actual); }
@Test public void selectAppropriateClientName_shouldReturnFirstFromLinkTemplateIfGlobalAndClassNotExist() throws Exception { Mockito.when(administrationService.getGlobalProperty(SyncConstants.RESOURCE_PREFERRED_CLIENT, SyncConstants.DEFAULT_SYNC_2_CLIENT)).thenReturn(null); String expected = SyncConstants.FHIR_CLIENT; String actual = SyncUtils.selectAppropriateClientName(prepareDummyLinksTemplate(), "observation", SyncOperation.PULL); Assert.assertNotNull(actual); Assert.assertEquals(expected, actual); }
@Test public void selectAppropriateClientName_shouldReturnGlobalClientIfClassClientNotExist() throws Exception { String expected = GLOBAL_CLIENT; String actual = SyncUtils.selectAppropriateClientName(prepareDummyLinksTemplate(), "observation", SyncOperation.PUSH); Assert.assertNotNull(actual); Assert.assertEquals(expected, actual); } |
### Question:
SimpleObjectSerializationUtils { public static String serialize(SimpleObject simpleObject) { SimpleObjectMessageConverter converter = new SimpleObjectMessageConverter(); return converter.convertToJson(simpleObject); } private SimpleObjectSerializationUtils(); static String serialize(SimpleObject simpleObject); static SimpleObject deserialize(String simpleObject); static SimpleObject clone(SimpleObject simpleObject); }### Answer:
@Test public void serialize_shouldCreateValidJson() { String expected = SyncConfigurationUtils.readResourceFile(EXPECTED_SIMPLE_OBJECT_FILE); SimpleObject simpleObject = SimpleObjectMother.createInstanceWithDateChanged( TEST_DATE_CHANGE, true, false); String actual = SimpleObjectSerializationUtils.serialize(simpleObject); actual += System.getProperty("line.separator"); Assert.assertNotNull(actual); Assert.assertEquals(expected, actual); } |
### Question:
SimpleObjectSerializationUtils { public static SimpleObject deserialize(String simpleObject) { try { return SimpleObject.parseJson(simpleObject); } catch (IOException e) { throw new SerializationException("IOException while deserialize object data", e); } } private SimpleObjectSerializationUtils(); static String serialize(SimpleObject simpleObject); static SimpleObject deserialize(String simpleObject); static SimpleObject clone(SimpleObject simpleObject); }### Answer:
@Test public void deserialize_shouldCreateValidObject() { SimpleObject expected = SimpleObjectMother.createInstanceWithDateChanged( TEST_DATE_CHANGE, true, true); String json = SyncConfigurationUtils.readResourceFile(EXPECTED_SIMPLE_OBJECT_FILE); SimpleObject actual = SimpleObjectSerializationUtils.deserialize(json); Assert.assertNotNull(actual); Assert.assertEquals(expected, actual); } |
### Question:
SimpleObjectSerializationUtils { public static SimpleObject clone(SimpleObject simpleObject) { String stringRepresentation = serialize(simpleObject); return deserialize(stringRepresentation); } private SimpleObjectSerializationUtils(); static String serialize(SimpleObject simpleObject); static SimpleObject deserialize(String simpleObject); static SimpleObject clone(SimpleObject simpleObject); }### Answer:
@Test public void cloneMethod_shouldCorrectlyCloneObject() { SimpleObject expected = SimpleObjectMother.createInstanceWithDateChanged( TEST_DATE_CHANGE, true, true); SimpleObject actual = SimpleObjectSerializationUtils.clone(expected); Assert.assertNotNull(actual); Assert.assertEquals(expected, actual); } |
### Question:
SyncConfigurationUtils { public static String readResourceFile(String file) throws SyncException { try (InputStream in = SyncUtils.class.getClassLoader().getResourceAsStream(file)) { if (in == null) { throw new SyncException("Resource '" + file + "' doesn't exist"); } return IOUtils.toString(in, "UTF-8"); } catch (IOException e) { throw new SyncException(e); } } static void checkIfConfigurationIsValid(); static String readResourceFile(String file); static String readResourceFileAbsolutePath(String file); static SyncConfiguration parseJsonFileToSyncConfiguration(String path, ResourcePathType absolutePath); static SyncConfiguration parseJsonStringToSyncConfiguration(String value); static boolean isValidateJson(String json); static String writeSyncConfigurationToJsonString(SyncConfiguration syncConfiguration); static void writeSyncConfigurationToJsonFile(SyncConfiguration syncConfigurations, String absolutePath); static boolean resourceFileExists(String path); static boolean customConfigExists(String path); static ClientConfiguration getClientConfiguration(String clientName); }### Answer:
@Test public void readResourceFile_shouldReadSampleFile() throws SyncException { final String sampleResourcePath = "sampleTextFile.txt"; final String expectedResult = "sampleContent"; String result = readResourceFile(sampleResourcePath); Assert.assertEquals(result, expectedResult); }
@Test(expected = SyncException.class) public void readResourceFile_shouldThrowIoExceptionIfFileDoesNotExist() throws SyncException { readResourceFile(NOT_EXISTING_FILE_PATH); }
@Test public void serializeMapToPrettyJson_shouldSerializeMapWithStrings() throws SyncException { Assert.assertEquals(readResourceFile(SAMPLE_PRETTY_SERIALIZED_MAP), prettySerialize(createSampleMap())); }
@Test public void serialize_shouldSerializeMapToJson() throws SyncException { Assert.assertEquals(readResourceFile(SAMPLE_SERIALIZED_MAP), serialize(createSampleMap())); }
@Test public void deserializeJsonToStringsMap_shouldDeserializeMapWithStrings() throws SyncException { Assert.assertEquals(createSampleMap(), SyncUtils.deserializeJsonToStringsMap(readResourceFile(SAMPLE_SERIALIZED_MAP))); } |
### Question:
SyncConfigurationUtils { public static SyncConfiguration parseJsonFileToSyncConfiguration(String path, ResourcePathType absolutePath) { ObjectMapper mapper = new ObjectMapper(); try { String resourceFile = absolutePath.equals(ABSOLUTE) ? readResourceFileAbsolutePath(path) : readResourceFile(path); return mapper.readValue(resourceFile, SyncConfiguration.class); } catch (IOException e) { throw new SyncException(e); } } static void checkIfConfigurationIsValid(); static String readResourceFile(String file); static String readResourceFileAbsolutePath(String file); static SyncConfiguration parseJsonFileToSyncConfiguration(String path, ResourcePathType absolutePath); static SyncConfiguration parseJsonStringToSyncConfiguration(String value); static boolean isValidateJson(String json); static String writeSyncConfigurationToJsonString(SyncConfiguration syncConfiguration); static void writeSyncConfigurationToJsonFile(SyncConfiguration syncConfigurations, String absolutePath); static boolean resourceFileExists(String path); static boolean customConfigExists(String path); static ClientConfiguration getClientConfiguration(String clientName); }### Answer:
@Test public void parseJsonFileToSyncConfiguration_shouldCorrectlyParseSampleConfiguration() throws SyncException { SyncConfiguration result = parseJsonFileToSyncConfiguration(SAMPLE_SYNC_CONFIGURATION_PATH, RELATIVE); Assert.assertEquals(EXPECTED_CONFIGURATION, result); }
@Test(expected = SyncException.class) public void parseJsonFileToSyncConfiguration_shouldThrowJsonParseException() throws SyncException { parseJsonFileToSyncConfiguration(INCORRECT_SYNC_CONFIGURATION_PATH, RELATIVE); } |
### Question:
SyncConfigurationUtils { public static boolean resourceFileExists(String path) { InputStream in = SyncUtils.class.getClassLoader().getResourceAsStream(path); return in != null; } static void checkIfConfigurationIsValid(); static String readResourceFile(String file); static String readResourceFileAbsolutePath(String file); static SyncConfiguration parseJsonFileToSyncConfiguration(String path, ResourcePathType absolutePath); static SyncConfiguration parseJsonStringToSyncConfiguration(String value); static boolean isValidateJson(String json); static String writeSyncConfigurationToJsonString(SyncConfiguration syncConfiguration); static void writeSyncConfigurationToJsonFile(SyncConfiguration syncConfigurations, String absolutePath); static boolean resourceFileExists(String path); static boolean customConfigExists(String path); static ClientConfiguration getClientConfiguration(String clientName); }### Answer:
@Test public void resourceFileExists_exist() throws SyncException { Assert.assertTrue(resourceFileExists(SAMPLE_SYNC_CONFIGURATION_PATH)); }
@Test public void resourceFileExists_notExist() throws SyncException { Assert.assertFalse(resourceFileExists(NOT_EXISTING_FILE_PATH)); } |
### Question:
SyncClient { public Object pullData(SyncCategory category, String clientName, String resourceUrl, OpenMRSSyncInstance instance) { Object result = null; setUpCredentials(clientName, instance); ClientHelper clientHelper = ClientHelperFactory.createClient(clientName); prepareRestTemplate(clientHelper); String destinationUrl = getDestinationUri(instance, clientName); try { result = retrieveObject(category, resourceUrl, destinationUrl, clientName, instance); } catch (HttpClientErrorException e) { if (e.getStatusCode().equals(HttpStatus.UNAUTHORIZED)) { throw new SyncException("Unauthorized error during reading parent object: ", e); } if (!e.getStatusCode().equals(HttpStatus.NOT_FOUND)) { throw new SyncException("Error during reading local object: ", e); } } catch (URISyntaxException e) { LOGGER.error(e.getMessage()); } return result; } Object pullData(SyncCategory category, String clientName, String resourceUrl, OpenMRSSyncInstance instance); ResponseEntity<String> pushData(SyncCategory category, Object object, String clientName,
String resourceUrl, String action, OpenMRSSyncInstance instance); }### Answer:
@Test public void pullDataFromParent_shouldCallRestClient() { SyncClient resourceManager = new SyncClient(); Object pulledObject = resourceManager.pullData(PATIENT_CATEGORY, REST_CLIENT_KEY, REST_FULL_RESOURCE_URL, PARENT); assertThat((Patient) pulledObject, is(expectedPatient)); }
@Test public void pullDataFromParent_shouldCallFHIRClient() { SyncClient resourceManager = new SyncClient(); Object pulledObject = resourceManager.pullData(PATIENT_CATEGORY, FHIR_CLIENT_KEY, FHIR_FULL_RESOURCE_URL, PARENT); assertThat((Patient) pulledObject, is(expectedPatient)); } |
### Question:
RESTClientHelper implements ClientHelper { @Override public ClientHttpEntity retrieveRequest(String url) throws URISyntaxException { return new ClientHttpEntity(HttpMethod.GET, new URI(url)); } @Override ClientHttpEntity retrieveRequest(String url); @Override ClientHttpEntity createRequest(String url, Object object); @Override ClientHttpEntity deleteRequest(String url, String uuid); @Override ClientHttpEntity updateRequest(String url, Object object); @Override Class resolveClassByCategory(String category); @Override List<ClientHttpRequestInterceptor> getCustomInterceptors(String username, String password); @Override List<HttpMessageConverter<?>> getCustomMessageConverter(); @Override boolean compareResourceObjects(String category, Object from, Object dest); @Override Object convertToObject(String formattedData, Class<?> clazz); @Override String convertToFormattedData(Object object); @Override Object convertToOpenMrsObject(Object o, String category); }### Answer:
@Test public void retrieveRequest() throws Exception { ClientHttpEntity expected = new ClientHttpEntity(HttpMethod.GET, URI.create(TEST_URI)); RESTClientHelper restClientHelper = new RESTClientHelper(); assertEquals(expected, restClientHelper.retrieveRequest(TEST_URI)); } |
### Question:
RESTClientHelper implements ClientHelper { @Override public ClientHttpEntity createRequest(String url, Object object) throws URISyntaxException { if (object instanceof SimpleObject) { getRestResourceConverter().convertObject(url, object); } return new ClientHttpEntity<String>(convertToFormattedData(object), HttpMethod.POST, new URI(url)); } @Override ClientHttpEntity retrieveRequest(String url); @Override ClientHttpEntity createRequest(String url, Object object); @Override ClientHttpEntity deleteRequest(String url, String uuid); @Override ClientHttpEntity updateRequest(String url, Object object); @Override Class resolveClassByCategory(String category); @Override List<ClientHttpRequestInterceptor> getCustomInterceptors(String username, String password); @Override List<HttpMessageConverter<?>> getCustomMessageConverter(); @Override boolean compareResourceObjects(String category, Object from, Object dest); @Override Object convertToObject(String formattedData, Class<?> clazz); @Override String convertToFormattedData(Object object); @Override Object convertToOpenMrsObject(Object o, String category); }### Answer:
@Test public void createRequest() throws Exception { Patient patient = new Patient(); SimpleObject simpleObject = getSimpleObject(patient); String json = (new SimpleObjectMessageConverter()).convertToJson(simpleObject); ClientHttpEntity expected = new ClientHttpEntity<String>(json, HttpMethod.POST, URI.create(TEST_URI)); assertEquals(expected, restClientHelper.createRequest(TEST_URI, simpleObject)); } |
### Question:
RESTClientHelper implements ClientHelper { @Override public ClientHttpEntity deleteRequest(String url, String uuid) throws URISyntaxException { url += "/" + uuid; return new ClientHttpEntity<String>(uuid, HttpMethod.DELETE, new URI(url)); } @Override ClientHttpEntity retrieveRequest(String url); @Override ClientHttpEntity createRequest(String url, Object object); @Override ClientHttpEntity deleteRequest(String url, String uuid); @Override ClientHttpEntity updateRequest(String url, Object object); @Override Class resolveClassByCategory(String category); @Override List<ClientHttpRequestInterceptor> getCustomInterceptors(String username, String password); @Override List<HttpMessageConverter<?>> getCustomMessageConverter(); @Override boolean compareResourceObjects(String category, Object from, Object dest); @Override Object convertToObject(String formattedData, Class<?> clazz); @Override String convertToFormattedData(Object object); @Override Object convertToOpenMrsObject(Object o, String category); }### Answer:
@Test public void deleteRequest() throws Exception { ClientHttpEntity expected = new ClientHttpEntity<String>(TEST_PATIENT_UUID, HttpMethod.DELETE, URI.create(TEST_URI + "/" + TEST_PATIENT_UUID)); RESTClientHelper restClientHelper = new RESTClientHelper(); assertEquals(expected, restClientHelper.deleteRequest(TEST_URI, TEST_PATIENT_UUID)); } |
### Question:
RESTClientHelper implements ClientHelper { @Override public ClientHttpEntity updateRequest(String url, Object object) throws URISyntaxException { if (object instanceof AuditMessage) { url += "/" + ((AuditMessage) object).getUuid(); return new ClientHttpEntity<String>(convertToFormattedData(object), HttpMethod.POST, new URI(url)); } else { getRestResourceConverter().convertObject(url, object); url += "/" + ((SimpleObject) object).get("uuid"); } return new ClientHttpEntity<String>(convertToFormattedData(object), HttpMethod.POST, new URI(url)); } @Override ClientHttpEntity retrieveRequest(String url); @Override ClientHttpEntity createRequest(String url, Object object); @Override ClientHttpEntity deleteRequest(String url, String uuid); @Override ClientHttpEntity updateRequest(String url, Object object); @Override Class resolveClassByCategory(String category); @Override List<ClientHttpRequestInterceptor> getCustomInterceptors(String username, String password); @Override List<HttpMessageConverter<?>> getCustomMessageConverter(); @Override boolean compareResourceObjects(String category, Object from, Object dest); @Override Object convertToObject(String formattedData, Class<?> clazz); @Override String convertToFormattedData(Object object); @Override Object convertToOpenMrsObject(Object o, String category); }### Answer:
@Test public void updateRequest() throws Exception { Patient patient = new Patient(); patient.setUuid(TEST_PATIENT_UUID); SimpleObject simpleObject = getSimpleObject(patient); String json = (new SimpleObjectMessageConverter()).convertToJson(simpleObject); ClientHttpEntity expected = new ClientHttpEntity<String>(json, HttpMethod.POST, URI.create(TEST_URI + "/" + TEST_PATIENT_UUID)); assertEquals(expected, restClientHelper.updateRequest(TEST_URI, simpleObject)); } |
### Question:
RESTClientHelper implements ClientHelper { @Override public Class resolveClassByCategory(String category) { if (category.equalsIgnoreCase(CATEGORY_AUDIT_MESSAGE)) { return AuditMessage.class; } return SimpleObject.class; } @Override ClientHttpEntity retrieveRequest(String url); @Override ClientHttpEntity createRequest(String url, Object object); @Override ClientHttpEntity deleteRequest(String url, String uuid); @Override ClientHttpEntity updateRequest(String url, Object object); @Override Class resolveClassByCategory(String category); @Override List<ClientHttpRequestInterceptor> getCustomInterceptors(String username, String password); @Override List<HttpMessageConverter<?>> getCustomMessageConverter(); @Override boolean compareResourceObjects(String category, Object from, Object dest); @Override Object convertToObject(String formattedData, Class<?> clazz); @Override String convertToFormattedData(Object object); @Override Object convertToOpenMrsObject(Object o, String category); }### Answer:
@Test public void resolveClassByCategory() { RESTClientHelper restClientHelper = new RESTClientHelper(); assertEquals(SimpleObject.class, restClientHelper.resolveClassByCategory(CATEGORY_PATIENT)); assertEquals(SimpleObject.class, restClientHelper.resolveClassByCategory(CATEGORY_VISIT)); assertEquals(AuditMessage.class, restClientHelper.resolveClassByCategory(CATEGORY_AUDIT_MESSAGE)); } |
### Question:
LazyCachingSupplier implements Supplier<T> { public static <T> LazyCachingSupplier<T> lazyCaching(Supplier<T> supplier) { return new LazyCachingSupplier<>(supplier); } private LazyCachingSupplier(Supplier<T> supplier); @Override T get(); static LazyCachingSupplier<T> lazyCaching(Supplier<T> supplier); }### Answer:
@Test public void testSuppliersGetIsNotCalledOnInitialization() { LazyCachingSupplier.lazyCaching(() -> { fail("Should never be called"); return "never"; }); } |
### Question:
MessageListCollector { public static Collector<Message, ?, MessageList> toMessageList() { return Collector.of(MessageList::new, MessageList::add, addAll()); } private MessageListCollector(); static Collector<Message, ?, MessageList> toMessageList(); }### Answer:
@Test public void testToMessageList_Parallel() { MessageList sortedMessageList = Stream.of(Message.newInfo("A", "bla"), Message.newError("B", "blubb")) .parallel() .collect(MessageListCollector.toMessageList()); assertThat(sortedMessageList, hasSize(2)); assertThat(sortedMessageList, hasInfoMessage("A")); assertThat(sortedMessageList, hasErrorMessage("B")); List<String> codes = sortedMessageList.stream().map(Message::getCode).collect(toList()); assertThat(codes, contains("A", "B")); }
@Test public void testToMessageList() { MessageList emptyMessageList = Stream.<Message> empty().collect(toMessageList()); assertThat(emptyMessageList, is(emptyMessageList())); MessageList singleMessageList = Stream.of(Message.newError("A", "bla")) .collect(MessageListCollector.toMessageList()); assertThat(singleMessageList, hasSize(1)); MessageList sortedMessageList = Stream.of(Message.newInfo("A", "bla"), Message.newError("B", "blubb")) .collect(MessageListCollector.toMessageList()); assertThat(sortedMessageList, hasSize(2)); assertThat(sortedMessageList, hasInfoMessage("A")); assertThat(sortedMessageList, hasErrorMessage("B")); List<String> codes = sortedMessageList.stream().map(Message::getCode).collect(toList()); assertThat(codes, contains("A", "B")); } |
### Question:
ObjectProperty implements Serializable { @Override public int hashCode() { return hashCode; } ObjectProperty(Object object, @CheckForNull String property, int index); ObjectProperty(Object object, String property); ObjectProperty(Object object); Object getObject(); @CheckForNull String getProperty(); int getIndex(); boolean hasIndex(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testHashCode() { ObjectProperty objectProperty = new ObjectProperty("foo"); assertThat(objectProperty.hashCode(), is(objectProperty.hashCode())); assertThat(new ObjectProperty("foo").hashCode(), is(new ObjectProperty("foo").hashCode())); assertThat(new ObjectProperty("foo", "bar").hashCode(), is(new ObjectProperty("foo", "bar").hashCode())); assertThat(new ObjectProperty("foo", "bar", 1).hashCode(), is(new ObjectProperty("foo", "bar", 1).hashCode())); }
@Test public void testHashCode_IsCached() { HashCodeCounter hashCodeCounter = new HashCodeCounter(); ObjectProperty objectProperty = new ObjectProperty(hashCodeCounter); assertThat(objectProperty.hashCode(), is(objectProperty.hashCode())); assertThat(hashCodeCounter.count, is(1)); } |
### Question:
ObjectProperty implements Serializable { public boolean hasIndex() { return index >= 0; } ObjectProperty(Object object, @CheckForNull String property, int index); ObjectProperty(Object object, String property); ObjectProperty(Object object); Object getObject(); @CheckForNull String getProperty(); int getIndex(); boolean hasIndex(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testHasIndex() { String object = "foo"; assertThat(new ObjectProperty(object).hasIndex(), is(false)); assertThat(new ObjectProperty(object, "chars").hasIndex(), is(false)); assertThat(new ObjectProperty(object, "chars", 1).hasIndex(), is(true)); } |
### Question:
ObjectProperty implements Serializable { @Override public boolean equals(Object obj) { if (obj instanceof ObjectProperty) { ObjectProperty other = (ObjectProperty)obj; return Objects.equals(object, other.object) && index == other.index && Objects.equals(property, other.property); } return false; } ObjectProperty(Object object, @CheckForNull String property, int index); ObjectProperty(Object object, String property); ObjectProperty(Object object); Object getObject(); @CheckForNull String getProperty(); int getIndex(); boolean hasIndex(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() { ObjectProperty objectProperty = new ObjectProperty("foo"); assertThat(objectProperty, is(equalTo(objectProperty))); assertThat(new ObjectProperty("foo"), is(equalTo(new ObjectProperty("foo")))); assertThat(new ObjectProperty("foo", "bar"), is(equalTo(new ObjectProperty("foo", "bar")))); assertThat(new ObjectProperty("foo", "bar", 1), is(equalTo(new ObjectProperty("foo", "bar", 1)))); assertThat(new ObjectProperty("foo", "bar", 1), is(not(equalTo(new ObjectProperty("foo", "bar", 2))))); assertThat(new ObjectProperty("foo", "bar", 1), is(not(equalTo(new ObjectProperty("foo", "bar"))))); assertThat(new ObjectProperty("foo", "bar"), is(not(equalTo(new ObjectProperty("foo", "bar", 1))))); assertThat(new ObjectProperty("foo", "bar", 1), is(not(equalTo(new ObjectProperty("foo"))))); assertThat(new ObjectProperty("foo"), is(not(equalTo(new ObjectProperty("foo", "bar", 1))))); assertThat(new ObjectProperty("foo", "bar"), is(not(equalTo(new ObjectProperty("foo"))))); assertThat(new ObjectProperty("foo"), is(not(equalTo(new ObjectProperty("foo", "bar"))))); assertThat(new ObjectProperty("foo", "bar"), is(not(equalTo(new ObjectProperty("foo", "baz"))))); assertThat(new ObjectProperty("foo", "bar", 1), is(not(equalTo(new ObjectProperty("foo", "baz", 1))))); assertThat(new ObjectProperty("foo", "bar", 1), is(not(equalTo(new ObjectProperty("baz", "bar", 1))))); assertThat(new ObjectProperty("foo", "bar"), is(not(equalTo(new ObjectProperty("baz", "bar"))))); assertThat(new ObjectProperty("foo"), is(not(equalTo(new ObjectProperty("baz"))))); assertThat(new ObjectProperty("foo"), is(not(equalTo("foo")))); } |
### Question:
MessageList implements Serializable, Iterable<Message> { public MessageList getMessagesByMarker(@CheckForNull ValidationMarker marker) { return messages.stream() .filter(m -> (marker == null && !m.hasMarkers()) || marker != null && m.hasMarker(marker)) .collect(toMessageList()); } MessageList(@NonNull Message... messages); void add(Message message); void add(@CheckForNull MessageList messageList); boolean isEmpty(); int size(); Message getMessage(int index); Optional<Message> getFirstMessage(Severity errorLevel); Optional<Message> getMessageByCode(@CheckForNull String code); MessageList getMessagesByCode(@CheckForNull String code); Optional<Severity> getSeverity(); String getText(); boolean containsErrorMsg(); MessageList getMessagesFor(Object object); MessageList getMessagesFor(Object object, @CheckForNull String property); MessageList getMessagesFor(Object object, @CheckForNull String property, int index); MessageList getMessagesByMarker(@CheckForNull ValidationMarker marker); MessageList getMessagesByMarker(Predicate<ValidationMarker> markerPredicate); MessageList sortBySeverity(); Optional<Message> getMessageWithHighestSeverity(); @Override Iterator<Message> iterator(); void clear(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); Stream<Message> stream(); static Collector<Message, ?, MessageList> collector(); }### Answer:
@SuppressWarnings({ "unchecked", "rawtypes" }) @Test public void testGetMessagesByMarker_predicateNull_shouldThrowNullPointerException() { Assertions.assertThrows(NullPointerException.class, () -> { new MessageList().getMessagesByMarker((Predicate)null); }); } |
### Question:
MessageList implements Serializable, Iterable<Message> { public Optional<Message> getMessageWithHighestSeverity() { return messages.stream() .sorted(Comparator.comparing(Message::getSeverity).reversed()) .findFirst(); } MessageList(@NonNull Message... messages); void add(Message message); void add(@CheckForNull MessageList messageList); boolean isEmpty(); int size(); Message getMessage(int index); Optional<Message> getFirstMessage(Severity errorLevel); Optional<Message> getMessageByCode(@CheckForNull String code); MessageList getMessagesByCode(@CheckForNull String code); Optional<Severity> getSeverity(); String getText(); boolean containsErrorMsg(); MessageList getMessagesFor(Object object); MessageList getMessagesFor(Object object, @CheckForNull String property); MessageList getMessagesFor(Object object, @CheckForNull String property, int index); MessageList getMessagesByMarker(@CheckForNull ValidationMarker marker); MessageList getMessagesByMarker(Predicate<ValidationMarker> markerPredicate); MessageList sortBySeverity(); Optional<Message> getMessageWithHighestSeverity(); @Override Iterator<Message> iterator(); void clear(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); Stream<Message> stream(); static Collector<Message, ?, MessageList> collector(); }### Answer:
@Test public void testGetMessageWithHighestSeverity() { MessageList messages = new MessageList(Message.builder("info", Severity.INFO).create(), Message.builder("error", Severity.ERROR).create(), Message.builder("warning", Severity.WARNING).create()); Optional<Message> message = messages.getMessageWithHighestSeverity(); assertThat(message, is(present())); assertThat(message.get().getSeverity(), is(Severity.ERROR)); }
@Test public void testGetMessageWithHighestSeverity_null() { MessageList messages = new MessageList(); Optional<Message> message = messages.getMessageWithHighestSeverity(); assertThat(message, is(not(present()))); } |
### Question:
MessageList implements Serializable, Iterable<Message> { public MessageList sortBySeverity() { return messages.stream() .sorted(Comparator.comparing(Message::getSeverity).reversed()) .collect(collector()); } MessageList(@NonNull Message... messages); void add(Message message); void add(@CheckForNull MessageList messageList); boolean isEmpty(); int size(); Message getMessage(int index); Optional<Message> getFirstMessage(Severity errorLevel); Optional<Message> getMessageByCode(@CheckForNull String code); MessageList getMessagesByCode(@CheckForNull String code); Optional<Severity> getSeverity(); String getText(); boolean containsErrorMsg(); MessageList getMessagesFor(Object object); MessageList getMessagesFor(Object object, @CheckForNull String property); MessageList getMessagesFor(Object object, @CheckForNull String property, int index); MessageList getMessagesByMarker(@CheckForNull ValidationMarker marker); MessageList getMessagesByMarker(Predicate<ValidationMarker> markerPredicate); MessageList sortBySeverity(); Optional<Message> getMessageWithHighestSeverity(); @Override Iterator<Message> iterator(); void clear(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); Stream<Message> stream(); static Collector<Message, ?, MessageList> collector(); }### Answer:
@Test public void testSortBySeverity() { Message e1 = Message.newError("e1", "E1"); Message e2 = Message.newError("e2", "E2"); Message e3 = Message.newError("e3", "E3"); Message w1 = Message.newWarning("w1", "W1"); Message w2 = Message.newWarning("w2", "W2"); Message i1 = Message.newInfo("i1", "I1"); Message i2 = Message.newInfo("i2", "I2"); MessageList unsortedMessageList = new MessageList(i2, e1, w1, e3, i1, e2, w2); MessageList sortedMessageList = new MessageList(e1, e3, e2, w1, w2, i2, i1); MessageList actualMessageList = unsortedMessageList.sortBySeverity(); assertThat(actualMessageList, is(equalTo(sortedMessageList))); } |
### Question:
MessageList implements Serializable, Iterable<Message> { public String getText() { return messages.stream() .map(Message::getText) .collect(Collectors.joining("\n")); } MessageList(@NonNull Message... messages); void add(Message message); void add(@CheckForNull MessageList messageList); boolean isEmpty(); int size(); Message getMessage(int index); Optional<Message> getFirstMessage(Severity errorLevel); Optional<Message> getMessageByCode(@CheckForNull String code); MessageList getMessagesByCode(@CheckForNull String code); Optional<Severity> getSeverity(); String getText(); boolean containsErrorMsg(); MessageList getMessagesFor(Object object); MessageList getMessagesFor(Object object, @CheckForNull String property); MessageList getMessagesFor(Object object, @CheckForNull String property, int index); MessageList getMessagesByMarker(@CheckForNull ValidationMarker marker); MessageList getMessagesByMarker(Predicate<ValidationMarker> markerPredicate); MessageList sortBySeverity(); Optional<Message> getMessageWithHighestSeverity(); @Override Iterator<Message> iterator(); void clear(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); Stream<Message> stream(); static Collector<Message, ?, MessageList> collector(); }### Answer:
@Test public void testGetText() { MessageList messageList = new MessageList(Message.newInfo("don't care", "we care"), Message.newError("don't care", "even more")); assertThat(messageList.getText(), is("we care\neven more")); }
@Test public void testGetText_OneMessageList() { MessageList messageList = new MessageList(Message.newInfo("don't care", "we care")); assertThat(messageList.getText(), is("we care")); }
@Test public void testGetText_emptyList_shouldReturnEmptyString() { MessageList emptyMessageList = new MessageList(); assertThat(emptyMessageList.getText(), is(StringUtils.EMPTY)); } |
### Question:
TwoDigitYearUtil { LocalDate convertInternal(LocalDate value) { if (value.isAfter(LocalDate.of(-1, 1, 1)) && value.isBefore(LocalDate.of(100, 1, 1))) { LocalDate resultDate = value; LocalDate pivotLocalDate = LocalDate.now().withYear(getCurrentYear()).minusYears(80); int pivotYear = pivotLocalDate.getYear() % 100; int pivotCentury = pivotLocalDate.minusYears(pivotYear).getYear(); if (resultDate.getYear() < pivotYear) { resultDate = resultDate.plusYears(100); } resultDate = resultDate.plusYears(pivotCentury); return resultDate; } else { return value; } } private TwoDigitYearUtil(); static LocalDate convert(LocalDate value); }### Answer:
@Test public void testconvertInternal_ThreeDigitYear_NoConversion() { givenCurrentYear(2019); assertThat((convertInternaler.convertInternal(LocalDate.of(139, 12, 31))), is(LocalDate.of(139, 12, 31))); }
@Test public void testconvertInternal_FourDigitYear_NoConversion() { givenCurrentYear(2019); assertThat((convertInternaler.convertInternal(LocalDate.of(2039, 12, 31))), is(LocalDate.of(2039, 12, 31))); }
@Test public void testconvertInternal_TwoDigitYearCurrrentCentury_Future() { givenCurrentYear(2091); assertThat((convertInternaler.convertInternal(LocalDate.of(80, 2, 24))), is(LocalDate.of(2080, 2, 24))); }
@Test public void testconvertInternal_TwoDigitYearNextCentury_Future() { givenCurrentYear(2091); assertThat((convertInternaler.convertInternal(LocalDate.of(10, 5, 1))), is(LocalDate.of(2110, 5, 1))); }
@Test public void testconvertInternal_TwoDigitYearCurrentCentury() { givenCurrentYear(2019); assertThat((convertInternaler.convertInternal(LocalDate.of(19, 6, 7))), is(LocalDate.of(2019, 6, 7))); }
@Test public void testconvertInternal_TwoDigitYearLastCentury() { givenCurrentYear(2019); assertThat((convertInternaler.convertInternal(LocalDate.of(68, 3, 2))), is(LocalDate.of(1968, 3, 2))); }
@Test public void testconvertInternal_MinTwoDigitYearLastCentury() { givenCurrentYear(2019); assertThat((convertInternaler.convertInternal(LocalDate.of(39, 1, 1))), is(LocalDate.of(1939, 1, 1))); }
@Test public void testconvertInternal_MaxTwoDigitYearLastCentury() { givenCurrentYear(2019); assertThat((convertInternaler.convertInternal(LocalDate.of(99, 12, 31))), is(LocalDate.of(1999, 12, 31))); }
@Test public void testconvertInternal_MinTwoDigitYearCurrrentCentury() { givenCurrentYear(2019); assertThat((convertInternaler.convertInternal(LocalDate.of(0, 1, 1))), is(LocalDate.of(2000, 1, 1))); }
@Test public void testconvertInternal_MaxTwoDigitYearCurrrentCentury() { givenCurrentYear(2019); assertThat((convertInternaler.convertInternal(LocalDate.of(38, 12, 31))), is(LocalDate.of(2038, 12, 31))); } |
### Question:
MessageList implements Serializable, Iterable<Message> { public MessageList getMessagesFor(Object object) { return getMessagesFor(object, null); } MessageList(@NonNull Message... messages); void add(Message message); void add(@CheckForNull MessageList messageList); boolean isEmpty(); int size(); Message getMessage(int index); Optional<Message> getFirstMessage(Severity errorLevel); Optional<Message> getMessageByCode(@CheckForNull String code); MessageList getMessagesByCode(@CheckForNull String code); Optional<Severity> getSeverity(); String getText(); boolean containsErrorMsg(); MessageList getMessagesFor(Object object); MessageList getMessagesFor(Object object, @CheckForNull String property); MessageList getMessagesFor(Object object, @CheckForNull String property, int index); MessageList getMessagesByMarker(@CheckForNull ValidationMarker marker); MessageList getMessagesByMarker(Predicate<ValidationMarker> markerPredicate); MessageList sortBySeverity(); Optional<Message> getMessageWithHighestSeverity(); @Override Iterator<Message> iterator(); void clear(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); Stream<Message> stream(); static Collector<Message, ?, MessageList> collector(); }### Answer:
@Test public void testGetMessagesFor_noObjects_shouldReturnEmptyMessageList() { MessageList messages = new MessageList(Message.newError("code", "msg"), Message.newWarning("code", "msg")) .getMessagesFor(new Object()); assertThat(messages, is(emptyMessageList())); }
@Test public void testGetMessagesFor_objectNull_shouldThrowNullPointerException() { Assertions.assertThrows(NullPointerException.class, () -> { new MessageList(Message.newError("code", "msg"), Message.newWarning("code", "msg")) .getMessagesFor(null); }); } |
### Question:
MessageList implements Serializable, Iterable<Message> { public Optional<Severity> getSeverity() { return messages.stream() .map(Message::getSeverity) .max(Comparator.comparing(Severity::ordinal)); } MessageList(@NonNull Message... messages); void add(Message message); void add(@CheckForNull MessageList messageList); boolean isEmpty(); int size(); Message getMessage(int index); Optional<Message> getFirstMessage(Severity errorLevel); Optional<Message> getMessageByCode(@CheckForNull String code); MessageList getMessagesByCode(@CheckForNull String code); Optional<Severity> getSeverity(); String getText(); boolean containsErrorMsg(); MessageList getMessagesFor(Object object); MessageList getMessagesFor(Object object, @CheckForNull String property); MessageList getMessagesFor(Object object, @CheckForNull String property, int index); MessageList getMessagesByMarker(@CheckForNull ValidationMarker marker); MessageList getMessagesByMarker(Predicate<ValidationMarker> markerPredicate); MessageList sortBySeverity(); Optional<Message> getMessageWithHighestSeverity(); @Override Iterator<Message> iterator(); void clear(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); Stream<Message> stream(); static Collector<Message, ?, MessageList> collector(); }### Answer:
@Test public void testGetSeverity() { MessageList messageList = new MessageList( Message.newInfo(ANY, ANY), Message.newError(ANY, ANY), Message.newWarning(ANY, ANY)); assertThat(messageList.getSeverity(), is(hasValue(Severity.ERROR))); }
@Test public void testGetSeverity_OneSeverity() { MessageList messageList = new MessageList( Message.newInfo(ANY, ANY), Message.newInfo(ANY, ANY)); assertThat(messageList.getSeverity(), is(hasValue(Severity.INFO))); }
@Test public void testGetSeverity_EmptyList() { assertThat(new MessageList().getSeverity(), is(absent())); } |
### Question:
Message implements Serializable { public static Builder builder(String text, Severity severity) { Objects.requireNonNull(text, "text must not be null"); Objects.requireNonNull(severity, "severity must not be null"); return new Builder(text, severity); } Message(@CheckForNull String code, String text, Severity severity); Message(@CheckForNull String code, String text, Severity severity,
@CheckForNull List<ObjectProperty> invalidObjectProperties, @CheckForNull Set<ValidationMarker> markers); static Message newInfo(String code, String text); static Message newWarning(String code, String text); static Message newError(String code, String text); Severity getSeverity(); String getText(); @CheckForNull String getCode(); List<ObjectProperty> getInvalidObjectProperties(); Set<ValidationMarker> getMarkers(); boolean hasMarker(ValidationMarker marker); boolean hasMarkers(); boolean isMandatoryFieldMessage(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); static Builder builder(String text, Severity severity); }### Answer:
@Test public void testEquals_NotEqual_ObjectProperties() { Object invalidObject = new Object(); ObjectProperty objectProperty = new ObjectProperty(invalidObject); ValidationMarker validationMarker = () -> false; Message message1 = Message.builder("text", Severity.INFO).code("code").markers(validationMarker) .invalidObjectWithProperties(invalidObject).create(); Message message2 = Message.builder("text", Severity.INFO).code("code").markers(validationMarker) .invalidObjects(objectProperty, objectProperty).create(); Message message3 = Message.builder("text", Severity.INFO).code("code").markers(validationMarker) .invalidObjectWithProperties(invalidObject, "foo", "bar").create(); assertThat(message1, is(not(equalTo(message2)))); assertThat(message1, is(not(equalTo(message3)))); } |
### Question:
Message implements Serializable { @Override public String toString() { StringBuilder buffer = new StringBuilder(); buffer.append(severity.toString()) .append(' ') .append(code) .append('['); int max = invalidProperties.size(); for (int i = 0; i < max; i++) { if (i > 0) { buffer.append(", "); } buffer.append(invalidProperties.get(i).getObject().toString()) .append('.') .append(invalidProperties.get(i).getProperty()); } buffer.append(']') .append('\n') .append(text); return buffer.toString(); } Message(@CheckForNull String code, String text, Severity severity); Message(@CheckForNull String code, String text, Severity severity,
@CheckForNull List<ObjectProperty> invalidObjectProperties, @CheckForNull Set<ValidationMarker> markers); static Message newInfo(String code, String text); static Message newWarning(String code, String text); static Message newError(String code, String text); Severity getSeverity(); String getText(); @CheckForNull String getCode(); List<ObjectProperty> getInvalidObjectProperties(); Set<ValidationMarker> getMarkers(); boolean hasMarker(ValidationMarker marker); boolean hasMarkers(); boolean isMandatoryFieldMessage(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); static Builder builder(String text, Severity severity); }### Answer:
@Test public void testToString() { Message message = new Message("code", "text", Severity.WARNING, Arrays.asList(new ObjectProperty("Object", "property", 1)), Collections.singleton(() -> true)); assertThat(message.toString(), is("WARNING code[Object.property]\ntext")); } |
### Question:
Message implements Serializable { public boolean isMandatoryFieldMessage() { return getMarkers() .stream() .anyMatch(ValidationMarker::isRequiredInformationMissing); } Message(@CheckForNull String code, String text, Severity severity); Message(@CheckForNull String code, String text, Severity severity,
@CheckForNull List<ObjectProperty> invalidObjectProperties, @CheckForNull Set<ValidationMarker> markers); static Message newInfo(String code, String text); static Message newWarning(String code, String text); static Message newError(String code, String text); Severity getSeverity(); String getText(); @CheckForNull String getCode(); List<ObjectProperty> getInvalidObjectProperties(); Set<ValidationMarker> getMarkers(); boolean hasMarker(ValidationMarker marker); boolean hasMarkers(); boolean isMandatoryFieldMessage(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); static Builder builder(String text, Severity severity); }### Answer:
@Test public void testIsMandatoryFieldMessage() { ValidationMarker mandatoryMarker = () -> true; ValidationMarker notMandatoryMarker = () -> false; assertThat(createMessage().isMandatoryFieldMessage(), is(false)); assertThat(createMessage(notMandatoryMarker).isMandatoryFieldMessage(), is(false)); assertThat(createMessage(mandatoryMarker).isMandatoryFieldMessage(), is(true)); assertThat(createMessage(notMandatoryMarker, mandatoryMarker).isMandatoryFieldMessage(), is(true)); } |
### Question:
BindingManager { public void removeUiUpdateObserver(UiUpdateObserver observer) { requireNonNull(observer, "observer must not be null"); uiUpdateObservers.remove(observer); } BindingManager(ValidationService validationService); @Deprecated BindingContext startNewContext(Class<?> clazz); BindingContext createContext(Class<?> clazz, PropertyBehaviorProvider behaviorProvider); @Deprecated BindingContext startNewContext(String name); BindingContext createContext(String name, PropertyBehaviorProvider behaviorProvider); BindingContext getContext(Class<?> clazz); BindingContext getContext(String name); @Deprecated Optional<BindingContext> getExistingContext(Class<?> clazz); @Deprecated Optional<BindingContext> getExistingContext(String name); @Deprecated BindingContext getExistingContextOrStartNewOne(Class<?> clazz); @Deprecated BindingContext getExistingContextOrStartNewOne(String name); void removeContext(BindingContext context); void removeAllContexts(); void addUiUpdateObserver(UiUpdateObserver observer); void removeUiUpdateObserver(UiUpdateObserver observer); void afterUpdateUi(); void notifyUiUpdateObservers(); @Override String toString(); }### Answer:
@Test public void testRemoveUiUpdateObserver() { TestBindingManager bindingManager = new TestBindingManager(() -> new MessageList()); UiUpdateObserver observer = mock(UiUpdateObserver.class); bindingManager.addUiUpdateObserver(observer); bindingManager.removeUiUpdateObserver(observer); bindingManager.afterUpdateUi(); verify(observer, never()).uiUpdated(); } |
### Question:
ContainerBinding extends BindingContext implements Binding { @Override public void modelChanged() { modelChanged.apply(); } ContainerBinding(Binding selfBinding, PropertyBehaviorProvider behaviorProvider,
PropertyDispatcherFactory dispatcherFactory, Handler modelChanged); @Override void modelChanged(); @Override void updateFromPmo(); @Override Object getBoundComponent(); @Override Object getPmo(); }### Answer:
@Test public void testModelChanged_IsForwardedToParent() { BindingContext bindingContext = spy(new BindingContext()); ComponentWrapper componentWrapper = new TestComponentWrapper(new TestUiComponent()); ContainerBinding binding = bindingContext.bindContainer(new TestPmo(new TestModelObject()), BoundProperty.of("test"), Arrays.asList(), componentWrapper); binding.modelChanged(); verify(bindingContext).modelChanged(); }
@Test public void testModelChanged() { BindingContext bindingContext = new BindingContext(); ComponentWrapper componentWrapper = new TestComponentWrapper(new TestUiComponent()); TestAspectDef testAspectDef = new TestAspectDef(); ContainerBinding binding = bindingContext.bindContainer(new Object(), BoundProperty.of("test"), Arrays.asList(testAspectDef), componentWrapper); testAspectDef.triggered = false; binding.modelChanged(); assertThat(testAspectDef.triggered, is(true)); } |
### Question:
ContainerBinding extends BindingContext implements Binding { @Override public void updateFromPmo() { binding.updateFromPmo(); super.updateFromPmo(); } ContainerBinding(Binding selfBinding, PropertyBehaviorProvider behaviorProvider,
PropertyDispatcherFactory dispatcherFactory, Handler modelChanged); @Override void modelChanged(); @Override void updateFromPmo(); @Override Object getBoundComponent(); @Override Object getPmo(); }### Answer:
@Test public void testUpdateFromPmo_ManuallyUpdated() { BindingContext bindingContext = new BindingContext(); ComponentWrapper componentWrapper = new TestComponentWrapper(new TestUiComponent()); TestAspectDef testAspectDef = new TestAspectDef(); bindingContext.bindContainer(new TestPmo(new TestModelObject()), BoundProperty.of("test"), Arrays.asList(testAspectDef), componentWrapper); testAspectDef.triggered = false; bindingContext.updateFromPmo(); assertThat(testAspectDef.triggered, is(true)); }
@Test public void testUpdateFromPmo_ContainerBindingBeforeChildren() { BindingContext bindingContext = new BindingContext(); ComponentWrapper componentWrapper = new TestComponentWrapper(new TestUiComponent()); TestAspectDef testAspectDef = new TestAspectDef(); TestDependantAspectDef testDependantAspectDef = new TestDependantAspectDef(testAspectDef); ContainerBinding binding = bindingContext.bindContainer(new Object(), BoundProperty.of("test"), Arrays.asList(testAspectDef), componentWrapper); binding.bind(new Object(), BoundProperty.of("test2"), Arrays.asList(testDependantAspectDef), componentWrapper); assertThat(testAspectDef.triggered, is(true)); assertThat(testDependantAspectDef.triggered, is(true)); testAspectDef.triggered = false; testDependantAspectDef.triggered = false; binding.updateFromPmo(); assertThat(testAspectDef.triggered, is(true)); assertThat(testDependantAspectDef.triggered, is(true)); } |
### Question:
ModelObjects { public static Supplier<Object> supplierFor(Object pmo, String modelObjectName) { Member accessMember = getModelObjectAccessMember(pmo, modelObjectName) .orElseThrow(() -> ModelObjectAnnotationException.noAnnotatedMember(pmo.getClass(), modelObjectName)); return () -> MemberAccessors.getValue(pmo, accessMember); } private ModelObjects(Class<?> pmoClass, String modelObjectName); static Supplier<Object> supplierFor(Object pmo, String modelObjectName); static boolean isAccessible(Object pmo, String modelObjectName); }### Answer:
@Test public void testGetModelObjectSupplier_noAnnotation() { Assertions.assertThrows(ModelObjectAnnotationException.class, () -> { ModelObjects.supplierFor(new TestObject(), ModelObject.DEFAULT_NAME); }); }
@Test public void testGetModelObjectSupplier_ThrowsExceptionIfNoMatchingAnnotationExists() { Assertions.assertThrows(ModelObjectAnnotationException.class, () -> { ModelObjects.supplierFor(new PmoWithNamedModelObject(), "someOtherName"); }); }
@Test public void testGetModelObjectSupplier_ThrowsExceptionIfAnnotatedMethodReturnsVoid() { Assertions.assertThrows(ModelObjectAnnotationException.class, () -> { ModelObjects.supplierFor(new PmoWithVoidModelObjectMethod(), ModelObject.DEFAULT_NAME); }); }
@Test public void testGetModelObjectSupplier() { Supplier<?> modelObjectSupplier = ModelObjects .supplierFor(new PmoWithNamedModelObject(), PmoWithNamedModelObject.MODEL_OBJECT); assertThat(modelObjectSupplier, is(notNullValue())); assertThat(modelObjectSupplier.get(), is(instanceOf(TestObject.class))); }
@Test public void testModelObjectAnnotatedField() { PmoWithModelObjectField pmoWithModelObjectField = new PmoWithModelObjectField(); assertThat(ModelObjects.supplierFor(pmoWithModelObjectField, ModelObject.DEFAULT_NAME) .get(), is(pmoWithModelObjectField.testSub)); }
@Test public void testPrivateModelObjectAnnotatedFieldInSuperclass() { PmoWithModelObjectFieldInSuperclass pmoWithModelObjectFieldInSuperclass = new PmoWithModelObjectFieldInSuperclass(); Object modelObject = ModelObjects .supplierFor(pmoWithModelObjectFieldInSuperclass, ModelObject.DEFAULT_NAME).get(); assertThat(modelObject, is(not(nullValue()))); assertThat(modelObject, instanceOf(TestSub.class)); }
@Test public void testMixedModelObjectFieldAndMethod() { PmoWithNamedModelObject pmoWithNamedModelObject = new PmoWithNamedModelObject(); Object defaultModelObject = ModelObjects .supplierFor(pmoWithNamedModelObject, ModelObject.DEFAULT_NAME).get(); Object namedModelObject = ModelObjects .supplierFor(pmoWithNamedModelObject, PmoWithNamedModelObject.MODEL_OBJECT).get(); assertThat(defaultModelObject, instanceOf(TestSub.class)); assertThat(namedModelObject, instanceOf(TestObject.class)); }
@Test public void testTwoDefaultModelObjectAnnotations() { PmoWithTwoDefaultModelObjects pmoWithTwoDefaultModelObjects = new PmoWithTwoDefaultModelObjects(); Assertions.assertThrows(ModelObjectAnnotationException.class, () -> { ModelObjects.supplierFor(pmoWithTwoDefaultModelObjects, ModelObject.DEFAULT_NAME) .get(); }); }
@Test public void testTwoDefaultModelObjectMethodAnnotations() { PmoWithTwoDefaultModelObjectMethods pmoWithTwoDefaultModelObjects = new PmoWithTwoDefaultModelObjectMethods(); Assertions.assertThrows(ModelObjectAnnotationException.class, () -> { ModelObjects.supplierFor(pmoWithTwoDefaultModelObjects, ModelObject.DEFAULT_NAME) .get(); }); } |
### Question:
ModelObjects { public static boolean isAccessible(Object pmo, String modelObjectName) { return getModelObjectAccessMember(pmo, modelObjectName).isPresent(); } private ModelObjects(Class<?> pmoClass, String modelObjectName); static Supplier<Object> supplierFor(Object pmo, String modelObjectName); static boolean isAccessible(Object pmo, String modelObjectName); }### Answer:
@Test public void testHasModelObjectAnnotatedMethod() { assertThat(ModelObjects.isAccessible(new TestPmo(), ModelObject.DEFAULT_NAME), is(true)); assertThat(ModelObjects.isAccessible(new PmoWithNamedModelObject(), PmoWithNamedModelObject.MODEL_OBJECT), is(true)); assertThat(ModelObjects.isAccessible(new PmoWithNamedModelObject(), ModelObject.DEFAULT_NAME), is(true)); }
@Test public void testHasModelObjectAnnotatedMethod_noAnnotation() { assertThat(ModelObjects.isAccessible(new Object(), ModelObject.DEFAULT_NAME), is(false)); }
@Test public void testHasModelObjectAnnotatedMethod_noMatchingAnnotation() { assertThat(ModelObjects.isAccessible(new PmoWithNamedModelObject(), "someOtherName"), is(false)); assertThat(ModelObjects.isAccessible(new Object(), "FooBar"), is(false)); } |
### Question:
BoundPropertyAnnotationReader { public static boolean isBoundPropertyPresent(AnnotatedElement annotatedElement) { return BOUND_PROPERTY_ANNOTATION.isPresentOnAnyAnnotationOn(annotatedElement); } private BoundPropertyAnnotationReader(); static boolean isBoundPropertyPresent(AnnotatedElement annotatedElement); static BoundProperty getBoundProperty(AnnotatedElement annotatedElement); static Optional<BoundProperty> findBoundProperty(AnnotatedElement annotatedElement); static BoundProperty getBoundProperty(A annotation,
AnnotatedElement annotatedElement); }### Answer:
@Test public void testIsBoundPropertyPresent() throws Exception { assertThat(BoundPropertyAnnotationReader.isBoundPropertyPresent(BoundPropertyAnnotationReaderTest.class), is(false)); assertThat(BoundPropertyAnnotationReader.isBoundPropertyPresent(BoundPropertyAnnotationReaderTest.class .getMethod("testIsBoundPropertyPresent")), is(false)); assertThat(BoundPropertyAnnotationReader.isBoundPropertyPresent(BoundPropertyAnnotationReaderTest.class .getField("foo")), is(false)); assertThat(BoundPropertyAnnotationReader.isBoundPropertyPresent(TestBind.class), is(false)); assertThat(BoundPropertyAnnotationReader.isBoundPropertyPresent(ClassWithBoundPropertyAnnotations.class), is(false)); assertThat(BoundPropertyAnnotationReader.isBoundPropertyPresent(ClassWithBoundPropertyAnnotations.class .getMethod("getComponent")), is(true)); assertThat(BoundPropertyAnnotationReader.isBoundPropertyPresent(ClassWithBoundPropertyAnnotations.class .getField("component")), is(true)); assertThat(BoundPropertyAnnotationReader.isBoundPropertyPresent(ClassWithBoundPropertyAnnotations.class .getField("componentWithDefectBoundPropertyCreator")), is(true)); assertThat(BoundPropertyAnnotationReader.isBoundPropertyPresent(ClassWithBoundPropertyAnnotations.class .getField("componentWithUninstatiableBoundPropertyCreator")), is(true)); }
@Test public void testIsBoundPropertyPresent_multipleBoundPropertyCreators() throws Exception { assertTrue(BoundPropertyAnnotationReader.isBoundPropertyPresent(ClassWithBoundPropertyAnnotations.class .getField("componentWithMultipleBoundProperties"))); } |
### Question:
BoundPropertyAnnotationReader { public static BoundProperty getBoundProperty(AnnotatedElement annotatedElement) { return findBoundProperty(annotatedElement) .orElseThrow(() -> new IllegalArgumentException( String.format("%s has no annotation that defines a %s. You can call " + BoundPropertyAnnotationReader.class.getSimpleName() + "#isBoundPropertyPresent(AnnotatedElement) to safeguard against this.", annotatedElement, BoundPropertyCreator.class.getName()))); } private BoundPropertyAnnotationReader(); static boolean isBoundPropertyPresent(AnnotatedElement annotatedElement); static BoundProperty getBoundProperty(AnnotatedElement annotatedElement); static Optional<BoundProperty> findBoundProperty(AnnotatedElement annotatedElement); static BoundProperty getBoundProperty(A annotation,
AnnotatedElement annotatedElement); }### Answer:
@Test public void testGetBoundProperty_FailsIfNoBoundPropertyAnnotationPresent() throws Exception { try { BoundPropertyAnnotationReader.getBoundProperty(BoundPropertyAnnotationReaderTest.class.getField("foo")); fail("expected an " + IllegalArgumentException.class.getSimpleName()); } catch (IllegalArgumentException e) { assertThat(e.getMessage(), containsString(BoundPropertyAnnotationReaderTest.class.getSimpleName())); assertThat(e.getMessage(), containsString("foo")); assertThat(e.getMessage(), containsString("isBoundPropertyPresent")); } }
@Test public void testGetBoundProperty_FailsWithMultipleBoundProperties() { Assertions.assertThrows(IllegalArgumentException.class, () -> { BoundPropertyAnnotationReader.getBoundProperty(ClassWithBoundPropertyAnnotations.class .getField("componentWithMultipleBoundProperties")); }); }
@Test public void testGetBoundProperty_multipleSameBoundProperties() throws Exception { BoundPropertyAnnotationReader.getBoundProperty(ClassWithBoundPropertyAnnotations.class .getField("componentWithMultipleSameBoundProperties")); }
@Test public void testGetBoundProperty_FailsIfCreatorCantBeCreated() { Assertions.assertThrows(IllegalArgumentException.class, () -> { BoundPropertyAnnotationReader.getBoundProperty(ClassWithBoundPropertyAnnotations.class .getField("componentWithUninstatiableBoundPropertyCreator")); }); }
@Test public void testGetBoundProperty_PropagatesExceptionFromCreator() { Assertions.assertThrows(IllegalStateException.class, () -> { BoundPropertyAnnotationReader.getBoundProperty(ClassWithBoundPropertyAnnotations.class .getField("componentWithDefectBoundPropertyCreator")); }); }
@Test public void testGetBoundProperty() throws Exception { BoundProperty boundProperty = BoundPropertyAnnotationReader .getBoundProperty(ClassWithBoundPropertyAnnotations.class .getField("component")); assertThat(boundProperty.getPmoProperty(), is("foo")); } |
### Question:
UIElementAnnotationReader { @Deprecated public static boolean hasModelObjectAnnotation(Object pmo, String modelObjectName) { try { return ModelObjects.isAccessible(pmo, modelObjectName); } catch (org.linkki.core.binding.descriptor.modelobject.ModelObjects.ModelObjectAnnotationException e) { throw new ModelObjectAnnotationException(e.getMessage()); } } UIElementAnnotationReader(Class<?> annotatedClass); PropertyElementDescriptors findDescriptors(String propertyName); Stream<PropertyElementDescriptors> getUiElements(); @Deprecated static Supplier<?> getModelObjectSupplier(Object pmo, String modelObjectName); @Deprecated static boolean hasModelObjectAnnotation(Object pmo, String modelObjectName); }### Answer:
@SuppressWarnings("deprecation") @Test public void testHasModelObjectAnnotatedMethod() { assertThat(UIElementAnnotationReader.hasModelObjectAnnotation(new TestPmo(), ModelObject.DEFAULT_NAME), is(true)); assertThat(UIElementAnnotationReader.hasModelObjectAnnotation(new PmoWithNamedModelObject(), PmoWithNamedModelObject.MODEL_OBJECT), is(true)); assertThat(UIElementAnnotationReader.hasModelObjectAnnotation(new PmoWithNamedModelObject(), ModelObject.DEFAULT_NAME), is(true)); }
@SuppressWarnings("deprecation") @Test public void testHasModelObjectAnnotatedMethod_noAnnotation() { assertThat(UIElementAnnotationReader.hasModelObjectAnnotation(new Object(), ModelObject.DEFAULT_NAME), is(false)); }
@SuppressWarnings("deprecation") @Test public void testHasModelObjectAnnotatedMethod_noMatchingAnnotation() { assertThat(UIElementAnnotationReader.hasModelObjectAnnotation(new PmoWithNamedModelObject(), "someOtherName"), is(false)); assertThat(UIElementAnnotationReader.hasModelObjectAnnotation(new Object(), "FooBar"), is(false)); } |
### Question:
Sequence implements Iterable<T> { public static <T> Sequence<T> empty() { return new Sequence<>(); } private Sequence(); private Sequence(Collection<T> collection); @SuppressWarnings("unchecked") static Sequence<T> of(Collection<? extends T> elements); @SafeVarargs static Sequence<T> of(T... elements); static Sequence<T> empty(); @CheckReturnValue Sequence<T> with(Collection<T> elements); Sequence<T> withNewElementsFrom(Collection<T> elements); @CheckReturnValue final Sequence<T> with(Sequence<T> sequence); @CheckReturnValue @SafeVarargs final Sequence<T> with(T... newElements); @SafeVarargs @CheckReturnValue final Sequence<T> withIf(boolean condition, Supplier<T>... suppliers); @CheckReturnValue final Sequence<T> withIf(boolean condition, Supplier<T> supplier); List<T> list(); @Override Iterator<T> iterator(); Stream<T> stream(); @Override String toString(); static Collector<T, ?, Sequence<T>> collect(); }### Answer:
@Test public void testEmpty() { Sequence<Object> sequence = Sequence.empty(); assertThat(sequence.list(), is(Collections.emptyList())); } |
### Question:
UIElementAnnotationReader { public Stream<PropertyElementDescriptors> getUiElements() { validateNoDuplicatePosition(); return descriptorsByProperty.values().stream() .filter(PropertyElementDescriptors::isNotEmpty) .sorted(Comparator.comparing(PropertyElementDescriptors::getPosition)); } UIElementAnnotationReader(Class<?> annotatedClass); PropertyElementDescriptors findDescriptors(String propertyName); Stream<PropertyElementDescriptors> getUiElements(); @Deprecated static Supplier<?> getModelObjectSupplier(Object pmo, String modelObjectName); @Deprecated static boolean hasModelObjectAnnotation(Object pmo, String modelObjectName); }### Answer:
@Test public void testGetUiElements_DynamicFields() { UIElementAnnotationReader uiElementAnnotationReader = new UIElementAnnotationReader(DynamicFieldPmo.class); List<PropertyElementDescriptors> uiElements = uiElementAnnotationReader.getUiElements() .collect(Collectors.toList()); assertThat(uiElements.size(), is(1)); PropertyElementDescriptors elementDescriptors = uiElements.get(0); ElementDescriptor fooDescriptor = elementDescriptors .getDescriptor(new DynamicFieldPmo(Type.FOO)); assertThat(fooDescriptor, is(notNullValue())); assertThat(fooDescriptor.getBoundProperty().getModelAttribute(), is("foo")); ElementDescriptor barDescriptor = elementDescriptors .getDescriptor(new DynamicFieldPmo(Type.BAR)); assertThat(barDescriptor, is(notNullValue())); assertThat(barDescriptor.getBoundProperty().getModelAttribute(), is("bar")); } |
### Question:
PropertyElementDescriptors { public int getPosition() { return position; } PropertyElementDescriptors(String pmoPropertyName); int getPosition(); String getPmoPropertyName(); ElementDescriptor getDescriptor(Object pmo); void addAspect(List<LinkkiAspectDefinition> aspectDefs); boolean isNotEmpty(); List<LinkkiAspectDefinition> getAllAspects(); }### Answer:
@Test public void testGetPosition_WithoutDescriptor() { PropertyElementDescriptors descriptors = new PropertyElementDescriptors(TestPmo.SINGLE_PMO_PROPERTY); assertThat(descriptors.getPosition(), is(0)); } |
### Question:
PropertyElementDescriptors { public String getPmoPropertyName() { return pmoPropertyName; } PropertyElementDescriptors(String pmoPropertyName); int getPosition(); String getPmoPropertyName(); ElementDescriptor getDescriptor(Object pmo); void addAspect(List<LinkkiAspectDefinition> aspectDefs); boolean isNotEmpty(); List<LinkkiAspectDefinition> getAllAspects(); }### Answer:
@Test public void testGetPmoPropertyName() { PropertyElementDescriptors descriptors = new PropertyElementDescriptors(TestPmo.SINGLE_PMO_PROPERTY); assertThat(descriptors.getPmoPropertyName(), is(TestPmo.SINGLE_PMO_PROPERTY)); } |
### Question:
Sequence implements Iterable<T> { @Override public String toString() { return list.toString(); } private Sequence(); private Sequence(Collection<T> collection); @SuppressWarnings("unchecked") static Sequence<T> of(Collection<? extends T> elements); @SafeVarargs static Sequence<T> of(T... elements); static Sequence<T> empty(); @CheckReturnValue Sequence<T> with(Collection<T> elements); Sequence<T> withNewElementsFrom(Collection<T> elements); @CheckReturnValue final Sequence<T> with(Sequence<T> sequence); @CheckReturnValue @SafeVarargs final Sequence<T> with(T... newElements); @SafeVarargs @CheckReturnValue final Sequence<T> withIf(boolean condition, Supplier<T>... suppliers); @CheckReturnValue final Sequence<T> withIf(boolean condition, Supplier<T> supplier); List<T> list(); @Override Iterator<T> iterator(); Stream<T> stream(); @Override String toString(); static Collector<T, ?, Sequence<T>> collect(); }### Answer:
@Test public void testToString() { Sequence<Integer> sequence = Sequence.of(1, 2, 3); assertThat(sequence.toString(), is("[1, 2, 3]")); } |
### Question:
PropertyElementDescriptors { public ElementDescriptor getDescriptor(Object pmo) { ElementDescriptor descriptor = findDescriptor(pmo); descriptor.addAspectDefinitions(additionalAspects); return descriptor; } PropertyElementDescriptors(String pmoPropertyName); int getPosition(); String getPmoPropertyName(); ElementDescriptor getDescriptor(Object pmo); void addAspect(List<LinkkiAspectDefinition> aspectDefs); boolean isNotEmpty(); List<LinkkiAspectDefinition> getAllAspects(); }### Answer:
@Test public void testGetDescriptor_WithoutDescriptor_NoComponentTypeMethod() { PropertyElementDescriptors descriptors = new PropertyElementDescriptors(TestPmo.SINGLE_PMO_PROPERTY); Assertions.assertThrows(IllegalStateException.class, () -> { descriptors.getDescriptor(new TestPmo()); }); }
@Test public void testGetDescriptor_WithoutDescriptor_WithComponentTypeMethod() { PropertyElementDescriptors descriptors = new PropertyElementDescriptors(TestPmo.DUAL_PMO_PROPERTY); Assertions.assertThrows(IllegalStateException.class, () -> { descriptors.getDescriptor(new TestPmo()); }); } |
### Question:
PropertyElementDescriptors { void addDescriptor(Class<? extends Annotation> uiElementAnnotationType, ElementDescriptor descriptor, Class<?> pmoClass) { Validate.isTrue(pmoPropertyName.equals(descriptor.getPmoPropertyName()), String .format("Cannot add descriptor for property %s to PropertyElementDescriptors intended for property %s", descriptor.getPmoPropertyName(), pmoPropertyName)); if (descriptors.isEmpty()) { position = descriptor.getPosition(); } else { validateDynamicFieldDescriptor(descriptor, pmoClass); } descriptors.put(uiElementAnnotationType, descriptor); } PropertyElementDescriptors(String pmoPropertyName); int getPosition(); String getPmoPropertyName(); ElementDescriptor getDescriptor(Object pmo); void addAspect(List<LinkkiAspectDefinition> aspectDefs); boolean isNotEmpty(); List<LinkkiAspectDefinition> getAllAspects(); }### Answer:
@Test public void testAddDescriptor_DualDifferentPosition() { PropertyElementDescriptors descriptors = new PropertyElementDescriptors( TestPmo.ILLEGAL_DUAL_PMO_PROPERTY_WITH_DIFFERENT_POSITION); Assertions.assertThrows(IllegalStateException.class, () -> { descriptors.addDescriptor(TestUIAnnotation.class, new ElementDescriptor(30, TestLinkkiComponentDefinition.create(() -> "TestUIAnnotation"), BoundProperty .of(TestPmo.ILLEGAL_DUAL_PMO_PROPERTY_WITH_DIFFERENT_POSITION), Collections.emptyList()), TestPmo.class); descriptors.addDescriptor(AnotherTestUIAnnotation.class, new ElementDescriptor(31, TestLinkkiComponentDefinition.create(() -> "AnotherTestUIAnnotation"), BoundProperty .of(TestPmo.ILLEGAL_DUAL_PMO_PROPERTY_WITH_DIFFERENT_POSITION), Collections.emptyList()), TestPmo.class); }); }
@Test public void testAddDescriptor_NoComponentTypeMethod() { PropertyElementDescriptors descriptors = new PropertyElementDescriptors( TestPmo.ILLEGAL_DUAL_PMO_PROPERTY_WITHOUT_DIFFERENTIATOR); Assertions.assertThrows(IllegalStateException.class, () -> { descriptors.addDescriptor(TestUIAnnotation.class, new ElementDescriptor(30, TestLinkkiComponentDefinition.create(() -> "TestUIAnnotation"), BoundProperty .of(TestPmo.ILLEGAL_DUAL_PMO_PROPERTY_WITHOUT_DIFFERENTIATOR), Collections.emptyList()), TestPmo.class); descriptors.addDescriptor(AnotherTestUIAnnotation.class, new ElementDescriptor(30, TestLinkkiComponentDefinition.create(() -> "AnotherTestUIAnnotation"), BoundProperty .of(TestPmo.ILLEGAL_DUAL_PMO_PROPERTY_WITHOUT_DIFFERENTIATOR), Collections.emptyList()), TestPmo.class); }); }
@Test public void testAddDescriptor_DifferentProperty() { PropertyElementDescriptors descriptors = new PropertyElementDescriptors(TestPmo.SINGLE_PMO_PROPERTY); Assertions.assertThrows(IllegalArgumentException.class, () -> { descriptors.addDescriptor(TestUIAnnotation.class, new ElementDescriptor(30, TestLinkkiComponentDefinition.create(() -> "TestUIAnnotation"), BoundProperty.of(TestPmo.DUAL_PMO_PROPERTY), Collections.emptyList()), TestPmo.class); }); } |
### Question:
PropertyElementDescriptors { public void addAspect(List<LinkkiAspectDefinition> aspectDefs) { additionalAspects.addAll(aspectDefs); } PropertyElementDescriptors(String pmoPropertyName); int getPosition(); String getPmoPropertyName(); ElementDescriptor getDescriptor(Object pmo); void addAspect(List<LinkkiAspectDefinition> aspectDefs); boolean isNotEmpty(); List<LinkkiAspectDefinition> getAllAspects(); }### Answer:
@Test public void testAddAspect() { PropertyElementDescriptors descriptors = new PropertyElementDescriptors(TestPmo.SINGLE_PMO_PROPERTY); assertThat(descriptors.getAllAspects(), is(empty())); EnabledAspectDefinition enabledAspectDefinition = new EnabledAspectDefinition(EnabledType.ENABLED); descriptors.addAspect(Arrays.<LinkkiAspectDefinition> asList(enabledAspectDefinition)); assertThat(descriptors.getAllAspects(), contains(enabledAspectDefinition)); } |
### Question:
PropertyElementDescriptors { public boolean isNotEmpty() { return !descriptors.isEmpty(); } PropertyElementDescriptors(String pmoPropertyName); int getPosition(); String getPmoPropertyName(); ElementDescriptor getDescriptor(Object pmo); void addAspect(List<LinkkiAspectDefinition> aspectDefs); boolean isNotEmpty(); List<LinkkiAspectDefinition> getAllAspects(); }### Answer:
@Test public void testIsNotEmpty() { PropertyElementDescriptors descriptors = new PropertyElementDescriptors(TestPmo.SINGLE_PMO_PROPERTY); assertThat(descriptors.isNotEmpty(), is(false)); descriptors.addAspect(Arrays.<LinkkiAspectDefinition> asList(new EnabledAspectDefinition(EnabledType.ENABLED))); assertThat(descriptors.isNotEmpty(), is(false)); descriptors.addDescriptor(TestUIAnnotation.class, new ElementDescriptor(0, TestLinkkiComponentDefinition.create(), BoundProperty.of(TestPmo.SINGLE_PMO_PROPERTY), Collections.emptyList()), TestPmo.class); assertThat(descriptors.isNotEmpty()); } |
### Question:
PropertyElementDescriptors { public List<LinkkiAspectDefinition> getAllAspects() { return Stream.concat( descriptors.values().stream() .map(d -> d.getAspectDefinitions()) .flatMap(Collection::stream), additionalAspects.stream()) .collect(toList()); } PropertyElementDescriptors(String pmoPropertyName); int getPosition(); String getPmoPropertyName(); ElementDescriptor getDescriptor(Object pmo); void addAspect(List<LinkkiAspectDefinition> aspectDefs); boolean isNotEmpty(); List<LinkkiAspectDefinition> getAllAspects(); }### Answer:
@Test public void testGetAllAspects() { PropertyElementDescriptors descriptors = new PropertyElementDescriptors(TestPmo.DUAL_PMO_PROPERTY); EnabledAspectDefinition enabledAspectDefinition = new EnabledAspectDefinition(EnabledType.ENABLED); descriptors.addDescriptor(TestUIAnnotation.class, new ElementDescriptor(0, TestLinkkiComponentDefinition.create(), BoundProperty.of(TestPmo.DUAL_PMO_PROPERTY), Collections.singletonList(enabledAspectDefinition)), TestPmo.class); VisibleAspectDefinition visibleAspectDefinition = new VisibleAspectDefinition(VisibleType.VISIBLE); descriptors.addDescriptor(AnotherTestUIAnnotation.class, new ElementDescriptor(0, TestLinkkiComponentDefinition.create(), BoundProperty.of(TestPmo.DUAL_PMO_PROPERTY), Collections.singletonList(visibleAspectDefinition)), TestPmo.class); TestComponentClickAspectDefinition clickAspectDefinition = new TestComponentClickAspectDefinition(); descriptors.addAspect(Arrays.<LinkkiAspectDefinition> asList(clickAspectDefinition)); assertThat(descriptors.getAllAspects(), containsInAnyOrder(enabledAspectDefinition, visibleAspectDefinition, clickAspectDefinition)); } |
### Question:
AspectAnnotationReader { public static <UI_ANNOTATION extends Annotation> List<LinkkiAspectDefinition> createAspectDefinitionsFrom( UI_ANNOTATION uiAnnotation) { return createAspectDefinitionsStreamFrom(uiAnnotation) .collect(Collectors.toList()); } private AspectAnnotationReader(); static List<LinkkiAspectDefinition> createAspectDefinitionsFrom(
UI_ANNOTATION uiAnnotation); static List<LinkkiAspectDefinition> createAspectDefinitionsFor(AnnotatedElement annotatedElement); static List<LinkkiAspectDefinition> createAspectDefinitionsFor(Annotation componentDefAnnotation,
AnnotatedElement annotatedElement); }### Answer:
@Test public void testCreateAspectDefinitionsFrom() throws NoSuchMethodException, SecurityException { TestAnnotation annotationToTest = TestClass.class.getMethod("something").getAnnotation(TestAnnotation.class); List<LinkkiAspectDefinition> definitions = AspectAnnotationReader .createAspectDefinitionsFrom(annotationToTest); assertThat(definitions.size(), is(2)); LinkkiAspectDefinition definition = definitions.get(0); assertThat(definition, is(instanceOf(TestAspectDefinition.class))); assertThat(definition, isInitializedWith(TestAnnotation.class)); LinkkiAspectDefinition anotherDefinition = definitions.get(1); assertThat(anotherDefinition, is(instanceOf(AnotherTestAspectDefinition.class))); assertThat(anotherDefinition, isInitializedWith(TestAnnotation.class)); } |
### Question:
AspectAnnotationReader { public static List<LinkkiAspectDefinition> createAspectDefinitionsFor(AnnotatedElement annotatedElement) { return getAllAnnotations(annotatedElement) .map(a -> AspectAnnotationReader.createAspectDefinitionsFrom(a)) .flatMap(Collection::stream) .collect(Collectors.toList()); } private AspectAnnotationReader(); static List<LinkkiAspectDefinition> createAspectDefinitionsFrom(
UI_ANNOTATION uiAnnotation); static List<LinkkiAspectDefinition> createAspectDefinitionsFor(AnnotatedElement annotatedElement); static List<LinkkiAspectDefinition> createAspectDefinitionsFor(Annotation componentDefAnnotation,
AnnotatedElement annotatedElement); }### Answer:
@Test public void testCreateAspectDefinitionsFor() throws NoSuchMethodException, SecurityException { AnnotatedElement annotatedElement = TestClass.class.getMethod("somethingElse"); List<LinkkiAspectDefinition> definitions = AspectAnnotationReader .createAspectDefinitionsFor(annotatedElement); assertThat(definitions.size(), is(3)); LinkkiAspectDefinition definition = definitions.get(0); assertThat(definition, is(instanceOf(TestAspectDefinition.class))); assertThat(definition, isInitializedWith(TestAnnotation.class)); LinkkiAspectDefinition anotherDefinition = definitions.get(1); assertThat(anotherDefinition, is(instanceOf(AnotherTestAspectDefinition.class))); assertThat(anotherDefinition, isInitializedWith(TestAnnotation.class)); LinkkiAspectDefinition definitionFromSecondAnnotation = definitions.get(2); assertThat(definitionFromSecondAnnotation, is(instanceOf(TestAspectDefinition.class))); assertThat(definitionFromSecondAnnotation, isInitializedWith(AnotherTestAnnotation.class)); }
@Test public void testCreateAspectDefinitionsFor_Dynamic() throws NoSuchMethodException, SecurityException { class DynamicFieldTestPmo { @TestComponentAnnotation1(position = 10) @TestComponentAnnotation2(position = 10) @AnotherTestAnnotation @SuppressFBWarnings("UMAC_UNCALLABLE_METHOD_OF_ANONYMOUS_CLASS") public String getDynamic() { return "dyn"; } } AnnotatedElement annotatedElement = DynamicFieldTestPmo.class.getMethod("getDynamic"); List<LinkkiAspectDefinition> definitions = AspectAnnotationReader .createAspectDefinitionsFor(annotatedElement.getAnnotation(TestComponentAnnotation1.class), annotatedElement); assertThat(definitions.size(), is(2)); assertThat(definitions.get(0), is(instanceOf(TestAspectDefinition.class))); assertThat(definitions.get(0), isInitializedWith(TestComponentAnnotation1.class)); assertThat(definitions.get(1), is(instanceOf(TestAspectDefinition.class))); assertThat(definitions.get(1), isInitializedWith(AnotherTestAnnotation.class)); definitions = AspectAnnotationReader .createAspectDefinitionsFor(annotatedElement.getAnnotation(TestComponentAnnotation2.class), annotatedElement); assertThat(definitions.size(), is(2)); assertThat(definitions.get(0), is(instanceOf(YetAnotherTestAspectDefinition.class))); assertThat(definitions.get(0), isInitializedWith(TestComponentAnnotation2.class)); assertThat(definitions.get(1), is(instanceOf(TestAspectDefinition.class))); assertThat(definitions.get(1), isInitializedWith(AnotherTestAnnotation.class)); } |
### Question:
Services { public static <S> S get(Class<S> serviceClass) { @SuppressWarnings("unchecked") S service = (S)INSTANCES.computeIfAbsent(serviceClass, sc -> { ServiceLoader<?> serviceLoader = ServiceLoader.load(sc); return StreamSupport.stream(serviceLoader.spliterator(), false).reduce((f1, f2) -> { throw new IllegalStateException( "Multiple implementations of " + sc.getName() + " found on the classpath: " + f1.getClass() + " and " + f2.getClass()); }).orElseThrow(() -> new IllegalStateException( "No implementation of " + sc.getName() + " found on the classpath.")); }); return service; } private Services(); static S get(Class<S> serviceClass); }### Answer:
@Test public void testGetSingleImplementation() { assertThat(Services.get(InterfaceWithSingleImplementation.class), is(instanceOf(SingleImplementation.class))); }
@Test public void testGetNoImplementation() { Assertions.assertThrows(IllegalStateException.class, () -> { Services.get(InterfaceWithoutImplementation.class); }); }
@Test public void testGetMultipleImplementations() { Assertions.assertThrows(IllegalStateException.class, () -> { Services.get(InterfaceWithMultipleImplementations.class); }); } |
### Question:
StaticModelToUiAspectDefinition extends ModelToUiAspectDefinition<VALUE_TYPE> { @Override public Handler createUiUpdater(PropertyDispatcher propertyDispatcher, ComponentWrapper componentWrapper) { super.createUiUpdater(propertyDispatcher, componentWrapper).apply(); return Handler.NOP_HANDLER; } @Override Handler createUiUpdater(PropertyDispatcher propertyDispatcher, ComponentWrapper componentWrapper); }### Answer:
@SuppressWarnings("unchecked") @Test public void testCreateUiUpdater() { when(propertyDispatcher.pull(any(Aspect.class))).thenReturn(true); assertThat(componentWrapper.getComponent().isEnabled(), is(false)); Handler handler = aspectDefinition.createUiUpdater(propertyDispatcher, componentWrapper); verify(propertyDispatcher, times(1)).pull(any(Aspect.class)); assertThat(componentWrapper.getComponent().isEnabled(), is(true)); handler.apply(); verify(propertyDispatcher, times(1)).pull(any(Aspect.class)); }
@Test public void testCreateUiUpdater_WrapsExceptionInPull() { when(propertyDispatcher.pull(Mockito.any())).thenThrow(RuntimeException.class); Assertions.assertThrows(LinkkiBindingException.class, () -> { aspectDefinition.createUiUpdater(propertyDispatcher, componentWrapper); }); } |
### Question:
ModelToUiAspectDefinition implements LinkkiAspectDefinition { @Override public Handler createUiUpdater(PropertyDispatcher propertyDispatcher, ComponentWrapper componentWrapper) { Consumer<V> setter = createComponentValueSetter(componentWrapper); Aspect<V> aspect = createAspect(); return () -> { try { setter.accept(propertyDispatcher.pull(aspect)); } catch (RuntimeException e) { handleUiUpdateException(e, propertyDispatcher, aspect); } }; } @Override Handler createUiUpdater(PropertyDispatcher propertyDispatcher, ComponentWrapper componentWrapper); abstract Aspect<V> createAspect(); abstract Consumer<V> createComponentValueSetter(ComponentWrapper componentWrapper); }### Answer:
@SuppressWarnings("unchecked") @Test public void testCreateUiUpdater() { when(propertyDispatcher.pull(any(Aspect.class))).thenReturn(true); Handler handler = aspectDefinition.createUiUpdater(propertyDispatcher, componentWrapper); assertThat(componentWrapper.getComponent().isEnabled(), is(false)); handler.apply(); verify(propertyDispatcher, times(1)).pull(any(Aspect.class)); assertThat(componentWrapper.getComponent().isEnabled(), is(true)); handler.apply(); verify(propertyDispatcher, times(2)).pull(any(Aspect.class)); }
@Test public void testCreateUiUpdater_WrapsExceptionInPull() { when(propertyDispatcher.pull(any())).thenThrow(RuntimeException.class); Handler handler = aspectDefinition.createUiUpdater(propertyDispatcher, componentWrapper); Assertions.assertThrows(LinkkiBindingException.class, () -> { handler.apply(); }); } |
### Question:
ModelToUiAspectDefinition implements LinkkiAspectDefinition { public abstract Aspect<V> createAspect(); @Override Handler createUiUpdater(PropertyDispatcher propertyDispatcher, ComponentWrapper componentWrapper); abstract Aspect<V> createAspect(); abstract Consumer<V> createComponentValueSetter(ComponentWrapper componentWrapper); }### Answer:
@Test public void testCreateAspect() { Aspect<Boolean> createdAspect = aspectDefinition.createAspect(); assertThat(createdAspect.getName(), is(TestModelToUiAspectDefinition.NAME)); assertThat(createdAspect.getValue(), is(true)); } |
### Question:
ModelToUiAspectDefinition implements LinkkiAspectDefinition { public abstract Consumer<V> createComponentValueSetter(ComponentWrapper componentWrapper); @Override Handler createUiUpdater(PropertyDispatcher propertyDispatcher, ComponentWrapper componentWrapper); abstract Aspect<V> createAspect(); abstract Consumer<V> createComponentValueSetter(ComponentWrapper componentWrapper); }### Answer:
@Test public void testCreateComponentValueSetter() { Consumer<Boolean> setter = aspectDefinition.createComponentValueSetter(componentWrapper); assertThat(componentWrapper.getComponent().isEnabled(), is(false)); setter.accept(true); assertThat(componentWrapper.getComponent().isEnabled(), is(true)); } |
### Question:
CompositeAspectDefinition implements LinkkiAspectDefinition { @Override public Handler createUiUpdater(PropertyDispatcher propertyDispatcher, ComponentWrapper componentWrapper) { return aspectDefinitions.stream() .filter(d -> d.supports(componentWrapper.getType())) .map(lad -> lad.createUiUpdater(propertyDispatcher, componentWrapper)) .reduce(Handler.NOP_HANDLER, Handler::andThen); } CompositeAspectDefinition(@NonNull LinkkiAspectDefinition... aspectDefinitions); CompositeAspectDefinition(List<LinkkiAspectDefinition> aspectDefinitions); @Override Handler createUiUpdater(PropertyDispatcher propertyDispatcher, ComponentWrapper componentWrapper); @Override void initModelUpdate(PropertyDispatcher propertyDispatcher,
ComponentWrapper componentWrapper,
Handler modelUpdated); @Override boolean supports(WrapperType type); }### Answer:
@Test public void testCreateUiUpdater() { CompositeAspectDefinition composite = new CompositeAspectDefinition(aspect1, aspect2NotSupported, aspect3); composite.createUiUpdater(propertyDispatcher, componentWrapper); verify(aspect1).supports(WrapperType.FIELD); verify(aspect2NotSupported).supports(WrapperType.FIELD); verify(aspect3).supports(WrapperType.FIELD); verify(aspect1).createUiUpdater(propertyDispatcher, componentWrapper); verify(aspect2NotSupported, never()).createUiUpdater(propertyDispatcher, componentWrapper); verify(aspect3).createUiUpdater(propertyDispatcher, componentWrapper); } |
### Question:
CompositeAspectDefinition implements LinkkiAspectDefinition { @Override public void initModelUpdate(PropertyDispatcher propertyDispatcher, ComponentWrapper componentWrapper, Handler modelUpdated) { aspectDefinitions .stream() .filter(d -> d.supports(componentWrapper.getType())) .forEach(lad -> { try { lad.initModelUpdate(propertyDispatcher, componentWrapper, modelUpdated); } catch (RuntimeException e) { throw new LinkkiBindingException( e.getMessage() + " while init model update of " + lad.getClass().getSimpleName() + " for " + componentWrapper + " <=> " + propertyDispatcher, e); } }); } CompositeAspectDefinition(@NonNull LinkkiAspectDefinition... aspectDefinitions); CompositeAspectDefinition(List<LinkkiAspectDefinition> aspectDefinitions); @Override Handler createUiUpdater(PropertyDispatcher propertyDispatcher, ComponentWrapper componentWrapper); @Override void initModelUpdate(PropertyDispatcher propertyDispatcher,
ComponentWrapper componentWrapper,
Handler modelUpdated); @Override boolean supports(WrapperType type); }### Answer:
@Test public void testInitModelUpdate() { CompositeAspectDefinition composite = new CompositeAspectDefinition(aspect1, aspect2NotSupported, aspect3); composite.initModelUpdate(propertyDispatcher, componentWrapper, modelUpdated); verify(aspect1).supports(WrapperType.FIELD); verify(aspect2NotSupported).supports(WrapperType.FIELD); verify(aspect3).supports(WrapperType.FIELD); verify(aspect1).initModelUpdate(propertyDispatcher, componentWrapper, modelUpdated); verify(aspect2NotSupported, never()).initModelUpdate(propertyDispatcher, componentWrapper, modelUpdated); verify(aspect3).initModelUpdate(propertyDispatcher, componentWrapper, modelUpdated); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.