Datasets:
Minata
/
512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files
xet
Community
method2testcases
stringlengths
118
3.08k
### Question: ParserConfiguration { public ParserConfiguration registerDatatype(final String name, final DatatypeConstantHandler handler) throws IllegalArgumentException { Validate.isTrue(!this.datatypes.containsKey(name), "The Data type \"%s\" is already registered.", name); this.datatypes.put(name, handler); return this; } ParserConfiguration(); ParserConfiguration(ParserConfiguration other); ParserConfiguration registerDataSource(final String name, final DataSourceDeclarationHandler handler); DataSource parseDataSourceSpecificPartOfDataSourceDeclaration(PositiveLiteral declaration); Constant parseDatatypeConstant(final String lexicalForm, final String datatype, final TermFactory termFactory); boolean isConfigurableLiteralRegistered(ConfigurableLiteralDelimiter delimiter); Term parseConfigurableLiteral(ConfigurableLiteralDelimiter delimiter, String syntacticForm, final SubParserFactory subParserFactory); ParserConfiguration registerDatatype(final String name, final DatatypeConstantHandler handler); ParserConfiguration registerLiteral(ConfigurableLiteralDelimiter delimiter, ConfigurableLiteralHandler handler); ParserConfiguration registerDirective(String name, DirectiveHandler<KnowledgeBase> handler); KnowledgeBase parseDirectiveStatement(String name, List<Argument> arguments, SubParserFactory subParserFactory); ParserConfiguration setNamedNulls(boolean allow); ParserConfiguration allowNamedNulls(); ParserConfiguration disallowNamedNulls(); boolean isParsingOfNamedNullsAllowed(); String getImportBasePath(); ParserConfiguration setImportBasePath(String importBasePath); static final List<String> RESERVED_DIRECTIVE_NAMES; }### Answer: @Test(expected = IllegalArgumentException.class) public void registerDatatype_duplicateName_throws() { parserConfiguration.registerDatatype(TYPE_NAME, datatypeConstantHandler).registerDatatype(TYPE_NAME, datatypeConstantHandler); }
### Question: ParserConfiguration { public boolean isParsingOfNamedNullsAllowed() { return this.allowNamedNulls; } ParserConfiguration(); ParserConfiguration(ParserConfiguration other); ParserConfiguration registerDataSource(final String name, final DataSourceDeclarationHandler handler); DataSource parseDataSourceSpecificPartOfDataSourceDeclaration(PositiveLiteral declaration); Constant parseDatatypeConstant(final String lexicalForm, final String datatype, final TermFactory termFactory); boolean isConfigurableLiteralRegistered(ConfigurableLiteralDelimiter delimiter); Term parseConfigurableLiteral(ConfigurableLiteralDelimiter delimiter, String syntacticForm, final SubParserFactory subParserFactory); ParserConfiguration registerDatatype(final String name, final DatatypeConstantHandler handler); ParserConfiguration registerLiteral(ConfigurableLiteralDelimiter delimiter, ConfigurableLiteralHandler handler); ParserConfiguration registerDirective(String name, DirectiveHandler<KnowledgeBase> handler); KnowledgeBase parseDirectiveStatement(String name, List<Argument> arguments, SubParserFactory subParserFactory); ParserConfiguration setNamedNulls(boolean allow); ParserConfiguration allowNamedNulls(); ParserConfiguration disallowNamedNulls(); boolean isParsingOfNamedNullsAllowed(); String getImportBasePath(); ParserConfiguration setImportBasePath(String importBasePath); static final List<String> RESERVED_DIRECTIVE_NAMES; }### Answer: @Test public void isParsingOfNamedNullsAllowed_default_returnsTrue() { assertTrue("named nulls are allowed by default", parserConfiguration.isParsingOfNamedNullsAllowed()); }
### Question: ParserConfiguration { public Term parseConfigurableLiteral(ConfigurableLiteralDelimiter delimiter, String syntacticForm, final SubParserFactory subParserFactory) throws ParsingException { if (!isConfigurableLiteralRegistered(delimiter)) { throw new ParsingException( "No handler for configurable literal delimiter \"" + delimiter + "\" registered."); } ConfigurableLiteralHandler handler = literals.get(delimiter); return handler.parseLiteral(syntacticForm, subParserFactory); } ParserConfiguration(); ParserConfiguration(ParserConfiguration other); ParserConfiguration registerDataSource(final String name, final DataSourceDeclarationHandler handler); DataSource parseDataSourceSpecificPartOfDataSourceDeclaration(PositiveLiteral declaration); Constant parseDatatypeConstant(final String lexicalForm, final String datatype, final TermFactory termFactory); boolean isConfigurableLiteralRegistered(ConfigurableLiteralDelimiter delimiter); Term parseConfigurableLiteral(ConfigurableLiteralDelimiter delimiter, String syntacticForm, final SubParserFactory subParserFactory); ParserConfiguration registerDatatype(final String name, final DatatypeConstantHandler handler); ParserConfiguration registerLiteral(ConfigurableLiteralDelimiter delimiter, ConfigurableLiteralHandler handler); ParserConfiguration registerDirective(String name, DirectiveHandler<KnowledgeBase> handler); KnowledgeBase parseDirectiveStatement(String name, List<Argument> arguments, SubParserFactory subParserFactory); ParserConfiguration setNamedNulls(boolean allow); ParserConfiguration allowNamedNulls(); ParserConfiguration disallowNamedNulls(); boolean isParsingOfNamedNullsAllowed(); String getImportBasePath(); ParserConfiguration setImportBasePath(String importBasePath); static final List<String> RESERVED_DIRECTIVE_NAMES; }### Answer: @Test(expected = ParsingException.class) public void parseConfigurableLiteral_unregisteredLiteral_throws() throws ParsingException { parserConfiguration.parseConfigurableLiteral(ConfigurableLiteralDelimiter.BRACE, "test", subParserFactory); }
### Question: TweeterApplicationRunner implements ApplicationRunner { @Override public void run(ApplicationArguments args) throws Exception { this.tweetMapper .insert(new Tweet(UUID.randomUUID(), "Demo1", "making", Instant.now())); this.tweetMapper .insert(new Tweet(UUID.randomUUID(), "Demo2", "making", Instant.now())); long count = this.tweetMapper.count(); System.out.println("Number of tweets: " + count); List<Tweet> tweets = this.tweetMapper.findAll(); tweets.forEach(tweet -> System.out.println(tweet)); } TweeterApplicationRunner(TweetMapper tweetMapper); @Override void run(ApplicationArguments args); }### Answer: @Test void contextLoads(CapturedOutput capture) throws Exception { TweetMapper tweetMapper = mock(TweetMapper.class); given(tweetMapper.count()).willReturn(2L); given(tweetMapper.insert(any())).willReturn(1); Instant now = Instant.now(); UUID uuid1 = UUID.randomUUID(); UUID uuid2 = UUID.randomUUID(); given(tweetMapper.findAll()) .willReturn(Arrays.asList(new Tweet(uuid1, "test1", "making", now), new Tweet(uuid2, "test2", "making", now))); TweeterApplicationRunner tweeterApplicationRunner = new TweeterApplicationRunner( tweetMapper); tweeterApplicationRunner.run(new DefaultApplicationArguments(new String[] {})); String output = capture.toString(); assertThat(output).contains("Number of tweets: 2"); assertThat(output).contains("Tweet{uuid=" + uuid1 + ", text='test1', username='making', createdAt=" + now + "}"); assertThat(output).contains("Tweet{uuid=" + uuid2 + ", text='test2', username='making', createdAt=" + now + "}"); }
### Question: TweeterApplicationRunner implements ApplicationRunner { @Override @Transactional public void run(ApplicationArguments args) throws Exception { this.tweetRepository.save(new Tweet(null, "Demo1", "making", Instant.now())); this.tweetRepository.save(new Tweet(null, "Demo2", "making", Instant.now())); long count = this.tweetRepository.count(); System.out.println("Number of tweets: " + count); Iterable<Tweet> tweets = this.tweetRepository.findAll(); tweets.forEach(tweet -> System.out.println(tweet)); } TweeterApplicationRunner(TweetRepository tweetRepository); @Override @Transactional void run(ApplicationArguments args); }### Answer: @Test void contextLoads(CapturedOutput capture) throws Exception { TweetRepository TweetRepository = mock(TweetRepository.class); given(TweetRepository.count()).willReturn(2L); Instant now = Instant.now(); UUID uuid1 = UUID.randomUUID(); UUID uuid2 = UUID.randomUUID(); given(TweetRepository.findAll()) .willReturn(Arrays.asList(new Tweet(uuid1, "test1", "making", now), new Tweet(uuid2, "test2", "making", now))); TweeterApplicationRunner tweeterApplicationRunner = new TweeterApplicationRunner( TweetRepository); tweeterApplicationRunner.run(new DefaultApplicationArguments(new String[] {})); String output = capture.toString(); assertThat(output).contains("Number of tweets: 2"); assertThat(output).contains("Tweet{uuid=" + uuid1 + ", text='test1', username='making', createdAt=" + now + "}"); assertThat(output).contains("Tweet{uuid=" + uuid2 + ", text='test2', username='making', createdAt=" + now + "}"); }
### Question: MarkdownPrinter { public void print(InputStream stream) { System.out.print("Input markdown: "); try { String markdown = StreamUtils.copyToString(stream, StandardCharsets.UTF_8); String html = this.renderer.render(markdown); System.out.println(html); } catch (IOException e) { throw new UncheckedIOException(e); } } MarkdownPrinter(@Online /* (1) */ MarkdownRenderer renderer); void print(InputStream stream); }### Answer: @Test void print(CapturedOutput capture ) { MarkdownRenderer markdownRenderer = Mockito.mock(MarkdownRenderer.class); given(markdownRenderer.render(anyString())).willReturn("<p>Markdown!</p>"); MarkdownPrinter printer = new MarkdownPrinter(markdownRenderer); InputStream stream = new ByteArrayInputStream( "Markdown!".getBytes(StandardCharsets.UTF_8)); printer.print(stream); assertThat(capture.toString()).contains("Input markdown:"); assertThat(capture.toString()).contains("<p>Markdown!</p>"); }
### Question: MarkdownPrinter { public void print(InputStream stream) { System.out.print("Input markdown: "); try { String markdown = StreamUtils.copyToString(stream, StandardCharsets.UTF_8); String html = this.renderer.render(markdown); System.out.println(html); } catch (IOException e) { throw new UncheckedIOException(e); } } MarkdownPrinter(MarkdownRenderer renderer); void print(InputStream stream); }### Answer: @Test void print(CapturedOutput capture ) { MarkdownRenderer markdownRenderer = Mockito.mock(MarkdownRenderer.class); given(markdownRenderer.render(anyString())).willReturn("<p>Markdown!</p>"); MarkdownPrinter printer = new MarkdownPrinter(markdownRenderer); InputStream stream = new ByteArrayInputStream( "Markdown!".getBytes(StandardCharsets.UTF_8)); printer.print(stream); assertThat(capture.toString()).contains("Input markdown:"); assertThat(capture.toString()).contains("<p>Markdown!</p>"); }
### Question: MarkdownPrinter { @DetectSlowExecution(threshold = 1000) public void print(InputStream stream) { System.out.print("Input markdown: "); try { String markdown = StreamUtils.copyToString(stream, StandardCharsets.UTF_8); String html = this.renderer.render(markdown); System.out.println(html); } catch (IOException e) { throw new UncheckedIOException(e); } } MarkdownPrinter(MarkdownRenderer renderer); @DetectSlowExecution(threshold = 1000) void print(InputStream stream); }### Answer: @Test void print(CapturedOutput capture ) { MarkdownRenderer markdownRenderer = Mockito.mock(MarkdownRenderer.class); given(markdownRenderer.render(anyString())).willReturn("<p>Markdown!</p>"); MarkdownPrinter printer = new MarkdownPrinter(markdownRenderer); InputStream stream = new ByteArrayInputStream( "Markdown!".getBytes(StandardCharsets.UTF_8)); printer.print(stream); assertThat(capture.toString()).contains("Input markdown:"); assertThat(capture.toString()).contains("<p>Markdown!</p>"); }
### Question: MarkdownPrinter { public void print(InputStream stream) { System.out.print("Input markdown: "); try { String markdown = StreamUtils.copyToString(stream, StandardCharsets.UTF_8); String html = this.renderer.render(markdown); System.out.println(html); } catch (IOException e) { throw new UncheckedIOException(e); } } @Autowired MarkdownPrinter(MarkdownRenderer renderer); void print(InputStream stream); }### Answer: @Test void print(CapturedOutput capture ) { MarkdownRenderer markdownRenderer = Mockito.mock(MarkdownRenderer.class); given(markdownRenderer.render(anyString())).willReturn("<p>Markdown!</p>"); MarkdownPrinter printer = new MarkdownPrinter(markdownRenderer); InputStream stream = new ByteArrayInputStream( "Markdown!".getBytes(StandardCharsets.UTF_8)); printer.print(stream); assertThat(capture.toString()).contains("Input markdown:"); assertThat(capture.toString()).contains("<p>Markdown!</p>"); }
### Question: TweeterApplicationRunner implements ApplicationRunner { @Override @Transactional public void run(ApplicationArguments args) throws Exception { this.tweetRepository .save(new Tweet(UUID.randomUUID(), "Demo1", "making", Instant.now())); this.tweetRepository .save(new Tweet(UUID.randomUUID(), "Demo2", "making", Instant.now())); long count = this.tweetRepository.count(); System.out.println("Number of tweets: " + count); Iterable<Tweet> tweets = this.tweetRepository.findAll(); tweets.forEach(tweet -> System.out.println(tweet)); } TweeterApplicationRunner(TweetRepository tweetRepository); @Override @Transactional void run(ApplicationArguments args); }### Answer: @Test void contextLoads(CapturedOutput capture) throws Exception { TweetRepository TweetRepository = mock(TweetRepository.class); given(TweetRepository.count()).willReturn(2L); Instant now = Instant.now(); UUID uuid1 = UUID.randomUUID(); UUID uuid2 = UUID.randomUUID(); given(TweetRepository.findAll()) .willReturn(Arrays.asList(new Tweet(uuid1, "test1", "making", now), new Tweet(uuid2, "test2", "making", now))); TweeterApplicationRunner tweeterApplicationRunner = new TweeterApplicationRunner( TweetRepository); tweeterApplicationRunner.run(new DefaultApplicationArguments(new String[] {})); String output = capture.toString(); assertThat(output).contains("Number of tweets: 2"); assertThat(output).contains("Tweet{uuid=" + uuid1 + ", text='test1', username='making', createdAt=" + now + "}"); assertThat(output).contains("Tweet{uuid=" + uuid2 + ", text='test2', username='making', createdAt=" + now + "}"); }
### Question: MarkdownPrinter { public void print(InputStream stream) { System.out.print("Input markdown: "); try { String markdown = StreamUtils.copyToString(stream, StandardCharsets.UTF_8); String html = this.renderer.render(markdown); System.out.println(html); } catch (IOException e) { throw new UncheckedIOException(e); } } MarkdownPrinter( @Qualifier("gitHubApiMarkdownRenderer") /* (1) */ MarkdownRenderer renderer); void print(InputStream stream); }### Answer: @Test void print(CapturedOutput capture ) { MarkdownRenderer markdownRenderer = Mockito.mock(MarkdownRenderer.class); given(markdownRenderer.render(anyString())).willReturn("<p>Markdown!</p>"); MarkdownPrinter printer = new MarkdownPrinter(markdownRenderer); InputStream stream = new ByteArrayInputStream( "Markdown!".getBytes(StandardCharsets.UTF_8)); printer.print(stream); assertThat(capture.toString()).contains("Input markdown:"); assertThat(capture.toString()).contains("<p>Markdown!</p>"); }
### Question: MarkdownPrinter { public void print(InputStream stream) { System.out.print("Input markdown: "); try { String markdown = StreamUtils.copyToString(stream, StandardCharsets.UTF_8); for (int i = 0; i < 3; i++) { String html = this.renderer.render(markdown); System.out.println("TrackId = " + trackId.asLong()); System.out.println(html); } } catch (IOException e) { throw new UncheckedIOException(e); } } MarkdownPrinter(MarkdownRenderer renderer, TrackId trackId); void print(InputStream stream); }### Answer: @Test void print(CapturedOutput capture) { MarkdownRenderer markdownRenderer = Mockito.mock(MarkdownRenderer.class); given(markdownRenderer.render(anyString())).willReturn("<p>Markdown!</p>"); MarkdownPrinter printer = new MarkdownPrinter(markdownRenderer, new TrackId()); InputStream stream = new ByteArrayInputStream( "Markdown!".getBytes(StandardCharsets.UTF_8)); printer.print(stream); assertThat(capture.toString()).contains("Input markdown:"); assertThat(capture.toString()).contains("<p>Markdown!</p>"); }
### Question: FollowingsMapper { public Followings findFollowingsByUsername(String username) { return this.jdbcTemplate.query("SELECT t.username, f.followee AS tweeter FROM tweeters AS t INNER JOIN followings AS f ON t.username = f.follower WHERE t.username = ? ORDER BY f.created_at DESC", followingsResultSetExtractor, username); } FollowingsMapper(JdbcTemplate jdbcTemplate); Followings findFollowingsByUsername(String username); Followings findFollowersByUsername(String username); }### Answer: @Test void findFollowingsByUsername() { final Followings followings = this.followingsMapper.findFollowingsByUsername("foo"); assertThat(followings.getUsername()).isEqualTo("foo"); assertThat(followings.getTweeters()).containsExactly(new Tweeter("foo4"), new Tweeter("foo3"), new Tweeter("foo2")); }
### Question: FollowingsMapper { public Followings findFollowersByUsername(String username) { return this.jdbcTemplate.query("SELECT t.username, f.follower AS tweeter FROM tweeters AS t INNER JOIN followings AS f ON t.username = f.followee WHERE t.username = ? ORDER BY f.created_at DESC", followingsResultSetExtractor, username); } FollowingsMapper(JdbcTemplate jdbcTemplate); Followings findFollowingsByUsername(String username); Followings findFollowersByUsername(String username); }### Answer: @Test void findFollowersByUsername() { final Followings followings = this.followingsMapper.findFollowersByUsername("foo"); assertThat(followings.getUsername()).isEqualTo("foo"); assertThat(followings.getTweeters()).containsExactly(new Tweeter("foo4"), new Tweeter("foo2")); }
### Question: Node { @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof Node)) { return false; } Node otherNode = (Node) o; return this.nodeBody.equals(otherNode.nodeBody); } Node(NodeBody nodeBody); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testEquals() { Node a = Node.fromString("hello"); Node b = Node.fromString("world"); Node c = Node.fromString("world"); assertNotEquals(a, b); assertEquals(b, c); Node d = Node.fromPieces(Arrays.asList(a, b)); assertNotEquals(a, d); Node e = Node.fromPieces(Arrays.asList(a, c)); assertEquals(d, e); }
### Question: Interval { public boolean isEmpty() { return this.start >= this.end; } private Interval(int start, boolean startInclusive, int end, boolean endInclusive); static Interval ofOpenOpen(int start, int end); static Interval ofOpenClosed(int start, int end); static Interval ofClosedOpen(int start, int end); static Interval ofClosedClosed(int start, int end); boolean isStartClosed(); boolean isEndClosed(); boolean isEmpty(); boolean isBefore(int point); boolean contains(int point); boolean isAfter(int point); Interval intersect(Interval other); Interval union(Interval other); Interval prefix(Interval other); Interval suffix(Interval other); Interval translate(int amount); Interval translateNegative(int amount); int size(); int start(); int end(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testIsEmpty() { assertTrue(Interval.ofOpenOpen(0, 0).isEmpty()); assertFalse(Interval.ofClosedClosed(0, 0).isEmpty()); assertFalse(Interval.ofClosedOpen(0, 1).isEmpty()); assertTrue(Interval.ofOpenClosed(1, 0).isEmpty()); }
### Question: Interval { public Interval intersect(Interval other) { int start = Math.max(this.start(), other.start()); int end = Math.min(this.end(), other.end()); int actualStart = Math.max(this.start, other.start); int actualEnd = Math.min(this.end, other.end); return new Interval(start, (actualStart & 1) == 0, Math.max(start, end), (actualEnd & 1) != 0); } private Interval(int start, boolean startInclusive, int end, boolean endInclusive); static Interval ofOpenOpen(int start, int end); static Interval ofOpenClosed(int start, int end); static Interval ofClosedOpen(int start, int end); static Interval ofClosedClosed(int start, int end); boolean isStartClosed(); boolean isEndClosed(); boolean isEmpty(); boolean isBefore(int point); boolean contains(int point); boolean isAfter(int point); Interval intersect(Interval other); Interval union(Interval other); Interval prefix(Interval other); Interval suffix(Interval other); Interval translate(int amount); Interval translateNegative(int amount); int size(); int start(); int end(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testIntersect() { assertEquals(Interval.ofClosedOpen(2, 3), Interval.ofOpenOpen(1, 3).intersect(Interval.ofClosedClosed(2, 4))); assertTrue(Interval.ofClosedOpen(1, 2).intersect(Interval.ofClosedClosed(2, 43)).isEmpty()); }
### Question: Interval { public Interval prefix(Interval other) { int start = Math.min(this.start(), other.start()); int end = Math.min(this.end(), other.start()); int actualStart = Math.min(this.start, other.start); int actualEnd = Math.min(this.end, other.start); return new Interval(start, (actualStart & 1) == 0, end, (actualEnd & 1) != 0); } private Interval(int start, boolean startInclusive, int end, boolean endInclusive); static Interval ofOpenOpen(int start, int end); static Interval ofOpenClosed(int start, int end); static Interval ofClosedOpen(int start, int end); static Interval ofClosedClosed(int start, int end); boolean isStartClosed(); boolean isEndClosed(); boolean isEmpty(); boolean isBefore(int point); boolean contains(int point); boolean isAfter(int point); Interval intersect(Interval other); Interval union(Interval other); Interval prefix(Interval other); Interval suffix(Interval other); Interval translate(int amount); Interval translateNegative(int amount); int size(); int start(); int end(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testPrefix() { assertEquals(Interval.ofOpenOpen(1, 2), Interval.ofOpenOpen(1, 4).prefix(Interval.ofClosedClosed(2, 3))); }
### Question: Interval { public Interval suffix(Interval other) { int start = Math.max(this.start(), other.end()); int end = Math.max(this.end(), other.end()); int actualStart = Math.max(this.start, other.end); int actualEnd = Math.max(this.end, other.end); return new Interval(start, (actualStart & 1) == 0, end, (actualEnd & 1) != 0); } private Interval(int start, boolean startInclusive, int end, boolean endInclusive); static Interval ofOpenOpen(int start, int end); static Interval ofOpenClosed(int start, int end); static Interval ofClosedOpen(int start, int end); static Interval ofClosedClosed(int start, int end); boolean isStartClosed(); boolean isEndClosed(); boolean isEmpty(); boolean isBefore(int point); boolean contains(int point); boolean isAfter(int point); Interval intersect(Interval other); Interval union(Interval other); Interval prefix(Interval other); Interval suffix(Interval other); Interval translate(int amount); Interval translateNegative(int amount); int size(); int start(); int end(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testSuffix() { assertEquals(Interval.ofOpenOpen(3, 4), Interval.ofOpenOpen(1, 4).suffix(Interval.ofClosedClosed(2, 3))); }
### Question: Interval { public int size() { return this.end() - this.start(); } private Interval(int start, boolean startInclusive, int end, boolean endInclusive); static Interval ofOpenOpen(int start, int end); static Interval ofOpenClosed(int start, int end); static Interval ofClosedOpen(int start, int end); static Interval ofClosedClosed(int start, int end); boolean isStartClosed(); boolean isEndClosed(); boolean isEmpty(); boolean isBefore(int point); boolean contains(int point); boolean isAfter(int point); Interval intersect(Interval other); Interval union(Interval other); Interval prefix(Interval other); Interval suffix(Interval other); Interval translate(int amount); Interval translateNegative(int amount); int size(); int start(); int end(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testSize() { assertEquals(40, Interval.ofClosedOpen(2, 42).size()); assertEquals(0, Interval.ofClosedOpen(1, 0).size()); }
### Question: Interval { public Interval union(Interval other) { if (this.isEmpty()) return other; if (other.isEmpty()) return this; int start = Math.min(this.start(), other.start()); int end = Math.max(this.end(), other.end()); int actualStart = Math.min(this.start, other.start); int actualEnd = Math.max(this.end, other.end); return new Interval(start, (actualStart & 1) == 0, end, (actualEnd & 1) != 0); } private Interval(int start, boolean startInclusive, int end, boolean endInclusive); static Interval ofOpenOpen(int start, int end); static Interval ofOpenClosed(int start, int end); static Interval ofClosedOpen(int start, int end); static Interval ofClosedClosed(int start, int end); boolean isStartClosed(); boolean isEndClosed(); boolean isEmpty(); boolean isBefore(int point); boolean contains(int point); boolean isAfter(int point); Interval intersect(Interval other); Interval union(Interval other); Interval prefix(Interval other); Interval suffix(Interval other); Interval translate(int amount); Interval translateNegative(int amount); int size(); int start(); int end(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testUnion() { assertEquals(Interval.ofClosedClosed(1, 9), Interval.ofClosedOpen(1, 3).union(Interval.ofOpenClosed(7, 9))); }
### Question: Rope { public Rope concat(Rope anotherRope) { if (anotherRope == null) { throw new IllegalArgumentException("Attempting to concat this rope with null"); } Node newRoot = new Node(this.root.getNodeBody()); return Rope.fromNode(newRoot.concat(anotherRope.root)); } private Rope(Node root, int start, int length); static Rope from(String s); int length(); Rope slice(int start, int end); Rope replace(int start, int end, String newString); Rope concat(Rope anotherRope); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testConcat() { Rope a = Rope.from("hello"); Rope b = Rope.from(" world"); Rope c = a.concat(b); assertEquals(c.toString(), "hello world"); assertEquals(a.toString(), "hello"); assertEquals(b.toString(), " world"); Rope license = Rope.from(text); Rope newLicense = license.concat(Rope.from("=>> MIT LICENSE")); assertEquals(license.toString(), text); assertEquals(newLicense.toString(), text + "=>> MIT LICENSE"); assertNotEquals(license, newLicense); }
### Question: Rope { public Rope replace(int start, int end, String newString) { if (start < this.start || end > this.start + this.length) { throw new IllegalArgumentException( "[" + start + ", " + end + ") interval is out of bounds for current rope"); } if (this.isFull()) { Node newRoot = new Node(this.root.getNodeBody()); newRoot.replaceString(start, end, newString, false); return Rope.fromNode(newRoot); } else { Rope.Builder builder = new Rope.Builder(); this.root.subsequence(builder, this.start, this.start + start); builder.pushString(newString); this.root.subsequence(builder, this.start + end, this.start + this.length); return builder.build(); } } private Rope(Node root, int start, int length); static Rope from(String s); int length(); Rope slice(int start, int end); Rope replace(int start, int end, String newString); Rope concat(Rope anotherRope); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testReplace() { Rope a = Rope.from("hello world"); Rope b = a.replace(1, 9, "era"); assertEquals(b.toString(), "herald"); assertEquals(a.toString(), "hello world"); assertNotEquals(a, b); Rope readme = Rope.from(text); Rope newLicense = readme.replace(32, 40, "UTSAVOZA"); assertEquals(readme.toString(), text); String newText = text.substring(0, 32) + "UTSAVOZA" + text.substring(40, text.length()); assertEquals(newLicense.toString(), newText); assertNotEquals(readme, newLicense); }
### Question: Rope { public Rope slice(int start, int end) { if (start < this.start || end > this.start + this.length) { throw new IllegalArgumentException( "[" + start + ", " + end + ") interval is out of bounds for current rope"); } Node root = this.root; start += this.start; end += this.start - 1; while (root.getHeight() > 0) { ChildIndexOffset indexOffset = getChildIndexOffset(root.getChildren(), start, end); if (indexOffset != null) { int index = indexOffset.index; int offset = indexOffset.offset; root = root.getChildren().get(index); start -= offset; end -= offset; } else { break; } } return Rope.from(root.getString().substring(start, end - start + 1)); } private Rope(Node root, int start, int length); static Rope from(String s); int length(); Rope slice(int start, int end); Rope replace(int start, int end, String newString); Rope concat(Rope anotherRope); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testSlice() { Rope a = Rope.from("hello world"); Rope b = a.slice(1, 9); assertEquals(b.toString(), "ello wo"); assertNotEquals(a, b); Rope readme = Rope.from(text); Rope title = readme.slice(0, 4); assertEquals(title.toString(), "Rope"); assertNotEquals(title, readme); }
### Question: Rope { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (!(obj instanceof Rope)) { return false; } Rope otherRope = (Rope) obj; return this.length == otherRope.length && this.start == otherRope.start && this.root.equals(otherRope.root); } private Rope(Node root, int start, int length); static Rope from(String s); int length(); Rope slice(int start, int end); Rope replace(int start, int end, String newString); Rope concat(Rope anotherRope); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer: @Test public void testEquals() { Rope a = Rope.from("hello"); Rope b = Rope.from("world"); Rope c = Rope.from("hello"); assertNotEquals(a, b); assertEquals(a, c); }
### Question: Node { static Node mergeLeaves(Node rope1, Node rope2) { if (!rope1.isLeaf() || !rope2.isLeaf()) { throw new IllegalArgumentException("mergeLeaves() called with non-leaf node"); } if (rope1.getLength() >= MIN_LEAF && rope2.getLength() >= MIN_LEAF) { return Node.fromPieces(Arrays.asList(rope1, rope2)); } String rope1String = rope1.getLeaf(); String rope2String = rope2.getLeaf(); String ropeString = rope1String + rope2String; if (ropeString.length() <= MAX_LEAF) { return Node.fromStringPiece(ropeString); } else { int splitPoint = findLeafSplitForMerge(ropeString); String leftString = ropeString.substring(0, splitPoint); String rightString = ropeString.substring(splitPoint); Node leftNode = Node.fromStringPiece(leftString); Node rightNode = Node.fromStringPiece(rightString); return Node.fromPieces(Arrays.asList(leftNode, rightNode)); } } Node(NodeBody nodeBody); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testMergeLeaves() { Node hello = Node.fromString("hello"); Node world = Node.fromString("world"); Node mergedLeaves = Node.mergeLeaves(hello, world); Node helloWorld = Node.fromString("helloworld"); assertEquals(mergedLeaves, helloWorld); assertNotEquals(mergedLeaves, hello); assertNotEquals(mergedLeaves, world); mergedLeaves = hello.mergeLeaf(world); assertEquals(helloWorld, mergedLeaves); assertEquals(hello, Node.fromString("hello")); assertEquals(world, Node.fromString("world")); }
### Question: NodeBody { @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof NodeBody)) { return false; } NodeBody otherNodeBody = (NodeBody) o; return otherNodeBody.height == this.height && otherNodeBody.length == this.length && otherNodeBody.newlineCount == this.newlineCount && otherNodeBody.val.equals(this.val); } private NodeBody(Builder builder); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object o); }### Answer: @Test public void testEquals() { String helloStr = "hello"; NodeBody hello = new NodeBody.Builder() .height(0) .length(helloStr.length()) .newlineCount(countOccurrence(helloStr, NEW_LINE)) .val(new NodeBody.Leaf(helloStr)) .build(); String worldStr = "world"; NodeBody world = new NodeBody.Builder() .height(0) .length(worldStr.length()) .newlineCount(countOccurrence(worldStr, NEW_LINE)) .val(new NodeBody.Leaf(worldStr)) .build(); assertNotEquals(hello, world); NodeBody worldCopy = new NodeBody.Builder() .height(0) .length(worldStr.length()) .newlineCount(countOccurrence(worldStr, NEW_LINE)) .val(new NodeBody.Leaf("world")) .build(); assertEquals(world, worldCopy); }
### Question: Node { static Node mergeNodes(List<Node> children1, List<Node> children2) { int totalChildren = children1.size() + children2.size(); List<Node> children = Stream.concat(children1.stream(), children2.stream()).collect(Collectors.toList()); if (totalChildren <= MAX_CHILDREN) { return Node.fromPieces(children); } else { int splitPoint = Math.min(MAX_CHILDREN, totalChildren - MIN_CHILDREN); List<Node> left = children.subList(0, splitPoint); List<Node> right = children.subList(splitPoint, children.size()); List<Node> parent = Arrays.asList(Node.fromPieces(left), Node.fromPieces(right)); return Node.fromPieces(parent); } } Node(NodeBody nodeBody); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testMergeNodes() { Node readme = Node.fromString(text); Node first = Node.fromString(text.substring(0, MAX_LEAF)); Node second = Node.fromString(text.substring(MAX_LEAF, 2 * MAX_LEAF)); Node third = Node.fromString(text.substring(2 * MAX_LEAF)); Node parent = Node.mergeNodes(Arrays.asList(first, second), Collections.singletonList(third)); assertEquals(parent, readme); parent = Node.mergeNodes(Collections.singletonList(first), Arrays.asList(second, third)); assertEquals(parent, readme); }
### Question: Util { static int countOccurrence(String s, String pattern) { Matcher matcher = Pattern.compile(pattern).matcher(s); int newLine = 0; while (matcher.find()) { newLine++; } return newLine; } private Util(); }### Answer: @Test public void testCountNewLines() { assertEquals(3, countOccurrence("\nHello,\nWorld!\n", NEW_LINE)); assertEquals(2, countOccurrence("Hello, World\n\n", NEW_LINE)); }
### Question: Util { static boolean isCharBoundary(String s, int index) { return index == 0 || index == s.length() || s.getBytes()[index] >= -0x40; } private Util(); }### Answer: @Test public void testIsCharBoundary() { String s = "Löwe 老虎 Léopard"; assertTrue(isCharBoundary(s, 0)); assertTrue(isCharBoundary(s, 6)); assertTrue(isCharBoundary(s, s.length())); assertFalse(isCharBoundary(s, 2)); assertFalse(isCharBoundary(s, 8)); }
### Question: Interval { public boolean isBefore(int point) { int value = point * 2; return this.end <= value; } private Interval(int start, boolean startInclusive, int end, boolean endInclusive); static Interval ofOpenOpen(int start, int end); static Interval ofOpenClosed(int start, int end); static Interval ofClosedOpen(int start, int end); static Interval ofClosedClosed(int start, int end); boolean isStartClosed(); boolean isEndClosed(); boolean isEmpty(); boolean isBefore(int point); boolean contains(int point); boolean isAfter(int point); Interval intersect(Interval other); Interval union(Interval other); Interval prefix(Interval other); Interval suffix(Interval other); Interval translate(int amount); Interval translateNegative(int amount); int size(); int start(); int end(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testIsBefore() { Interval iv = Interval.ofOpenOpen(2, 42); assertFalse(iv.isBefore(1)); assertFalse(iv.isBefore(2)); assertFalse(iv.isBefore(3)); assertFalse(iv.isBefore(41)); assertTrue(iv.isBefore(42)); assertTrue(iv.isBefore(43)); iv = Interval.ofClosedClosed(2, 42); assertFalse(iv.isBefore(1)); assertFalse(iv.isBefore(2)); assertFalse(iv.isBefore(3)); assertFalse(iv.isBefore(41)); assertFalse(iv.isBefore(42)); assertTrue(iv.isBefore(43)); }
### Question: Interval { public boolean isAfter(int point) { int value = point * 2; return this.start > value; } private Interval(int start, boolean startInclusive, int end, boolean endInclusive); static Interval ofOpenOpen(int start, int end); static Interval ofOpenClosed(int start, int end); static Interval ofClosedOpen(int start, int end); static Interval ofClosedClosed(int start, int end); boolean isStartClosed(); boolean isEndClosed(); boolean isEmpty(); boolean isBefore(int point); boolean contains(int point); boolean isAfter(int point); Interval intersect(Interval other); Interval union(Interval other); Interval prefix(Interval other); Interval suffix(Interval other); Interval translate(int amount); Interval translateNegative(int amount); int size(); int start(); int end(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testIsAfter() { Interval iv = Interval.ofOpenOpen(2, 42); assertTrue(iv.isAfter(1)); assertTrue(iv.isAfter(2)); assertFalse(iv.isAfter(3)); assertFalse(iv.isAfter(41)); assertFalse(iv.isAfter(42)); assertFalse(iv.isAfter(43)); iv = Interval.ofClosedClosed(2, 42); assertTrue(iv.isAfter(1)); assertFalse(iv.isAfter(2)); assertFalse(iv.isAfter(3)); assertFalse(iv.isAfter(41)); assertFalse(iv.isAfter(42)); assertFalse(iv.isAfter(43)); }
### Question: Interval { public Interval translate(int amount) { int start = this.start() + amount; int end = this.end() + amount; return new Interval(start, this.isStartClosed(), end, this.isEndClosed()); } private Interval(int start, boolean startInclusive, int end, boolean endInclusive); static Interval ofOpenOpen(int start, int end); static Interval ofOpenClosed(int start, int end); static Interval ofClosedOpen(int start, int end); static Interval ofClosedClosed(int start, int end); boolean isStartClosed(); boolean isEndClosed(); boolean isEmpty(); boolean isBefore(int point); boolean contains(int point); boolean isAfter(int point); Interval intersect(Interval other); Interval union(Interval other); Interval prefix(Interval other); Interval suffix(Interval other); Interval translate(int amount); Interval translateNegative(int amount); int size(); int start(); int end(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void testTranslate() { Interval iv = Interval.ofOpenOpen(2, 42); assertEquals(Interval.ofOpenOpen(5, 45), iv.translate(3)); assertEquals(Interval.ofOpenOpen(1, 41), iv.translateNegative(1)); }
### Question: RoundRobin implements Iterable<T> { RoundRobin(List<T> list) { this.list = list; this.size = list.size(); } RoundRobin(List<T> list); @Override Iterator<T> iterator(); static RoundRobin<T> of(List<T> list); }### Answer: @Test @DisplayName("Test Round Robin") void testRoundRobin() { RoundRobin<String> rb = RoundRobin.of(Arrays.asList("foo", "bar", "baz")); Iterator<String> it = rb.iterator(); assertThat(it.hasNext()).isTrue(); assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(it::remove); assertThat(it.next()).isEqualTo("foo"); assertThat(it.next()).isEqualTo("bar"); assertThat(it.next()).isEqualTo("baz"); assertThat(it.next()).isEqualTo("foo"); assertThat(it.hasNext()).isTrue(); }
### Question: PipelineVerticle extends ConfigurableVerticle<PipelineOptions> implements SignalEmitter, SignalReceiver { @Override public EventBus eventBus() { return eventBus; } @Override ValidationResult validate(JsonObject config); @Override PipelineOptions readConfiguration(JsonObject config); @Override Completable configure(PipelineOptions config); @Override Completable shutdown(); @Override String controlChannel(); @Override Completable onSignal(Signal signal); @Override void emitSignal(Signal signal); @Override ExchangeOptions exchange(); @Override EventBus eventBus(); }### Answer: @Test @DisplayName("Test timer shutdown signal triggers pipeline verticle signal.") void testTimerShutdown(Vertx vertx, VertxTestContext ctx) throws InterruptedException { DeploymentOptions options = getDeploymentOptions("timer-shutdown-test"); vertx.eventBus().<String>consumer("test-shutdown", message -> { assertThat(message.headers().get("action")).isEqualTo("undeploy"); assertThat(message.body()).isEqualTo("timer-shutdown-test"); ctx.completeNow(); }); vertx.deployVerticle(PIPELINE_VERTICLE, options, ctx.succeeding()); ctx.awaitCompletion(15, TimeUnit.SECONDS); } @Test @DisplayName("Test counter shutdown signal triggers pipeline verticle signal.") void testCounterShutdown(Vertx vertx, VertxTestContext ctx) throws InterruptedException { DeploymentOptions options = getDeploymentOptions("counter-shutdown-test"); vertx.eventBus().<String>consumer("test-shutdown", message -> { assertThat(message.headers().get("action")).isEqualTo("undeploy"); assertThat(message.body()).isEqualTo("counter-shutdown-test"); ctx.completeNow(); }); vertx.deployVerticle(PIPELINE_VERTICLE, options, ctx.succeeding()); ctx.awaitCompletion(15, TimeUnit.SECONDS); }
### Question: ExchangeOptions { public ExchangeOptions() { } ExchangeOptions(); ExchangeOptions(ExchangeOptions other); ExchangeOptions(JsonObject json); List<String> getTo(); ExchangeOptions setTo(List<String> to); String getFrom(); ExchangeOptions setFrom(String from); String getControlChannel(); ExchangeOptions setControlChannel(String controlChannel); JsonObject toJson(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); static final List<String> DEFAULT_TO; static final String DEFAULT_FROM; static final String DEFAULT_CONTROL_CHANNEL; }### Answer: @Test @DisplayName("Validate log processor options") void testExchangeOptions() { new ExchangeOptionsConverter(); String badStr = "{\"from\": 10, \"to\": 20, \"controlChannel\": false}"; String optStr = "{\"from\":\"foo\", \"to\":[\"address1\",\"address2\"], \"controlChannel\":\"custom-channel\"}"; ExchangeOptions optNull = new ExchangeOptions() .setFrom(null) .setTo(emptyList()) .setControlChannel(null); ExchangeOptions optObj = new ExchangeOptions() .setFrom("foo") .setTo(asList("address1", "address2")) .setControlChannel("custom-channel"); JsonObject optJson = new JsonObject(optStr); assertThat(new ExchangeOptions(new JsonObject(badStr))).isEqualTo(new ExchangeOptions()); assertThat(optNull.toJson()).isEqualTo(obj().put("to", arr())); assertThat(optObj).isEqualTo(optObj); assertThat(optObj).isNotEqualTo(optNull); assertThat(optObj).isEqualTo(new ExchangeOptions(optJson)); assertThat(optObj).isEqualTo(new ExchangeOptions(optObj)); assertThat(optObj.toString()).isEqualTo(new ExchangeOptions(optJson).toString()); assertThat(optObj.hashCode()).isEqualTo(new ExchangeOptions(optJson).hashCode()); assertThat(optObj).isNotEqualTo(null); assertThat(optObj).isNotEqualTo(new Object()); assertThat(optObj.toJson()).isEqualTo(optJson); }
### Question: VertxVaadinContext implements VaadinContext { @Override public <T> T getAttribute(Class<T> type, Supplier<T> defaultValueSupplier) { T result = context.get(type.getName()); if (result == null && defaultValueSupplier != null) { result = defaultValueSupplier.get(); context.put(type.getName(), result); } return result; } VertxVaadinContext(Vertx vertx); @Override T getAttribute(Class<T> type, Supplier<T> defaultValueSupplier); @Override void setAttribute(T value); @Override void removeAttribute(Class<?> clazz); }### Answer: @Test public void getAttributeWithProvider() { Assert.assertNull(context.getAttribute(String.class)); String value = context.getAttribute(String.class, VertxVaadinContextTest::testAttributeProvider); assertEquals(testAttributeProvider(), value); assertEquals("Value from provider should be persisted", testAttributeProvider(), context.getAttribute(String.class)); } @Test public void getMissingAttributeWithoutProvider() { String value = context.getAttribute(String.class); Assert.assertNull(value); }
### Question: VertxVaadinContext implements VaadinContext { @Override public <T> void setAttribute(T value) { assert value != null; context.put(value.getClass().getName(), value); } VertxVaadinContext(Vertx vertx); @Override T getAttribute(Class<T> type, Supplier<T> defaultValueSupplier); @Override void setAttribute(T value); @Override void removeAttribute(Class<?> clazz); }### Answer: @Test(expected = AssertionError.class) public void setNullAttributeNotAllowed() { context.setAttribute(null); }
### Question: VertxVaadinContext implements VaadinContext { @Override public void removeAttribute(Class<?> clazz) { context.remove(clazz.getName()); } VertxVaadinContext(Vertx vertx); @Override T getAttribute(Class<T> type, Supplier<T> defaultValueSupplier); @Override void setAttribute(T value); @Override void removeAttribute(Class<?> clazz); }### Answer: @Test public void removeAttribute() { TestObj value = new TestObj(); context.setAttribute(value); assertEquals(value, context.getAttribute(TestObj.class)); context.removeAttribute(TestObj.class); assertNull(context.getAttribute(TestObj.class)); }
### Question: Profile { public JSONObject toJSONObject() { JSONObject jo = new JSONObject(); jo.put("executions", this.executions); jo.put("minTime", this.minTime); jo.put("avgTime", this.averageTime); jo.put("maxTime", this.maxTime); return jo; } Profile(); Profile(Profile p); Profile(JSONObject json); void start(); void end(); long getExecutionCount(); long getStartTime(); long getMinExecutionTime(); long getAverageExecutionTime(); long getMaxExecutionTime(); void clearExecutionCount(); void setExecutions(long executions); void setMinTime(long minTime); void setMaxTime(long maxTime); void setAvgTime(long averageTime); void accumulate(P p); JSONObject toJSONObject(); JSONObject updateJSON(JSONObject jo); void accumulateJSON(JSONObject jo); Profile copy(); @Override String toString(); }### Answer: @Test public void toJSONObjectTest() { Profile original = new Profile( new JSONObject("{" + "\"executions\":" + SET_EXECUTION_COUNT + "," + "\"maxTime\":" + SET_MAX_EXECUTION_TIME + "," + "\"minTime\":" + SET_MIN_EXECUTION_TIME + "," + "\"avgTime\":" + SET_AVG_EXECUTION_TIME + "}")); JSONObject jsonObject = original.toJSONObject(); Profile p = new Profile(jsonObject); if (p.getExecutionCount() != SET_EXECUTION_COUNT) { fail("Invalid execution count on complete JSON constructor"); } if (p.getMinExecutionTime() != SET_MIN_EXECUTION_TIME) { fail("Invalid default min execution time on complete JSON constructor"); } if (p.getAverageExecutionTime() != SET_AVG_EXECUTION_TIME) { fail("Invalid default average execution time on complete JSON constructor"); } if (p.getMaxExecutionTime() != SET_MAX_EXECUTION_TIME) { fail("Invalid default max execution time on complete JSON constructor"); } }
### Question: IdNowIdentificationService implements IdentificationService { private List<Identification> getIdentifications(String authToken) throws ExecutionException, RetryException { return getListOfStringsFromList((List) retryer.call(() -> { URI uri = new URI(kycConfigHolder.getIdNowHost() + "/api/v1/" + kycConfigHolder.getIdNowCompanyId() + "/identifications"); HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON_UTF8); headers.set("X-API-LOGIN-TOKEN", authToken); HttpEntity<String> request = new HttpEntity<>("parameters", headers); ResponseEntity<IdNowIdentificationResponse> responseEntity = restTemplate.exchange(uri, HttpMethod.GET, request, IdNowIdentificationResponse.class); List<Identification> idList = new ArrayList<>(); for (IdNowIdentification i : responseEntity.getBody().getIdentifications()) { idList.add(i.getIdNowIdentificationProcess()); } return idList; })); } @Override List<Identification> fetchIdentifications(); }### Answer: @Test public void testGetIdentifications() throws ParseException { List<Identification> identificationList = fetcher.fetchIdentifications(); assertThat(identificationList.size()).isEqualTo(1); Identification identification = identificationList.get(0); assertThat(identification.getId()).isEqualTo("c02f9eea-bdef-4723-8ec3-eb254c2039f7"); assertThat(identification.getIdentificationTime()).isEqualTo((format.parse("2014-06-02T05:03:54Z"))); assertThat(identification.getResult()).isEqualTo("SUCCESS"); }
### Question: CSVService { public List<KeyPairs> fromCSV(InputStream inputStream) throws Exception { Reader reader = new InputStreamReader(inputStream); Iterable<CSVRecord> records = CSVFormat.RFC4180.withFirstRecordAsHeader().parse(reader); Iterable<CSVRecord> iterable = () -> records.iterator(); Stream<CSVRecord> stream = StreamSupport.stream(iterable.spliterator(), false); return stream.map((entry) -> { String ethAddress = entry.get(0); String btcAddress = entry.get(1); LOG.info("Reading: ETH={} BTC={}", ethAddress, btcAddress); return new KeyPairs(btcAddress, ethAddress, true); }).collect(Collectors.toList()); } List<KeyPairs> fromCSV(InputStream inputStream); }### Answer: @Test public void testFromCSV() throws Exception { InputStream inputStream = CSVServiceTest.class.getResourceAsStream("/publickeys-dev.csv"); List<KeyPairs> keyPairsList = csvService.fromCSV(inputStream); assertEquals(100, keyPairsList.size()); } @Test(expected = Exception.class) public void testFromCSV_Error_Reading_Format() throws Exception { Mockito.mock(CSVFormat.class); when(CSVFormat.DEFAULT.parse(any())).thenThrow(new Exception()); InputStream inputStream = CSVServiceTest.class.getResourceAsStream("/publickeys-dev.csv"); csvService.fromCSV(inputStream); }
### Question: TierController { @GetMapping(value = "", produces = MediaType.APPLICATION_JSON_UTF8_VALUE) @ResponseStatus(HttpStatus.OK) @ResponseBody public ResponseEntity<List<SaleTierResponse>> getAllTiers() { List<SaleTierResponse> saleTiers = new ArrayList<>(); saleTierService.getAllSaleTiersOrderByStartDate().forEach( t -> saleTiers.add(fromEntityToResponse(t))); return ResponseEntity.ok(saleTiers); } @GetMapping(value = "", produces = MediaType.APPLICATION_JSON_UTF8_VALUE) @ResponseStatus(HttpStatus.OK) @ResponseBody ResponseEntity<List<SaleTierResponse>> getAllTiers(); @PostMapping(value = "/create", produces = MediaType.APPLICATION_JSON_UTF8_VALUE, consumes = MediaType.APPLICATION_JSON_UTF8_VALUE) ResponseEntity<List<SaleTierResponse>> createTiers( @RequestBody List<SaleTierRequest> tiersRequest); }### Answer: @Test public void getAllTiers() throws Exception { tiers = createFiveTiers(); when(saleTierService.getAllSaleTiersOrderByStartDate()) .thenReturn(tiers); MvcResult result = this.mockMvc.perform(get(TIERS_ENDPOINT) .contentType(APPLICATION_JSON)) .andExpect(status().isOk()) .andDo(print()) .andReturn(); List<SaleTierResponse> responses = tiers.stream() .map(t -> tierController.fromEntityToResponse(t)) .collect(Collectors.toList()); assertThat(result.getResponse().getContentAsString()).isEqualTo( jsonSaleTierResponse.write(responses).getJson()); }
### Question: CountryFilterController { @RequestMapping(value = "/countryfilter/allowed", method = GET, produces = APPLICATION_JSON_UTF8_VALUE) public ResponseEntity<?> isIPAllowed(HttpServletRequest requestContext) throws BaseException { String ipAddress = IPAddressUtil.getIPAddress(requestContext); boolean result = this.countryFilterService.isIPAllowed(ipAddress); LOG.debug("IP Address: {}, isIPAllowed result: {}", ipAddress, result); return new ResponseEntity<>(new CountryFilterResponse(result), HttpStatus.OK); } @RequestMapping(value = "/countryfilter/allowed", method = GET, produces = APPLICATION_JSON_UTF8_VALUE) ResponseEntity<?> isIPAllowed(HttpServletRequest requestContext); }### Answer: @Test public void testCountryFilterAllowed_with_X_Real_IP_Header() throws Exception { when(mockCountryFilterService.isIPAllowed("1.1.1.1")).thenReturn(true); MvcResult mvcResult1 = this.mockMvc.perform(get(COUNTRY_FILTER_ALLOWED_ENDPOINT) .header("X-Real-IP", "1.1.1.1") .contentType(APPLICATION_JSON)) .andExpect(status().isOk()) .andDo(print()) .andReturn(); assertThat(mvcResult1.getResponse().getContentAsString()).isEqualTo( jsonCountryFilterResponse.write(new CountryFilterResponse(true)).getJson() ); when(mockCountryFilterService.isIPAllowed("1.1.1.1")).thenReturn(false); MvcResult mvcResult2 = this.mockMvc.perform(get(COUNTRY_FILTER_ALLOWED_ENDPOINT) .header("X-Real-IP", "1.1.1.1") .contentType(APPLICATION_JSON)) .andExpect(status().isOk()) .andDo(print()) .andReturn(); assertThat(mvcResult2.getResponse().getContentAsString()).isEqualTo( jsonCountryFilterResponse.write(new CountryFilterResponse(false)).getJson() ); }
### Question: KeyPairsRepositoryService { @Transactional(isolation = Isolation.READ_COMMITTED) public Optional<KeyPairs> getFreshKey() { try { return this.keyPairsRepository .findFirstOptionalByAvailableOrderByIdAsc(new Boolean(true)) .map((k) -> k.setAvailable(new Boolean(false))) .map((k) -> this.keyPairsRepository.save(k)); } catch (Exception e) { LOG.error("Error obtaining a fresh key.", e); return Optional.empty(); } } @Autowired KeyPairsRepositoryService(KeyPairsRepository keyPairsRepository); @Transactional(isolation = Isolation.READ_COMMITTED) Optional<KeyPairs> getFreshKey(); boolean addKeyPairsIfNotPresent(KeyPairs keyPairs); Optional<KeyPairs> findByPublicEth(String publicEth); Optional<KeyPairs> findByPublicBtc(String publicBtc); Optional<KeyPairs> findById(long id); }### Answer: @Test public void testGetFreshKey() throws InterruptedException { List<Optional<KeyPairs>> optionalKeyPairsList = Collections.synchronizedList(new ArrayList<Optional<KeyPairs>>()); ThreadTestUtils.runMultiThread( () -> optionalKeyPairsList.add(keyPairsRepositoryService.getFreshKey()), 10 ); assertEquals(10, optionalKeyPairsList.size()); assertEquals(10, optionalKeyPairsList.stream().filter((k) -> k.isPresent()).count()); List<KeyPairs> keyPairsList = optionalKeyPairsList.stream() .map((k) -> k.get()) .collect(Collectors.toList()); assertTrue(allBTCAreUnique(10, keyPairsList)); assertTrue(allETHAreUnique(10, keyPairsList)); assertTrue(allMarkedAsUnavailable(keyPairsList)); }
### Question: InvestorService { public Investor getInvestorByInvestorId(long investorId) throws InvestorNotFoundException { Optional<Investor> investorFromDb = investorRepository.findById(investorId); return investorFromDb.orElseThrow(InvestorNotFoundException::new); } @Autowired InvestorService(InvestorRepository investorRepository); Investor getInvestorByInvestorId(long investorId); Investor getInvestorByEmail(String email); List<Investor> getAllInvestors(); Investor getInvestorByBitcoinAddress(String address); Investor getInvestorByEthereumAddress(String address); @Transactional(propagation = Propagation.REQUIRES_NEW) Investor saveRequireNewTransaction(Investor investor); }### Answer: @Test public void testGetInvestorByInvestorId() { try { Investor investorFromDb = investorService.getInvestorByInvestorId(investor.getId()); assertEquals(investor, investorFromDb); } catch(InvestorNotFoundException e) { fail(e.getMessage()); } }
### Question: InvestorService { public Investor getInvestorByEmail(String email) throws InvestorNotFoundException { Optional<Investor> investorFromDb = investorRepository.findOptionalByEmail(email); return investorFromDb.orElseThrow(InvestorNotFoundException::new); } @Autowired InvestorService(InvestorRepository investorRepository); Investor getInvestorByInvestorId(long investorId); Investor getInvestorByEmail(String email); List<Investor> getAllInvestors(); Investor getInvestorByBitcoinAddress(String address); Investor getInvestorByEthereumAddress(String address); @Transactional(propagation = Propagation.REQUIRES_NEW) Investor saveRequireNewTransaction(Investor investor); }### Answer: @Test public void testGetInvestorByEmail() { try { Investor investorFromDb = investorService.getInvestorByEmail("test@test.com"); assertEquals(investor, investorFromDb); } catch(InvestorNotFoundException e) { fail(e.getMessage()); } }
### Question: BitcoinUnitConverter { public static BigDecimal convert(BigDecimal value, BitcoinUnit unitFrom, BitcoinUnit unitTo) throws BitcoinUnitConversionNotImplementedException { if (unitFrom.equals(BitcoinUnit.SATOSHI) && unitTo.equals(BitcoinUnit.COIN)) { return new BigDecimal(Coin.valueOf(value.longValueExact()).toPlainString()); } if (unitFrom.equals(BitcoinUnit.COIN) && unitTo.equals(BitcoinUnit.SATOSHI)) { return value.multiply(BitcoinUnit.COIN.getSatoshiFactor()); } throw new BitcoinUnitConversionNotImplementedException( String.format("Converting %s to %s is not implemented.", unitFrom, unitTo)); } static BigDecimal convert(BigDecimal value, BitcoinUnit unitFrom, BitcoinUnit unitTo); static BigDecimal convert(BigInteger value, BitcoinUnit unitFrom, BitcoinUnit unitTo); }### Answer: @Test public void testSatoshiToBitcoinConversion() { BigDecimal coin = BigDecimal.ZERO; try { coin = BitcoinUnitConverter.convert( BigDecimal.valueOf(100_000_099), BitcoinUnit.SATOSHI, BitcoinUnit.COIN); } catch (BitcoinUnitConversionNotImplementedException e) { fail(); } assertEquals(0, coin.compareTo(new BigDecimal("1.00000099"))); } @Test public void testBitcoinToSatoshiConversion() { BigDecimal satoshi = BigDecimal.ZERO; try { satoshi = BitcoinUnitConverter.convert( new BigDecimal("1.00000099"), BitcoinUnit.COIN, BitcoinUnit.SATOSHI); } catch (BitcoinUnitConversionNotImplementedException e) { fail(); } assertEquals(0, satoshi.compareTo(new BigDecimal(100_000_099))); }
### Question: BitcoinUtils { public static BigInteger convertUsdToSatoshi(BigDecimal usd, BigDecimal USDperBTC) { try { BigDecimal coins = usd.divide(USDperBTC, MathContext.DECIMAL128); return BitcoinUnitConverter.convert(coins, BitcoinUnit.COIN, BitcoinUnit.SATOSHI) .toBigInteger(); } catch (BitcoinUnitConversionNotImplementedException e) { throw new RuntimeException(e); } } static BigDecimal convertSatoshiToUsd(BigInteger satoshi, BigDecimal USDperBTC); static BigInteger convertUsdToSatoshi(BigDecimal usd, BigDecimal USDperBTC); }### Answer: @Test public void testUsdToSatoshiConversion() { BigDecimal usdPerBtc = new BigDecimal("6010"); BigDecimal usd = new BigDecimal("1"); BigInteger satoshi = BitcoinUtils.convertUsdToSatoshi(usd, usdPerBtc); assertEquals(0, satoshi.compareTo(new BigInteger("16638"))); usd = new BigDecimal(1_000_000_000); satoshi = BitcoinUtils.convertUsdToSatoshi(usd, usdPerBtc); assertEquals(0, satoshi.compareTo(new BigInteger("16638935108153"))); usd = new BigDecimal("0.0001"); satoshi = BitcoinUtils.convertUsdToSatoshi(usd, usdPerBtc); assertEquals(0, satoshi.compareTo(BigInteger.ONE)); usd = new BigDecimal("0.00001"); satoshi = BitcoinUtils.convertUsdToSatoshi(usd, usdPerBtc); assertEquals(0, satoshi.compareTo(BigInteger.ZERO)); }
### Question: BitcoinUtils { public static BigDecimal convertSatoshiToUsd(BigInteger satoshi, BigDecimal USDperBTC) { try { return BitcoinUnitConverter.convert(satoshi, BitcoinUnit.SATOSHI, BitcoinUnit.COIN) .multiply(USDperBTC); } catch (BitcoinUnitConversionNotImplementedException e) { throw new RuntimeException(e); } } static BigDecimal convertSatoshiToUsd(BigInteger satoshi, BigDecimal USDperBTC); static BigInteger convertUsdToSatoshi(BigDecimal usd, BigDecimal USDperBTC); }### Answer: @Test public void testSatoshiToUsdConversion() { BigDecimal usdPerBtc = new BigDecimal("6010"); BigInteger satoshi = BigInteger.valueOf(522_222_222L); BigDecimal usd = BitcoinUtils.convertSatoshiToUsd(satoshi, usdPerBtc); assertEquals(0, usd.compareTo(new BigDecimal("31385.5555422"))); }
### Question: CountryFilterService { public boolean isIPAllowed(String ipAddress) { return countryFilterConfigHolder.isEnabled() ? this.ip2Asn2Cc.checkIP(ipAddress) : true; } boolean isIPAllowed(String ipAddress); }### Answer: @Test public void testIsIPAllowed_Correct_IP() { when(ip2Asn2Cc.checkIP(eq("1.2.3.4"))).thenReturn(true); boolean result = countryFilterService.isIPAllowed("1.2.3.4"); assertTrue(result); } @Test public void testIsIPAllowed_Wrong_IP() { when(ip2Asn2Cc.checkIP(eq("1.2.3.4"))).thenReturn(false); boolean result = countryFilterService.isIPAllowed("1.2.3.4"); assertFalse(result); } @Test public void testCountryFilter_Not_Enabled() { doReturn(false).when(countryFilterConfigHolder).isEnabled(); boolean result = countryFilterService.isIPAllowed("1.2.3.4"); assertTrue(result); }
### Question: KycInfoService { @Transactional public KycInfo setKycStartEmailSent(long investorId) throws InvestorNotFoundException { Optional<KycInfo> kycInfoFromDb = kycInfoRepository.findOptionalByInvestorId(investorId); if(kycInfoFromDb.isPresent()) { KycInfo kycInfo = kycInfoFromDb.get().setStartKycEmailSent(true); kycInfoFromDb = Optional.of(kycInfoRepository.save(kycInfo)); } return kycInfoFromDb.orElseThrow(InvestorNotFoundException::new); } @Autowired KycInfoService(KycInfoRepository kycInfoRepository); @Transactional KycInfo saveKycInfo(long investorId, URI kycUri); @Transactional KycInfo setKycComplete(long investorId, boolean isKycComplete); @Transactional KycInfo setKycCompleteByUuid(UUID uuid, boolean isKycComplete); @Transactional KycInfo setKycUri(long investorId, String kycUri); @Transactional KycInfo setKycStartEmailSent(long investorId); @Transactional KycInfo increaseNumberOfRemindersSent(long investorId); KycInfo getKycInfoByInvestorId(long investorId); KycInfo getKycInfoByKycUuid(UUID kycUuid); List<Long> getAllInvestorIdWhereStartKycEmailSent(); }### Answer: @Test public void testSetKycStartEmailSent() throws KycInfoNotSavedException { kycInfoService.saveKycInfo(1, kycUri); try { kycInfoService.setKycStartEmailSent(1); } catch(InvestorNotFoundException e) { fail(e.getMessage()); } Optional<KycInfo> oKycInfo = kycInfoRepository.findOptionalByInvestorId(1); assertKycInfo(oKycInfo.get(), 1, true, 0, false, kycUri); }
### Question: CryptoCompareClientService { public CryptoCompareResponseDTO getHistorical(CryptoCompareCurrency fromCurrency, List<CryptoCompareCurrency> toCurrency, long timeInSecond) throws Exception { CryptoCompareResponseDTO cryptoCompareResponseDTO = restTemplate.getForObject( getPriceHistoricalURI(fromCurrency, toCurrency, timeInSecond), CryptoCompareResponseDTO.class ); return cryptoCompareResponseDTO; } @Autowired CryptoCompareClientService(@Qualifier("restTemplateCryptoCompare") RestTemplate restTemplate, CryptoCompareConfigHolder cryptoCompareConfigHolder); CryptoCompareResponseDTO getHistorical(CryptoCompareCurrency fromCurrency, List<CryptoCompareCurrency> toCurrency, long timeInSecond); }### Answer: @Test public void testGetHistorical() throws Exception { CryptoCompareConversionRateResponse rateResponseUSD = new CryptoCompareConversionRateResponse(CryptoCompareCurrency.USD, new BigDecimal(401.25)); CryptoCompareConversionRateResponse rateResponseBTC = new CryptoCompareConversionRateResponse(CryptoCompareCurrency.BTC, new BigDecimal(0.0056)); CryptoCompareConversionRates conversionRates = new CryptoCompareConversionRates(Arrays.asList(rateResponseUSD, rateResponseBTC)); List<CryptoCompareResponse> compareResponses = Arrays.asList(new CryptoCompareResponse(CryptoCompareCurrency.ETH, conversionRates)); CryptoCompareResponseDTO responseDTO = new CryptoCompareResponseDTO(compareResponses); when(restTemplate.getForObject(any(), eq(CryptoCompareResponseDTO.class))).thenReturn(responseDTO); CryptoCompareResponseDTO actualResponseDTO = cryptoCompareClientService.getHistorical( CryptoCompareCurrency.ETH, Arrays.asList(CryptoCompareCurrency.USD, CryptoCompareCurrency.BTC), Instant.now().getEpochSecond() ); assertEquals(actualResponseDTO, responseDTO); }
### Question: CryptoCompareClientService { protected URI getPriceHistoricalURI(CryptoCompareCurrency fromCurrency, List<CryptoCompareCurrency> toCurrency, long timeInSeconds) { return UriComponentsBuilder.fromUriString(cryptoCompareConfigHolder.getBaseUrl()) .path("/data") .path("/pricehistorical") .queryParam("fsym", fromCurrency) .queryParam("tsyms", StringUtils.join(toCurrency, ',')) .queryParam("ts", timeInSeconds) .queryParam("extraParams", "ICOnator_client") .build() .toUri(); } @Autowired CryptoCompareClientService(@Qualifier("restTemplateCryptoCompare") RestTemplate restTemplate, CryptoCompareConfigHolder cryptoCompareConfigHolder); CryptoCompareResponseDTO getHistorical(CryptoCompareCurrency fromCurrency, List<CryptoCompareCurrency> toCurrency, long timeInSecond); }### Answer: @Test public void testGetPriceHistoricalURI() { URI actualUri = cryptoCompareClientService.getPriceHistoricalURI( CryptoCompareCurrency.ETH, Arrays.asList(CryptoCompareCurrency.CHF, CryptoCompareCurrency.USD), 123456789 ); URI expectedUri = URI.create( String.format( "%s/data/pricehistorical?fsym=%s&tsyms=%s&ts=%s&extraParams=%s", cryptoCompareConfigHolder.getBaseUrl(), "ETH", "CHF,USD", "123456789", "ICOnator_client" ) ); assertEquals(expectedUri, actualUri); }
### Question: KycInfoService { public KycInfo getKycInfoByInvestorId(long investorId) throws InvestorNotFoundException { Optional<KycInfo> kycInfoFromDb = kycInfoRepository.findOptionalByInvestorId(investorId); return kycInfoFromDb.orElseThrow(InvestorNotFoundException::new); } @Autowired KycInfoService(KycInfoRepository kycInfoRepository); @Transactional KycInfo saveKycInfo(long investorId, URI kycUri); @Transactional KycInfo setKycComplete(long investorId, boolean isKycComplete); @Transactional KycInfo setKycCompleteByUuid(UUID uuid, boolean isKycComplete); @Transactional KycInfo setKycUri(long investorId, String kycUri); @Transactional KycInfo setKycStartEmailSent(long investorId); @Transactional KycInfo increaseNumberOfRemindersSent(long investorId); KycInfo getKycInfoByInvestorId(long investorId); KycInfo getKycInfoByKycUuid(UUID kycUuid); List<Long> getAllInvestorIdWhereStartKycEmailSent(); }### Answer: @Test public void testGetKycInfoByInvestorId() throws KycInfoNotSavedException { kycInfoService.saveKycInfo(2000, kycUri); try { KycInfo kycInfo = kycInfoService.getKycInfoByInvestorId(2000); assertKycInfo(kycInfo, 2000, false, 0, false, kycUri); } catch (InvestorNotFoundException e) { fail(e.getMessage()); } try { kycInfoService.getKycInfoByInvestorId(1); fail("InvestorNotFoundException should have been thrown but wasn't."); } catch(InvestorNotFoundException expectedException) { } }
### Question: KycInfoService { public KycInfo getKycInfoByKycUuid(UUID kycUuid) throws InvestorNotFoundException { Optional<KycInfo> kycInfoFromDb = kycInfoRepository.findOptionalByKycUuid(kycUuid); return kycInfoFromDb.orElseThrow(InvestorNotFoundException::new); } @Autowired KycInfoService(KycInfoRepository kycInfoRepository); @Transactional KycInfo saveKycInfo(long investorId, URI kycUri); @Transactional KycInfo setKycComplete(long investorId, boolean isKycComplete); @Transactional KycInfo setKycCompleteByUuid(UUID uuid, boolean isKycComplete); @Transactional KycInfo setKycUri(long investorId, String kycUri); @Transactional KycInfo setKycStartEmailSent(long investorId); @Transactional KycInfo increaseNumberOfRemindersSent(long investorId); KycInfo getKycInfoByInvestorId(long investorId); KycInfo getKycInfoByKycUuid(UUID kycUuid); List<Long> getAllInvestorIdWhereStartKycEmailSent(); }### Answer: @Test public void testGetKycInfoByKycUuid() throws KycInfoNotSavedException { kycInfoService.saveKycInfo(1, kycUri); UUID uuid = kycInfoRepository.findOptionalByInvestorId(1).get().getKycUuid(); try { KycInfo kycInfo = kycInfoService.getKycInfoByKycUuid(uuid); assertKycInfo(kycInfo, 1, false, 0, false, kycUri); } catch(InvestorNotFoundException e) { fail(e.getMessage()); } }
### Question: KycInfoService { @Transactional public KycInfo setKycUri(long investorId, String kycUri) throws InvestorNotFoundException { Optional<KycInfo> kycInfoFromDb = kycInfoRepository.findOptionalByInvestorId(investorId); if(kycInfoFromDb.isPresent()) { KycInfo kycInfo = kycInfoFromDb.get().setKycUri(kycUri); kycInfoFromDb = Optional.of(kycInfoRepository.save(kycInfo)); } return kycInfoFromDb.orElseThrow(InvestorNotFoundException::new); } @Autowired KycInfoService(KycInfoRepository kycInfoRepository); @Transactional KycInfo saveKycInfo(long investorId, URI kycUri); @Transactional KycInfo setKycComplete(long investorId, boolean isKycComplete); @Transactional KycInfo setKycCompleteByUuid(UUID uuid, boolean isKycComplete); @Transactional KycInfo setKycUri(long investorId, String kycUri); @Transactional KycInfo setKycStartEmailSent(long investorId); @Transactional KycInfo increaseNumberOfRemindersSent(long investorId); KycInfo getKycInfoByInvestorId(long investorId); KycInfo getKycInfoByKycUuid(UUID kycUuid); List<Long> getAllInvestorIdWhereStartKycEmailSent(); }### Answer: @Test public void testSetKycUri() throws KycInfoNotSavedException, URISyntaxException { URI newKycUri = new URI("http: kycInfoService.saveKycInfo(1, kycUri); try { kycInfoService.setKycUri(1, newKycUri.toASCIIString()); } catch(InvestorNotFoundException e) { fail(e.getMessage()); } Optional<KycInfo> oKycInfo = kycInfoRepository.findOptionalByInvestorId(1); assertKycInfo(oKycInfo.get(), 1, false, 0, false, newKycUri); }
### Question: IdNowKycLinkCreatorService implements KycLinkCreatorService { @Override public String getKycLink(long investorId) throws InvestorNotFoundException { KycInfo kycInfo = kycInfoService.getKycInfoByInvestorId(investorId); return kycConfigHolder.getIdNowHost() + "/" + kycConfigHolder.getIdNowCompanyId() + "/userdata/" + kycInfo.getKycUuid(); } @Override String getKycLink(long investorId); }### Answer: @Test public void testGetKycLink() throws InvestorNotFoundException { String kycLink = linkCreatorService.getKycLink(1); assertEquals(targetKycLink, kycLink); } @Test(expected = InvestorNotFoundException.class) public void testGetKycLink_nonExistentInvestor() throws InvestorNotFoundException { linkCreatorService.getKycLink(2); }
### Question: SortImpl { public SortMetrics getMetrics() { return metrics; } SortImpl(OperExecContext opContext, SortConfig sortConfig, SpilledRuns spilledRuns, VectorContainer batch); void setSchema(BatchSchema schema); boolean forceSpill(); void addBatch(VectorAccessible incoming); SortMetrics getMetrics(); SortResults startMerge(); void close(); }### Answer: @Test public void testSpill() throws Exception { OperatorFixtureBuilder builder = OperatorFixture.builder(); builder.configBuilder() .put(ExecConstants.EXTERNAL_SORT_BATCH_LIMIT, 2); try (OperatorFixture fixture = builder.build()) { BatchSchema schema = SortTestUtilities.nonNullSchema(); SortTestFixture sortTest = new SortTestFixture(fixture) { @Override protected void validateSort(SortImpl sort) { assertEquals(1, sort.getMetrics().getSpillCount()); assertEquals(0, sort.getMetrics().getMergeCount()); assertEquals(2, sort.getMetrics().getPeakBatchCount()); } @Override protected void validateFinalStats(SortImpl sort) { assertTrue(sort.getMetrics().getWriteBytes() > 0); } }; sortTest.addInput(fixture.rowSetBuilder(schema) .add(2, "second") .build()); sortTest.addInput(fixture.rowSetBuilder(schema) .add(3, "third") .build()); sortTest.addInput(fixture.rowSetBuilder(schema) .add(1, "first") .build()); sortTest.addOutput(fixture.rowSetBuilder(schema) .add(1, "first") .add(2, "second") .add(3, "third") .build()); sortTest.run(); } }
### Question: Accountant implements AutoCloseable { public long getAllocatedMemory() { return locallyHeldMemory.get(); } Accountant(Accountant parent, long reservation, long maxAllocation); void releaseBytes(long size); void setLimit(long newLimit); boolean isOverLimit(); void close(); long getLimit(); long getAllocatedMemory(); long getPeakMemoryAllocation(); }### Answer: @Test public void nested() { final Accountant parent = new Accountant(null, 0, Long.MAX_VALUE); ensureAccurateReservations(parent); assertEquals(0, parent.getAllocatedMemory()); } @Test public void multiThread() throws InterruptedException { final Accountant parent = new Accountant(null, 0, Long.MAX_VALUE); final int numberOfThreads = 32; final int loops = 100; Thread[] threads = new Thread[numberOfThreads]; for (int i = 0; i < numberOfThreads; i++) { Thread t = new Thread() { @Override public void run() { try { for (int i = 0; i < loops; i++) { ensureAccurateReservations(parent); } } catch (Exception ex) { ex.printStackTrace(); Assert.fail(ex.getMessage()); } } }; threads[i] = t; t.start(); } for (Thread thread : threads) { thread.join(); } assertEquals(0, parent.getAllocatedMemory()); }
### Question: MetadataProvider { public static Runnable catalogs(final UserSession session, final DrillbitContext dContext, final GetCatalogsReq req, final ResponseSender responseSender) { return new CatalogsProvider(session, dContext, req, responseSender); } static Runnable catalogs(final UserSession session, final DrillbitContext dContext, final GetCatalogsReq req, final ResponseSender responseSender); static Runnable schemas(final UserSession session, final DrillbitContext dContext, final GetSchemasReq req, final ResponseSender responseSender); static Runnable tables(final UserSession session, final DrillbitContext dContext, final GetTablesReq req, final ResponseSender responseSender); static Runnable columns(final UserSession session, final DrillbitContext dContext, final GetColumnsReq req, final ResponseSender responseSender); }### Answer: @Test public void catalogs() throws Exception { GetCatalogsResp resp = client.getCatalogs(null).get(); assertEquals(RequestStatus.OK, resp.getStatus()); List<CatalogMetadata> catalogs = resp.getCatalogsList(); assertEquals(1, catalogs.size()); CatalogMetadata c = catalogs.get(0); assertEquals(IS_CATALOG_NAME, c.getCatalogName()); assertEquals(IS_CATALOG_DESCR, c.getDescription()); assertEquals(IS_CATALOG_CONNECT, c.getConnect()); } @Test public void catalogs() throws Exception { GetCatalogsResp resp = client.getCatalogs(null).get(); assertEquals(RequestStatus.OK, resp.getStatus()); List<CatalogMetadata> catalogs = resp.getCatalogsList(); assertEquals(1, catalogs.size()); CatalogMetadata c = catalogs.get(0); assertEquals(IS_CATALOG_NAME, c.getCatalogName()); assertEquals(IS_CATALOG_DESCRIPTION, c.getDescription()); assertEquals(IS_CATALOG_CONNECT, c.getConnect()); }
### Question: MetadataProvider { public static Runnable schemas(final UserSession session, final DrillbitContext dContext, final GetSchemasReq req, final ResponseSender responseSender) { return new SchemasProvider(session, dContext, req, responseSender); } static Runnable catalogs(final UserSession session, final DrillbitContext dContext, final GetCatalogsReq req, final ResponseSender responseSender); static Runnable schemas(final UserSession session, final DrillbitContext dContext, final GetSchemasReq req, final ResponseSender responseSender); static Runnable tables(final UserSession session, final DrillbitContext dContext, final GetTablesReq req, final ResponseSender responseSender); static Runnable columns(final UserSession session, final DrillbitContext dContext, final GetColumnsReq req, final ResponseSender responseSender); }### Answer: @Test public void schemas() throws Exception { GetSchemasResp resp = client.getSchemas(null, null).get(); assertEquals(RequestStatus.OK, resp.getStatus()); List<SchemaMetadata> schemas = resp.getSchemasList(); assertEquals(9, schemas.size()); verifySchema("INFORMATION_SCHEMA", schemas); verifySchema("cp.default", schemas); verifySchema("dfs.default", schemas); verifySchema("dfs.root", schemas); verifySchema("dfs.tmp", schemas); verifySchema("dfs_test.default", schemas); verifySchema("dfs_test.home", schemas); verifySchema("dfs_test.tmp", schemas); verifySchema("sys", schemas); } @Test public void schemas() throws Exception { GetSchemasResp resp = client.getSchemas(null, null).get(); assertEquals(RequestStatus.OK, resp.getStatus()); List<SchemaMetadata> schemas = resp.getSchemasList(); assertEquals(6, schemas.size()); verifySchema("information_schema", schemas); verifySchema("cp.default", schemas); verifySchema("dfs.default", schemas); verifySchema("dfs.root", schemas); verifySchema("dfs.tmp", schemas); verifySchema("sys", schemas); }
### Question: MetadataProvider { public static Runnable columns(final UserSession session, final DrillbitContext dContext, final GetColumnsReq req, final ResponseSender responseSender) { return new ColumnsProvider(session, dContext, req, responseSender); } static Runnable catalogs(final UserSession session, final DrillbitContext dContext, final GetCatalogsReq req, final ResponseSender responseSender); static Runnable schemas(final UserSession session, final DrillbitContext dContext, final GetSchemasReq req, final ResponseSender responseSender); static Runnable tables(final UserSession session, final DrillbitContext dContext, final GetTablesReq req, final ResponseSender responseSender); static Runnable columns(final UserSession session, final DrillbitContext dContext, final GetColumnsReq req, final ResponseSender responseSender); }### Answer: @Test public void columns() throws Exception { GetColumnsResp resp = client.getColumns(null, null, null, null).get(); assertEquals(RequestStatus.OK, resp.getStatus()); List<ColumnMetadata> columns = resp.getColumnsList(); assertEquals(76, columns.size()); } @Test public void columns() throws Exception { GetColumnsResp resp = client.getColumns(null, null, null, null).get(); assertEquals(RequestStatus.OK, resp.getStatus()); List<ColumnMetadata> columns = resp.getColumnsList(); assertEquals(162, columns.size()); }
### Question: FunctionRegistryHolder { public void removeJar(String jarName) { try (AutoCloseableLock lock = writeLock.open()) { removeAllByJar(jarName); } } FunctionRegistryHolder(); long getVersion(); void addJars(Map<String, List<FunctionHolder>> newJars, long version); void removeJar(String jarName); List<String> getAllJarNames(); List<String> getFunctionNamesByJar(String jarName); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(AtomicLong version); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(); ListMultimap<String, String> getAllFunctionsWithSignatures(); List<DrillFuncHolder> getHoldersByFunctionName(String functionName, AtomicLong version); List<DrillFuncHolder> getHoldersByFunctionName(String functionName); boolean containsJar(String jarName); int functionsSize(); String getJarNameByFunctionSignature(String functionName, String functionSignature); }### Answer: @Test public void testRemoveJar() { registryHolder.removeJar(built_in); assertFalse("Jar should be absent", registryHolder.containsJar(built_in)); assertTrue("Jar should be present", registryHolder.containsJar(udf_jar)); assertEquals("Functions size should match", newJars.get(udf_jar).size(), registryHolder.functionsSize()); }
### Question: FunctionRegistryHolder { public List<String> getAllJarNames() { try (AutoCloseableLock lock = readLock.open()) { return Lists.newArrayList(jars.keySet()); } } FunctionRegistryHolder(); long getVersion(); void addJars(Map<String, List<FunctionHolder>> newJars, long version); void removeJar(String jarName); List<String> getAllJarNames(); List<String> getFunctionNamesByJar(String jarName); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(AtomicLong version); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(); ListMultimap<String, String> getAllFunctionsWithSignatures(); List<DrillFuncHolder> getHoldersByFunctionName(String functionName, AtomicLong version); List<DrillFuncHolder> getHoldersByFunctionName(String functionName); boolean containsJar(String jarName); int functionsSize(); String getJarNameByFunctionSignature(String functionName, String functionSignature); }### Answer: @Test public void testGetAllJarNames() { ArrayList<String> expectedResult = Lists.newArrayList(newJars.keySet()); compareTwoLists(expectedResult, registryHolder.getAllJarNames()); }
### Question: FunctionRegistryHolder { public List<String> getFunctionNamesByJar(String jarName) { try (AutoCloseableLock lock = readLock.open()){ Map<String, Queue<String>> functions = jars.get(jarName); return functions == null ? Lists.<String>newArrayList() : Lists.newArrayList(functions.keySet()); } } FunctionRegistryHolder(); long getVersion(); void addJars(Map<String, List<FunctionHolder>> newJars, long version); void removeJar(String jarName); List<String> getAllJarNames(); List<String> getFunctionNamesByJar(String jarName); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(AtomicLong version); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(); ListMultimap<String, String> getAllFunctionsWithSignatures(); List<DrillFuncHolder> getHoldersByFunctionName(String functionName, AtomicLong version); List<DrillFuncHolder> getHoldersByFunctionName(String functionName); boolean containsJar(String jarName); int functionsSize(); String getJarNameByFunctionSignature(String functionName, String functionSignature); }### Answer: @Test public void testGetFunctionNamesByJar() { ArrayList<String> expectedResult = Lists.newArrayList(); for (FunctionHolder functionHolder : newJars.get(built_in)) { expectedResult.add(functionHolder.getName()); } compareTwoLists(expectedResult, registryHolder.getFunctionNamesByJar(built_in)); }
### Question: FunctionRegistryHolder { public ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(AtomicLong version) { try (AutoCloseableLock lock = readLock.open()) { if (version != null) { version.set(this.version); } ListMultimap<String, DrillFuncHolder> functionsWithHolders = ArrayListMultimap.create(); for (Map.Entry<String, Map<String, DrillFuncHolder>> function : functions.entrySet()) { functionsWithHolders.putAll(function.getKey(), Lists.newArrayList(function.getValue().values())); } return functionsWithHolders; } } FunctionRegistryHolder(); long getVersion(); void addJars(Map<String, List<FunctionHolder>> newJars, long version); void removeJar(String jarName); List<String> getAllJarNames(); List<String> getFunctionNamesByJar(String jarName); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(AtomicLong version); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(); ListMultimap<String, String> getAllFunctionsWithSignatures(); List<DrillFuncHolder> getHoldersByFunctionName(String functionName, AtomicLong version); List<DrillFuncHolder> getHoldersByFunctionName(String functionName); boolean containsJar(String jarName); int functionsSize(); String getJarNameByFunctionSignature(String functionName, String functionSignature); }### Answer: @Test public void testGetAllFunctionsWithHolders() { ListMultimap<String, DrillFuncHolder> expectedResult = ArrayListMultimap.create(); for (List<FunctionHolder> functionHolders : newJars.values()) { for(FunctionHolder functionHolder : functionHolders) { expectedResult.put(functionHolder.getName(), functionHolder.getHolder()); } } compareListMultimaps(expectedResult, registryHolder.getAllFunctionsWithHolders()); }
### Question: FunctionRegistryHolder { public ListMultimap<String, String> getAllFunctionsWithSignatures() { try (AutoCloseableLock lock = readLock.open()) { ListMultimap<String, String> functionsWithSignatures = ArrayListMultimap.create(); for (Map.Entry<String, Map<String, DrillFuncHolder>> function : functions.entrySet()) { functionsWithSignatures.putAll(function.getKey(), Lists.newArrayList(function.getValue().keySet())); } return functionsWithSignatures; } } FunctionRegistryHolder(); long getVersion(); void addJars(Map<String, List<FunctionHolder>> newJars, long version); void removeJar(String jarName); List<String> getAllJarNames(); List<String> getFunctionNamesByJar(String jarName); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(AtomicLong version); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(); ListMultimap<String, String> getAllFunctionsWithSignatures(); List<DrillFuncHolder> getHoldersByFunctionName(String functionName, AtomicLong version); List<DrillFuncHolder> getHoldersByFunctionName(String functionName); boolean containsJar(String jarName); int functionsSize(); String getJarNameByFunctionSignature(String functionName, String functionSignature); }### Answer: @Test public void testGetAllFunctionsWithSignatures() { ListMultimap<String, String> expectedResult = ArrayListMultimap.create(); for (List<FunctionHolder> functionHolders : newJars.values()) { for(FunctionHolder functionHolder : functionHolders) { expectedResult.put(functionHolder.getName(), functionHolder.getSignature()); } } compareListMultimaps(expectedResult, registryHolder.getAllFunctionsWithSignatures()); }
### Question: FunctionRegistryHolder { public List<DrillFuncHolder> getHoldersByFunctionName(String functionName, AtomicLong version) { try (AutoCloseableLock lock = readLock.open()) { if (version != null) { version.set(this.version); } Map<String, DrillFuncHolder> holders = functions.get(functionName); return holders == null ? Lists.<DrillFuncHolder>newArrayList() : Lists.newArrayList(holders.values()); } } FunctionRegistryHolder(); long getVersion(); void addJars(Map<String, List<FunctionHolder>> newJars, long version); void removeJar(String jarName); List<String> getAllJarNames(); List<String> getFunctionNamesByJar(String jarName); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(AtomicLong version); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(); ListMultimap<String, String> getAllFunctionsWithSignatures(); List<DrillFuncHolder> getHoldersByFunctionName(String functionName, AtomicLong version); List<DrillFuncHolder> getHoldersByFunctionName(String functionName); boolean containsJar(String jarName); int functionsSize(); String getJarNameByFunctionSignature(String functionName, String functionSignature); }### Answer: @Test public void testGetHoldersByFunctionName() { List<DrillFuncHolder> expectedResult = Lists.newArrayList(); for (List<FunctionHolder> functionHolders : newJars.values()) { for (FunctionHolder functionHolder : functionHolders) { if ("lower".equals(functionHolder.getName())) { expectedResult.add(functionHolder.getHolder()) ; } } } assertFalse(expectedResult.isEmpty()); compareTwoLists(expectedResult, registryHolder.getHoldersByFunctionName("lower")); }
### Question: FunctionRegistryHolder { public boolean containsJar(String jarName) { try (AutoCloseableLock lock = readLock.open()) { return jars.containsKey(jarName); } } FunctionRegistryHolder(); long getVersion(); void addJars(Map<String, List<FunctionHolder>> newJars, long version); void removeJar(String jarName); List<String> getAllJarNames(); List<String> getFunctionNamesByJar(String jarName); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(AtomicLong version); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(); ListMultimap<String, String> getAllFunctionsWithSignatures(); List<DrillFuncHolder> getHoldersByFunctionName(String functionName, AtomicLong version); List<DrillFuncHolder> getHoldersByFunctionName(String functionName); boolean containsJar(String jarName); int functionsSize(); String getJarNameByFunctionSignature(String functionName, String functionSignature); }### Answer: @Test public void testContainsJar() { assertTrue("Jar should be present in registry holder", registryHolder.containsJar(built_in)); assertFalse("Jar should be absent in registry holder", registryHolder.containsJar("unknown.jar")); }
### Question: FunctionRegistryHolder { public int functionsSize() { try (AutoCloseableLock lock = readLock.open()) { return functions.size(); } } FunctionRegistryHolder(); long getVersion(); void addJars(Map<String, List<FunctionHolder>> newJars, long version); void removeJar(String jarName); List<String> getAllJarNames(); List<String> getFunctionNamesByJar(String jarName); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(AtomicLong version); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(); ListMultimap<String, String> getAllFunctionsWithSignatures(); List<DrillFuncHolder> getHoldersByFunctionName(String functionName, AtomicLong version); List<DrillFuncHolder> getHoldersByFunctionName(String functionName); boolean containsJar(String jarName); int functionsSize(); String getJarNameByFunctionSignature(String functionName, String functionSignature); }### Answer: @Test public void testFunctionsSize() { int count = 0; for (List<FunctionHolder> functionHolders : newJars.values()) { count += functionHolders.size(); } assertEquals("Functions size should match", count, registryHolder.functionsSize()); }
### Question: FunctionRegistryHolder { public String getJarNameByFunctionSignature(String functionName, String functionSignature) { try (AutoCloseableLock lock = readLock.open()) { for (Map.Entry<String, Map<String, Queue<String>>> jar : jars.entrySet()) { Queue<String> functionSignatures = jar.getValue().get(functionName); if (functionSignatures != null && functionSignatures.contains(functionSignature)) { return jar.getKey(); } } } return null; } FunctionRegistryHolder(); long getVersion(); void addJars(Map<String, List<FunctionHolder>> newJars, long version); void removeJar(String jarName); List<String> getAllJarNames(); List<String> getFunctionNamesByJar(String jarName); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(AtomicLong version); ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(); ListMultimap<String, String> getAllFunctionsWithSignatures(); List<DrillFuncHolder> getHoldersByFunctionName(String functionName, AtomicLong version); List<DrillFuncHolder> getHoldersByFunctionName(String functionName); boolean containsJar(String jarName); int functionsSize(); String getJarNameByFunctionSignature(String functionName, String functionSignature); }### Answer: @Test public void testJarNameByFunctionSignature() { FunctionHolder functionHolder = newJars.get(built_in).get(0); assertEquals("Jar name should match", built_in, registryHolder.getJarNameByFunctionSignature(functionHolder.getName(), functionHolder.getSignature())); assertNull("Jar name should be null", registryHolder.getJarNameByFunctionSignature("unknown_function", "unknown_function(unknown-input)")); }
### Question: FunctionInitializer { public String getMethod(String methodName) { loadFunctionBody(); return methods.get(methodName); } FunctionInitializer(String className, ClassLoader classLoader); ClassLoader getClassLoader(); String getClassName(); List<String> getImports(); String getMethod(String methodName); }### Answer: @Test public void testConcurrentFunctionBodyLoad() throws Exception { final FunctionInitializer functionInitializer = new FunctionInitializer(CLASS_NAME, classLoader); final AtomicInteger counter = new AtomicInteger(); new MockUp<FunctionInitializer>() { @Mock Java.CompilationUnit convertToCompilationUnit(Invocation inv, Class<?> clazz) { counter.incrementAndGet(); return inv.proceed(); } }; int threadsNumber = 5; ExecutorService executor = Executors.newFixedThreadPool(threadsNumber); try { List<Future<String>> results = executor.invokeAll(Collections.nCopies(threadsNumber, new Callable<String>() { @Override public String call() throws Exception { return functionInitializer.getMethod("eval"); } })); final Set<String> uniqueResults = new HashSet<>(); for (Future<String> result : results) { uniqueResults.add(result.get()); } assertEquals("All threads should have received the same result", 1, uniqueResults.size()); assertEquals("Number of function body loads should match", 1, counter.intValue()); } finally { executor.shutdownNow(); } } @Test public void testGetMethod() { FunctionInitializer functionInitializer = new FunctionInitializer(CLASS_NAME, classLoader); String actualMethod = functionInitializer.getMethod("eval"); assertTrue("Method body should match", actualMethod.contains("CustomLowerFunction_eval:")); }
### Question: BaseAllocator extends Accountant implements BufferAllocator { @Override public BufferAllocator newChildAllocator( final String name, final long initReservation, final long maxAllocation) { assertOpen(); final ChildAllocator childAllocator = new ChildAllocator(this, name, initReservation, maxAllocation); if (DEBUG) { synchronized (DEBUG_LOCK) { childAllocators.put(childAllocator, childAllocator); historicalLog.recordEvent("allocator[%s] created new child allocator[%s]", name, childAllocator.name); } } return childAllocator; } protected BaseAllocator( final BaseAllocator parentAllocator, final String name, final long initReservation, final long maxAllocation); @Override void assertOpen(); @Override String getName(); @Override DrillBuf getEmpty(); @Override DrillBuf buffer(final int initialRequestSize); @Override DrillBuf buffer(final int initialRequestSize, BufferManager manager); @Override ByteBufAllocator getAsByteBufAllocator(); @Override BufferAllocator newChildAllocator( final String name, final long initReservation, final long maxAllocation); @Override AllocationReservation newReservation(); @Override synchronized void close(); @Override String toString(); @Override String toVerboseString(); static int nextPowerOfTwo(int val); static StringBuilder indent(StringBuilder sb, int indent); static boolean isDebug(); byte[] getIOBuffer(); @Override void read(DrillBuf buf, int length, InputStream in); DrillBuf read(int length, InputStream in); @Override void write(DrillBuf buf, OutputStream out); @Override void write(DrillBuf buf, int length, OutputStream out); static final String DEBUG_ALLOCATOR; static final int DEBUG_LOG_LENGTH; static final boolean DEBUG; }### Answer: @Test public void testAllocator_manyAllocations() throws Exception { try(final RootAllocator rootAllocator = new RootAllocator(MAX_ALLOCATION)) { try(final BufferAllocator childAllocator = rootAllocator.newChildAllocator("manyAllocations", 0, MAX_ALLOCATION)) { allocateAndFree(childAllocator); } } }
### Question: DrillOptiq { public static LogicalExpression toDrill(DrillParseContext context, RelNode input, RexNode expr) { return toDrill(context, Lists.newArrayList(input), expr); } static LogicalExpression toDrill(DrillParseContext context, RelNode input, RexNode expr); static LogicalExpression toDrill(DrillParseContext context, List<RelNode> inputs, RexNode expr); static boolean isLiteralNull(RexLiteral literal); static final String UNSUPPORTED_REX_NODE_ERROR; }### Answer: @Test public void testUnsupportedRexNode() { try { RelDataTypeFactory relFactory = new SqlTypeFactoryImpl(DrillRelDataTypeSystem.DRILL_REL_DATATYPE_SYSTEM); RexBuilder rex = new RexBuilder(relFactory); RelDataType anyType = relFactory.createSqlType(SqlTypeName.ANY); List<RexNode> emptyList = new LinkedList<>(); ImmutableList<RexFieldCollation> e = ImmutableList.copyOf(new RexFieldCollation[0]); RexNode window = rex.makeOver(anyType, SqlStdOperatorTable.AVG, emptyList, emptyList, e, null, null, true, false, false); DrillOptiq.toDrill(null, (RelNode) null, window); } catch (UserException e) { if (e.getMessage().contains(DrillOptiq.UNSUPPORTED_REX_NODE_ERROR)) { return; } Assert.fail("Hit exception with unexpected error message"); } Assert.fail("Failed to raise the expected exception"); }
### Question: OAuth2UserAgentUtils { static RequestEntity<?> withUserAgent(RequestEntity<?> request) { HttpHeaders headers = new HttpHeaders(); headers.putAll(request.getHeaders()); headers.add(HttpHeaders.USER_AGENT, DISCORD_BOT_USER_AGENT); return new RequestEntity<>(request.getBody(), headers, request.getMethod(), request.getUrl()); } }### Answer: @Test public void shouldAddHeaders() throws URISyntaxException { RequestEntity<?> requestEntity = new RequestEntity<>("body", new HttpHeaders(), HttpMethod.POST, new URI("https: RequestEntity<?> withUserAgent = OAuth2UserAgentUtils.withUserAgent(requestEntity); assertThat(withUserAgent).isNotNull(); assertThat(withUserAgent.getBody()).isSameAs(requestEntity.getBody()); assertThat(withUserAgent.getHeaders()).containsKey(HttpHeaders.USER_AGENT); assertThat(withUserAgent.getMethod()).isSameAs(requestEntity.getMethod()); assertThat(withUserAgent.getUrl()).isSameAs(requestEntity.getUrl()); }
### Question: OrderProjections { @EventHandler public void onOrderPlaced(OrderPlaced event, @Timestamp Instant timestamp, ReplayStatus replayStatus) { repository.save(new OrderHistoryItem(event.getReference(), event.getCustomerId(), LocalDateTime.ofInstant(timestamp, ZoneOffset.UTC))); if (replayStatus.isReplay()) { try { Thread.sleep(20L); } catch (InterruptedException e) { } } } @EventHandler void onOrderPlaced(OrderPlaced event, @Timestamp Instant timestamp, ReplayStatus replayStatus); @EventHandler void onOrderStatusChanged(OrderStatusChanged event); @ResetHandler void reset(); }### Answer: @Test public void shouldSave() { projections.onOrderPlaced(new OrderPlaced("reference", "customerId"), Instant.now(), ReplayStatus.REGULAR); verify(repository).save(any()); }
### Question: OrderProjections { @EventHandler public void onOrderStatusChanged(OrderStatusChanged event) { repository.updateStatus(event.getReference(), event.getStatus()); } @EventHandler void onOrderPlaced(OrderPlaced event, @Timestamp Instant timestamp, ReplayStatus replayStatus); @EventHandler void onOrderStatusChanged(OrderStatusChanged event); @ResetHandler void reset(); }### Answer: @Test public void shouldUpdateStatus() { projections.onOrderStatusChanged(new OrderStatusChanged("reference", Status.DISPATCHED)); verify(repository).updateStatus("reference", Status.DISPATCHED); }
### Question: ReplayController { @PostMapping("/replay") public String replay() { replayer.replay("nl.fourscouts.blog.replays.projections"); return "Replay started..."; } @PostMapping("/replay") String replay(); @GetMapping("/replay") String progress(); }### Answer: @Test void shouldStartReplay() throws Exception { mvc .perform(post("/replay")) .andExpect(status().isOk()); verify(replayer).replay(any()); }
### Question: BufferedLiveEvent extends SingleLiveEvent<T> { @Override public void setValue(@Nullable T t) { if (hasActiveObservers() && mBuffer.isEmpty()) { super.setValue(t); } else { mBuffer.add(t); } } @Override void postValue(@Nullable final T value); @Override void setValue(@Nullable T t); }### Answer: @Test public void startStopStart() { ble.setValue("a"); assertObserved(); lifecycle.handleLifecycleEvent(ON_START); assertObserved("a"); ble.setValue("b"); assertObserved("b"); ble.setValue("c"); lifecycle.handleLifecycleEvent(ON_STOP); ble.setValue("d"); ble.setValue("e"); assertObserved("c"); lifecycle.handleLifecycleEvent(ON_START); assertObserved("d", "e"); } @Test public void nullValue() { lifecycle.handleLifecycleEvent(ON_START); ble.setValue("a"); ble.setValue(null); ble.setValue("b"); assertObserved("a", null, "b"); } @Test public void observeRemoveObserve() { lifecycle.handleLifecycleEvent(ON_START); ble.setValue("a"); assertObserved("a"); ble.removeObserver(observer); ble.setValue("c"); ble.setValue("d"); assertObserved(); ble.observe(this, observer); assertObserved("c", "d"); }
### Question: MyResource { @GET public void getList(@Suspended final AsyncResponse ar) throws NamingException { ar.setTimeoutHandler(new TimeoutHandler() { @Override public void handleTimeout(AsyncResponse ar) { ar.resume("Operation timed out"); } }); ar.setTimeout(4000, TimeUnit.MILLISECONDS); ar.register(new MyCompletionCallback()); ar.register(new MyConnectionCallback()); ManagedThreadFactory threadFactory = (ManagedThreadFactory) new InitialContext() .lookup("java:comp/DefaultManagedThreadFactory"); Executors.newSingleThreadExecutor(threadFactory).submit(new Runnable() { @Override public void run() { try { Thread.sleep(3000); ar.resume(response[0]); } catch (InterruptedException ex) { } } }); } @GET void getList(@Suspended final AsyncResponse ar); }### Answer: @Test public void testGetList() { String result = target.request().get(String.class); assertEquals("apple", result); }
### Question: MyResource { @POST @Consumes(MyObject.MIME_TYPE) public String postWithCustomMimeType(MyObject mo) { System.out.println("endpoint invoked (getFruit(" + mo.getIndex() + "))"); return response[Integer.valueOf(mo.getIndex()) % 3]; } @POST @Consumes(MyObject.MIME_TYPE) String postWithCustomMimeType(MyObject mo); @POST @Path("index") @Consumes("text/plain") String postSimple(int index); }### Answer: @Test public void testPostWithCustomMimeType() { String fruit = target .request() .post(Entity.entity(new MyObject(1), MyObject.MIME_TYPE), String.class); assertEquals("banana", fruit); }
### Question: MyResource { @POST @Path("index") @Consumes("text/plain") public String postSimple(int index) { return response[index % 3]; } @POST @Consumes(MyObject.MIME_TYPE) String postWithCustomMimeType(MyObject mo); @POST @Path("index") @Consumes("text/plain") String postSimple(int index); }### Answer: @Test public void testPostSimple() { String fruit = target .path("index") .request() .post(Entity.text("1"), String.class); assertEquals("banana", fruit); }
### Question: MyResource { @GET public String get() { System.out.println("GET"); return Database.getAll(); } @GET String get(); @GET @Path("{name}") String get(@PathParam("name") String payload); @POST void post(String payload); @PUT void put(String payload); @DELETE @Path("{name}") void delete(@PathParam("name") String payload); }### Answer: @Test public void test3GetAll() { String r = target.request().get(String.class); assertEquals("[apple, banana]", r); } @Test public void test4GetOne() { String r = target.path("apple").request().get(String.class); assertEquals("apple", r); }
### Question: EmployeeResource { @GET @Produces("application/xml") public Employee[] get() { return em.createNamedQuery("Employee.findAll", Employee.class).getResultList().toArray(new Employee[0]); } @GET @Produces("application/xml") Employee[] get(); }### Answer: @Test public void testGet() { Employee[] list = target .request(MediaType.APPLICATION_XML) .get(Employee[].class); assertNotNull(list); assertEquals(8, list.length); assertFalse(list[0].equals(new Employee("Penny"))); assertFalse(list[1].equals(new Employee("Sheldon"))); assertFalse(list[2].equals(new Employee("Amy"))); assertFalse(list[3].equals(new Employee("Leonard"))); assertFalse(list[4].equals(new Employee("Bernadette"))); assertFalse(list[5].equals(new Employee("Raj"))); assertFalse(list[6].equals(new Employee("Howard"))); assertFalse(list[7].equals(new Employee("Priya"))); }
### Question: AccountSessionBean { public String withdraw(float amount) { this.amount -= amount; return "Withdrawn: " + amount; } String withdraw(float amount); String deposit(float amount); float getAmount(); }### Answer: @Test public void shouldWithdrawGivenAmount() { final float amount = 5.0F; final String actual = sut.withdraw(amount); assertThat(actual, is(equalTo("Withdrawn: " + amount))); }
### Question: AccountSessionBean { public String deposit(float amount) { this.amount += amount; return "Deposited: " + amount; } String withdraw(float amount); String deposit(float amount); float getAmount(); }### Answer: @Test public void shouldDepositGivenAmount() { final float amount = 10.0F; final String actual = sut.deposit(amount); assertThat(actual, is(equalTo("Deposited: " + amount))); }
### Question: CartBean { public List<String> getItems() { return items; } CartBean(); void addItem(String item); void removeItem(String item); void purchase(); List<String> getItems(); @Remove void remove(); }### Answer: @Test public void shouldBeEmpty() throws Exception { final List<String> actual = sut.getItems(); assertThat(actual.isEmpty(), is(true)); }
### Question: EmployeeBean { public List<Employee> getEmployees() { System.out.println("getEmployees"); return em.createNamedQuery("Employee.findAll", Employee.class).getResultList(); } @Transactional void addAndThrowChecked(); @Transactional void addAndThrowRuntime(); List<Employee> getEmployees(); }### Answer: @Test public void should_have_7_employees() { assertEquals(7, bean.getEmployees().size()); }
### Question: MyTransactionalBean { @Transactional public void withTransaction() { id1 = bean1.getId(); id2 = bean2.getId(); } @Transactional void withTransaction(); void withoutTransaction(); }### Answer: @Test public void should_withTransaction_have_only_one_instance_injected() { bean.withTransaction(); assertThat("bean1 and bean2 should the same object", bean.id1, is(bean.id2)); } @Test public void should_withTransaction_called_twice_have_different_instances_injected() { bean.withTransaction(); String firstId1 = bean.id1; bean.withTransaction(); String secondId1 = bean.id1; assertThat("bean1 should change between scenarios", firstId1, is(not(secondId1))); }
### Question: MyTransactionalBean { public void withoutTransaction() { id1 = bean1.getId(); id2 = bean2.getId(); } @Transactional void withTransaction(); void withoutTransaction(); }### Answer: @Test public void should_withoutTransaction_fail() { try { bean.withoutTransaction(); fail("No ContextNotActiveException"); } catch (ContextNotActiveException e) { } }
### Question: MyTransactionalTxTypeBean { @Transactional(Transactional.TxType.REQUIRED) public void required() { System.out.println(getClass().getName() + "Transactional.TxType.REQUIRED"); } @Transactional(Transactional.TxType.REQUIRED) void required(); @Transactional(Transactional.TxType.REQUIRES_NEW) void requiresNew(); @Transactional(Transactional.TxType.MANDATORY) void mandatory(); @Transactional(Transactional.TxType.SUPPORTS) void supports(); @Transactional(Transactional.TxType.NOT_SUPPORTED) void notSupported(); @Transactional(Transactional.TxType.NEVER) void never(); }### Answer: @Test public void should_required_work() { bean.required(); }
### Question: MyTransactionalTxTypeBean { @Transactional(Transactional.TxType.REQUIRES_NEW) public void requiresNew() { System.out.println(getClass().getName() + "Transactional.TxType.REQUIRES_NEW"); } @Transactional(Transactional.TxType.REQUIRED) void required(); @Transactional(Transactional.TxType.REQUIRES_NEW) void requiresNew(); @Transactional(Transactional.TxType.MANDATORY) void mandatory(); @Transactional(Transactional.TxType.SUPPORTS) void supports(); @Transactional(Transactional.TxType.NOT_SUPPORTED) void notSupported(); @Transactional(Transactional.TxType.NEVER) void never(); }### Answer: @Test public void should_requiresNew_work() { bean.requiresNew(); }
### Question: MyTransactionalTxTypeBean { @Transactional(Transactional.TxType.MANDATORY) public void mandatory() { System.out.println(getClass().getName() + "Transactional.TxType.MANDATORY"); } @Transactional(Transactional.TxType.REQUIRED) void required(); @Transactional(Transactional.TxType.REQUIRES_NEW) void requiresNew(); @Transactional(Transactional.TxType.MANDATORY) void mandatory(); @Transactional(Transactional.TxType.SUPPORTS) void supports(); @Transactional(Transactional.TxType.NOT_SUPPORTED) void notSupported(); @Transactional(Transactional.TxType.NEVER) void never(); }### Answer: @Test(expected = TransactionalException.class) public void should_mandatory_throw_exception() { bean.mandatory(); }
### Question: MyTransactionalTxTypeBean { @Transactional(Transactional.TxType.SUPPORTS) public void supports() { System.out.println(getClass().getName() + "Transactional.TxType.SUPPORTS"); } @Transactional(Transactional.TxType.REQUIRED) void required(); @Transactional(Transactional.TxType.REQUIRES_NEW) void requiresNew(); @Transactional(Transactional.TxType.MANDATORY) void mandatory(); @Transactional(Transactional.TxType.SUPPORTS) void supports(); @Transactional(Transactional.TxType.NOT_SUPPORTED) void notSupported(); @Transactional(Transactional.TxType.NEVER) void never(); }### Answer: @Test public void should_supports_work() { bean.supports(); }
### Question: MyTransactionalTxTypeBean { @Transactional(Transactional.TxType.NOT_SUPPORTED) public void notSupported() { System.out.println(getClass().getName() + "Transactional.TxType.NOT_SUPPORTED"); } @Transactional(Transactional.TxType.REQUIRED) void required(); @Transactional(Transactional.TxType.REQUIRES_NEW) void requiresNew(); @Transactional(Transactional.TxType.MANDATORY) void mandatory(); @Transactional(Transactional.TxType.SUPPORTS) void supports(); @Transactional(Transactional.TxType.NOT_SUPPORTED) void notSupported(); @Transactional(Transactional.TxType.NEVER) void never(); }### Answer: @Test public void should_notSupported_work() { bean.notSupported(); }
### Question: MyTransactionalTxTypeBean { @Transactional(Transactional.TxType.NEVER) public void never() { System.out.println(getClass().getName() + "Transactional.TxType.NEVER"); } @Transactional(Transactional.TxType.REQUIRED) void required(); @Transactional(Transactional.TxType.REQUIRES_NEW) void requiresNew(); @Transactional(Transactional.TxType.MANDATORY) void mandatory(); @Transactional(Transactional.TxType.SUPPORTS) void supports(); @Transactional(Transactional.TxType.NOT_SUPPORTED) void notSupported(); @Transactional(Transactional.TxType.NEVER) void never(); }### Answer: @Test public void should_never_work() { bean.never(); }
### Question: EmployeeBean { public List<Employee> get() { return em.createNamedQuery("Employee.findAll", Employee.class).getResultList(); } List<Employee> get(); }### Answer: @Test public void testGet() throws Exception { assertNotNull(bean); List<Employee> list = bean.get(); assertNotNull(list); assertEquals(8, list.size()); assertFalse(list.contains(new Employee("Penny"))); assertFalse(list.contains(new Employee("Sheldon"))); assertFalse(list.contains(new Employee("Amy"))); assertFalse(list.contains(new Employee("Leonard"))); assertFalse(list.contains(new Employee("Bernadette"))); assertFalse(list.contains(new Employee("Raj"))); assertFalse(list.contains(new Employee("Howard"))); assertFalse(list.contains(new Employee("Priya"))); }
### Question: EmployeeBean { public List<Employee> get() { return em.createNamedQuery("Employee.findAll", Employee.class).getResultList(); } void persist(Employee e); List<Employee> get(); }### Answer: @Test public void testGet() throws Exception { assertNotNull(bean); List<Employee> list = bean.get(); assertNotNull(list); assertEquals(8, list.size()); assertFalse(list.contains(new Employee("Penny"))); assertFalse(list.contains(new Employee("Sheldon"))); assertFalse(list.contains(new Employee("Amy"))); assertFalse(list.contains(new Employee("Leonard"))); assertFalse(list.contains(new Employee("Bernadette"))); assertFalse(list.contains(new Employee("Raj"))); assertFalse(list.contains(new Employee("Howard"))); assertFalse(list.contains(new Employee("Priya"))); }
### Question: EmployeeRepository { public List<Employee> all() { return em.createNamedQuery("Employee.findAll", Employee.class).getResultList(); } void persist(Employee e); List<Employee> all(); }### Answer: @Test public void should_return_all_employee_records() throws Exception { final List<Employee> actualEmployees = repository.all(); assertTrue(actualEmployees.size() == 6); List<Employee> expectedEmployees = asList( employee("Leonard", "11-22-33-44"), employee("Sheldon", "22-33-44-55"), employee("Penny", "33-44-55-66"), employee("Raj", "44-55-66-77"), employee("Howard", "55-66-77-88"), employee("Bernadette", "66-77-88-99")); for (Employee employee : expectedEmployees) { assertTrue(actualEmployees.contains(employee)); } }