method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public void setSamplerConfiguration(SamplerConfiguration samplerConfiguration) { scanner.setSamplerConfiguration(samplerConfiguration); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void setSamplerConfigurationTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); SamplerConfiguration config = new SamplerConfiguration("test"); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).setSamplerConfiguration(config); verify(mockScanner).setSamplerConfiguration(config); } |
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public SamplerConfiguration getSamplerConfiguration() { return scanner.getSamplerConfiguration(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void getSamplerConfigurationTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); SamplerConfiguration config = new SamplerConfiguration("test"); when(mockScanner.getSamplerConfiguration()).thenReturn(config); SamplerConfiguration value = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS) .getSamplerConfiguration(); verify(mockScanner).getSamplerConfiguration(); assertThat("correct config returned", value, equalTo(config)); } |
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public void clearSamplerConfiguration() { scanner.clearSamplerConfiguration(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void clearSamplerConfigurationTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).clearSamplerConfiguration(); verify(mockScanner).clearSamplerConfiguration(); } |
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public void setBatchTimeout(long l, TimeUnit timeUnit) { scanner.setBatchTimeout(l, timeUnit); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void setBatchTimeoutTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).setBatchTimeout(5L, TimeUnit.DAYS); verify(mockScanner).setBatchTimeout(5L, TimeUnit.DAYS); } |
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public long getBatchTimeout(TimeUnit timeUnit) { return scanner.getBatchTimeout(timeUnit); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void getBatchTimeoutTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockScanner.getBatchTimeout(TimeUnit.DAYS)).thenReturn(5L); long value = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).getBatchTimeout(TimeUnit.DAYS); verify(mockScanner).getBatchTimeout(TimeUnit.DAYS); assertThat("correct timeout returned", value, is(5L)); } |
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public void setClassLoaderContext(String s) { scanner.setClassLoaderContext(s); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void setClassLoaderContextTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).setClassLoaderContext("test"); verify(mockScanner).setClassLoaderContext("test"); } |
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public void clearClassLoaderContext() { scanner.clearClassLoaderContext(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void clearClassLoaderContextTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).clearClassLoaderContext(); verify(mockScanner).clearClassLoaderContext(); } |
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public String getClassLoaderContext() { return scanner.getClassLoaderContext(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void getClassLoaderContextTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockScanner.getClassLoaderContext()).thenReturn("test"); String value = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).getClassLoaderContext(); verify(mockScanner).getClassLoaderContext(); assertThat("correct class loader context returned", value, is("test")); } |
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public void addScanIterator(IteratorSetting iteratorSetting) { scanner.addScanIterator(iteratorSetting); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void addScanIteratorTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); IteratorSetting test = new IteratorSetting(10, "test", "test2"); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).addScanIterator(test); verify(mockScanner).addScanIterator(test); } |
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public void removeScanIterator(String s) { scanner.removeScanIterator(s); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void removeScanIteratorTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).removeScanIterator("test"); verify(mockScanner).removeScanIterator("test"); } |
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public void updateScanIteratorOption(String s, String s1, String s2) { scanner.updateScanIteratorOption(s, s1, s2); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void updateScanIteratorOptionTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).updateScanIteratorOption("test", "a", "b"); verify(mockScanner).updateScanIteratorOption("test", "a", "b"); } |
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public void setTimeout(long l, TimeUnit timeUnit) { scanner.setTimeout(l, timeUnit); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void setTimeoutTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).setTimeout(5L, TimeUnit.DAYS); verify(mockScanner).setTimeout(5L, TimeUnit.DAYS); } |
### Question:
EncryptedBatchScanner implements BatchScanner { @Override public long getTimeout(TimeUnit timeUnit) { return scanner.getTimeout(timeUnit); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); }### Answer:
@Test public void getTimeoutTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockScanner.getTimeout(TimeUnit.DAYS)).thenReturn(5L); Long value = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).getTimeout(TimeUnit.DAYS); verify(mockScanner).getTimeout(TimeUnit.DAYS); assertThat("correct timeout returned", value, is(5L)); } |
### Question:
EncryptedBatchWriter implements BatchWriter { @Override public void addMutations(Iterable<Mutation> iterable) throws MutationsRejectedException { for (Mutation mutation : iterable) { addMutation(mutation); } } EncryptedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, EncryptionConfig cryptoConfig, EncryptionKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); }### Answer:
@Test public void addMutationsTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); BatchWriter writer = new EncryptedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("encrypt-value.ini"), KEYS); List<Mutation> mutations = new ArrayList<>(); Mutation mutation = new Mutation("row"); mutation.put("colF", "colQ", "val"); mutations.add(mutation); writer.addMutations(mutations); verify(mockWriter, times(1)).addMutation(any()); mutations.add(mutation); writer.addMutations(mutations); verify(mockWriter, times(3)).addMutation(any()); mutations.add(mutation); writer.addMutations(mutations); verify(mockWriter, times(6)).addMutation(any()); } |
### Question:
EncryptedBatchWriter implements BatchWriter { @Override public void flush() throws MutationsRejectedException { writer.flush(); } EncryptedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, EncryptionConfig cryptoConfig, EncryptionKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); }### Answer:
@Test public void flushTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); new EncryptedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("encrypt-value.ini"), KEYS).flush(); verify(mockWriter).flush(); } |
### Question:
EncryptedBatchWriter implements BatchWriter { @Override public void close() throws MutationsRejectedException { writer.close(); } EncryptedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, EncryptionConfig cryptoConfig, EncryptionKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); }### Answer:
@Test public void closeTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); new EncryptedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("encrypt-value.ini"), KEYS).close(); verify(mockWriter).close(); } |
### Question:
EncryptionConfig { public void write(Writer out) throws IOException { Ini configIni = new Ini(); for (FieldEncryptorConfig config : fieldEncryptorConfigs) { config.write(configIni); } configIni.store(out); } EncryptionConfig(List<FieldEncryptorConfig> fieldEncryptorConfigs); void write(Writer out); }### Answer:
@Test public void writeTest() throws IOException { File iniFile = testFolder.newFile(); FileWriter out = new FileWriter(iniFile); config1.write(out); out.close(); Ini actual = new Ini(new FileReader(iniFile)); Ini expected = getIni("config1.ini"); assertThat("reading the ini produces the correct configuration", actual, is(Matchers.equalTo(expected))); }
@Test public void writeReadTest() throws IOException { File ini = testFolder.newFile(); FileWriter out = new FileWriter(ini); config1.write(out); out.close(); FileReader in = new FileReader(ini); EncryptionConfig config2 = new EncryptionConfigBuilder().readFromFile(in).build(); in.close(); assertThat("writing then reading the config should produce an equivalent configuration", config2, is(equalTo(config1))); } |
### Question:
EncryptedScannerIterator implements ItemProcessingIterator<Entry<Key,Value>> { @Override public boolean hasNext() { if (next == null) { advance(); } return next != null; } EncryptedScannerIterator(Iterator<Entry<Key,Value>> iterator, EntryEncryptor encryptor, List<Range> clientSideRanges,
SortedSet<Column> clientSideColumnFilters); @Override boolean hasNext(); @Override Entry<Key,Value> next(); @Override void remove(); @Override Entry<Key,Value> unprocessed(); }### Answer:
@Test public void hasNextTest() throws Exception { EntryEncryptor encryptor = new EntryEncryptor(getConfig("config.ini"), KEYS); List<Entry<Key,Value>> entries = new ArrayList<>(); Entry<Key,Value> entry = new SimpleImmutableEntry<Key,Value>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); entries.add(encryptor.encrypt(entry)); EncryptedScannerIterator iterator = new EncryptedScannerIterator(entries.iterator(), encryptor, Collections.singletonList(new Range()), new TreeSet<Column>()); assertThat("has next item", iterator.hasNext(), is(true)); assertThat("has next item", iterator.hasNext(), is(true)); iterator.next(); assertThat("does not have a next item", iterator.hasNext(), is(false)); } |
### Question:
EncryptedScannerIterator implements ItemProcessingIterator<Entry<Key,Value>> { @Override public Entry<Key,Value> next() { if (next == null) { advance(); } if (next == null) { throw new NoSuchElementException(); } Entry<Key,Value> value = next; next = null; return value; } EncryptedScannerIterator(Iterator<Entry<Key,Value>> iterator, EntryEncryptor encryptor, List<Range> clientSideRanges,
SortedSet<Column> clientSideColumnFilters); @Override boolean hasNext(); @Override Entry<Key,Value> next(); @Override void remove(); @Override Entry<Key,Value> unprocessed(); }### Answer:
@Test public void nextTest() throws Exception { EntryEncryptor encryptor = new EntryEncryptor(getConfig("config.ini"), KEYS); List<Entry<Key,Value>> entries = new ArrayList<>(); Entry<Key,Value> entry = new SimpleImmutableEntry<Key,Value>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); entries.add(encryptor.encrypt(entry)); EncryptedScannerIterator iterator = new EncryptedScannerIterator(entries.iterator(), encryptor, Collections.singletonList(new Range()), new TreeSet<Column>()); assertThat("next item is correct", iterator.next(), Matchers.equalTo(entry)); try { iterator.next(); fail("no items should be left"); } catch (NoSuchElementException e) { } } |
### Question:
EncryptedScannerIterator implements ItemProcessingIterator<Entry<Key,Value>> { @Override public Entry<Key,Value> unprocessed() { if (next != null || unprocessedEntry == null) { throw new NoSuchElementException(); } return unprocessedEntry; } EncryptedScannerIterator(Iterator<Entry<Key,Value>> iterator, EntryEncryptor encryptor, List<Range> clientSideRanges,
SortedSet<Column> clientSideColumnFilters); @Override boolean hasNext(); @Override Entry<Key,Value> next(); @Override void remove(); @Override Entry<Key,Value> unprocessed(); }### Answer:
@Test public void unprocessedTest() throws Exception { EntryEncryptor encryptor = new EntryEncryptor(getConfig("config.ini"), KEYS); List<Entry<Key,Value>> entries = new ArrayList<>(); Entry<Key,Value> entry = new SimpleImmutableEntry<Key,Value>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); entries.add(encryptor.encrypt(entry)); EncryptedScannerIterator iterator = new EncryptedScannerIterator(entries.iterator(), encryptor, Collections.singletonList(new Range()), new TreeSet<Column>()); iterator.next(); assertThat("unprocessed item is correct", iterator.unprocessed(), Matchers.equalTo(entries.get(0))); } |
### Question:
EncryptedScannerIterator implements ItemProcessingIterator<Entry<Key,Value>> { @Override public void remove() { throw new UnsupportedOperationException(); } EncryptedScannerIterator(Iterator<Entry<Key,Value>> iterator, EntryEncryptor encryptor, List<Range> clientSideRanges,
SortedSet<Column> clientSideColumnFilters); @Override boolean hasNext(); @Override Entry<Key,Value> next(); @Override void remove(); @Override Entry<Key,Value> unprocessed(); }### Answer:
@Test public void removeException() throws Exception { EntryEncryptor encryptor = new EntryEncryptor(getConfig("config.ini"), KEYS); List<Entry<Key,Value>> entries = new ArrayList<>(); Entry<Key,Value> entry = new SimpleImmutableEntry<Key,Value>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); entries.add(encryptor.encrypt(entry)); EncryptedScannerIterator iterator = new EncryptedScannerIterator(entries.iterator(), encryptor, Collections.singletonList(new Range()), new TreeSet<>()); try { iterator.remove(); fail("remove not supported"); } catch (UnsupportedOperationException e) { } } |
### Question:
EntryEncryptor { public boolean canBeDeleteServerSide() { for (EntryField field : FieldEncryptorConfig.KEY_DESTINATION_FIELDS) { if (destinationMap.containsKey(field) && !destinationMap.get(field).canBeFilteredServerSide(FieldEncryptorConfig.KEY_SOURCE_FIELDS)) { return false; } } return true; } EntryEncryptor(EncryptionConfig config, EncryptionKeyContainer keys); Entry<Key,Value> encrypt(Entry<Key,Value> entry); Entry<Key,Value> decrypt(Entry<Key,Value> entry); boolean canBeDeleteServerSide(); Collection<Key> getDeleteKeys(Key key); ColumnFilterResult getColumnFamilyFilter(Text col); ColumnFilterResult getColumnFilter(Text colFam, Text colQual); boolean transformRange(Range range, Collection<Range> serverSideRanges); }### Answer:
@Test public void canBeDeletedServerSideTest() throws Exception { assertThat("non-encrypted key can be updated", getEncryptor("encrypt-value.ini").canBeDeleteServerSide(), is(true)); assertThat("non-deterministically encrypted key cannot be updated", getEncryptor("encrypt-entry.ini").canBeDeleteServerSide(), is(false)); assertThat("searchable key can be updated", getEncryptor("searchable.ini").canBeDeleteServerSide(), is(true)); } |
### Question:
FieldEncryptor { boolean canBeFilteredServerSide(Collection<EntryField> availableSources) { return config.valueEncryptor.isDeterministic() && availableSources.containsAll(config.sources); } FieldEncryptor(FieldEncryptorConfig config, EncryptionKeyContainer keys); }### Answer:
@Test public void canBeFilteredServerSideTest() throws Exception { assertThat("non-deterministic algorithms can't be filtered server side", getEncryptor("gcm.ini").canBeFilteredServerSide(ImmutableSet.of(EntryField.ROW)), is(false)); assertThat("Visibility can't be filtered server side", getEncryptor("gcmCEABAC.ini").canBeFilteredServerSide(ImmutableSet.of(EntryField.ROW)), is(false)); assertThat("appropriate columns must be available", getEncryptor("siv.ini").canBeFilteredServerSide(ImmutableSet.of(EntryField.COLUMN_FAMILY)), is(false)); assertThat("deterministic encryption with correct fields should work", getEncryptor("siv.ini").canBeFilteredServerSide(ImmutableSet.of(EntryField.ROW)), is(true)); } |
### Question:
FieldEncryptor { boolean canSearchFor(Set<EntryField> fields) { return config.valueEncryptor.isDeterministic() && fields.equals(config.sources); } FieldEncryptor(FieldEncryptorConfig config, EncryptionKeyContainer keys); }### Answer:
@Test public void canSearchForTest() throws Exception { assertThat("non-deterministic algorithms can't be searched server side", getEncryptor("gcm.ini").canSearchFor(ImmutableSet.of(EntryField.ROW)), is(false)); assertThat("Visibility can't be filtered server side", getEncryptor("gcmCEABAC.ini").canSearchFor(ImmutableSet.of(EntryField.ROW)), is(false)); assertThat("appropriate columns must be available", getEncryptor("siv.ini").canSearchFor(ImmutableSet.of(EntryField.ROW, EntryField.COLUMN_FAMILY)), is(false)); assertThat("deterministic encryption with correct fields should work", getEncryptor("siv.ini").canSearchFor(ImmutableSet.of(EntryField.ROW)), is(true)); } |
### Question:
FieldEncryptor { List<byte[]> getServerSideFilterValues(MutableEntry key) { return getServerSideFilterValues(key, false); } FieldEncryptor(FieldEncryptorConfig config, EncryptionKeyContainer keys); }### Answer:
@Test public void getServerSideFilterValuesTest() throws Exception { MutableEntry original = new MutableEntry(new SimpleImmutableEntry<>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), (long) 5, false), new Value(new byte[] {6}))); ColumnVisibility visibility = new ColumnVisibility("secret"); MutableEntry encryptedV1 = new MutableEntry(); getEncryptor("siv.ini", new MockEncryptionKeyContainer(Pair.of("SIV", 1))).encrypt(original, encryptedV1, visibility); MutableEntry encryptedV2 = new MutableEntry(); getEncryptor("siv.ini", new MockEncryptionKeyContainer(Pair.of("SIV", 2))).encrypt(original, encryptedV2, visibility); List<byte[]> searchKeys = getEncryptor("siv.ini", new MockEncryptionKeyContainer(Pair.of("SIV", 2))).getServerSideFilterValues(original); assertThat("encrypted values for each version available", searchKeys, containsInAnyOrder(encryptedV1.row, encryptedV2.row)); } |
### Question:
MutableEntry implements Cloneable { public Key toKey() { return new Key(row, colF, colQ, colVis, timestamp, delete, false); } MutableEntry(); MutableEntry(Key key); MutableEntry(Map.Entry<Key,Value> entry); MutableEntry(byte[] row, ColumnUpdate update); Key toKey(); Map.Entry<Key,Value> toEntry(); MutableEntry cloneEntry(); byte[] getBytes(EntryField field); void setBytes(EntryField field, byte[] bytes); public byte[] row; public long timestamp; public boolean delete; }### Answer:
@Test public void toKeyTest() { MutableEntry mutableKey = new MutableEntry(key); assertThat("returned key should be the same as the original key", mutableKey.toKey(), is(equalTo(key))); } |
### Question:
MutableEntry implements Cloneable { public Map.Entry<Key,Value> toEntry() { return new AbstractMap.SimpleImmutableEntry<>(toKey(), new Value(value, false)); } MutableEntry(); MutableEntry(Key key); MutableEntry(Map.Entry<Key,Value> entry); MutableEntry(byte[] row, ColumnUpdate update); Key toKey(); Map.Entry<Key,Value> toEntry(); MutableEntry cloneEntry(); byte[] getBytes(EntryField field); void setBytes(EntryField field, byte[] bytes); public byte[] row; public long timestamp; public boolean delete; }### Answer:
@Test public void toEntryTest() { MutableEntry mutableEntry = new MutableEntry(entry); assertThat("returned entry should be the same as the original entry", mutableEntry.toEntry(), is(equalTo(entry))); } |
### Question:
MutableEntry implements Cloneable { public byte[] getBytes(EntryField field) { switch (field) { case ROW: return row; case COLUMN_FAMILY: return colF; case COLUMN_QUALIFIER: return colQ; case COLUMN_VISIBILITY: return colVis; case VALUE: return value; default: throw new IllegalArgumentException("invalid field"); } } MutableEntry(); MutableEntry(Key key); MutableEntry(Map.Entry<Key,Value> entry); MutableEntry(byte[] row, ColumnUpdate update); Key toKey(); Map.Entry<Key,Value> toEntry(); MutableEntry cloneEntry(); byte[] getBytes(EntryField field); void setBytes(EntryField field, byte[] bytes); public byte[] row; public long timestamp; public boolean delete; }### Answer:
@Test public void getBytesTest() { MutableEntry mutableEntry = new MutableEntry(entry); assertThat("correct bytes returned", mutableEntry.getBytes(EntryField.ROW), is(equalTo(row))); assertThat("correct bytes returned", mutableEntry.getBytes(EntryField.COLUMN_FAMILY), is(equalTo(colF))); assertThat("correct bytes returned", mutableEntry.getBytes(EntryField.COLUMN_QUALIFIER), is(equalTo(colQ))); assertThat("correct bytes returned", mutableEntry.getBytes(EntryField.COLUMN_VISIBILITY), is(equalTo(colVis))); assertThat("correct bytes returned", mutableEntry.getBytes(EntryField.VALUE), is(equalTo(value))); }
@Test(expected = IllegalArgumentException.class) public void getBytesException() { MutableEntry mutableEntry = new MutableEntry(entry); mutableEntry.getBytes(EntryField.TIMESTAMP); } |
### Question:
MutableEntry implements Cloneable { public void setBytes(EntryField field, byte[] bytes) { switch (field) { case ROW: row = bytes; break; case COLUMN_FAMILY: colF = bytes; break; case COLUMN_QUALIFIER: colQ = bytes; break; case COLUMN_VISIBILITY: colVis = bytes; break; case VALUE: value = bytes; break; default: throw new IllegalArgumentException("invalid field"); } } MutableEntry(); MutableEntry(Key key); MutableEntry(Map.Entry<Key,Value> entry); MutableEntry(byte[] row, ColumnUpdate update); Key toKey(); Map.Entry<Key,Value> toEntry(); MutableEntry cloneEntry(); byte[] getBytes(EntryField field); void setBytes(EntryField field, byte[] bytes); public byte[] row; public long timestamp; public boolean delete; }### Answer:
@Test(expected = IllegalArgumentException.class) public void setBytesException() { MutableEntry mutableEntry = new MutableEntry(entry); mutableEntry.setBytes(EntryField.TIMESTAMP, EMPTY); } |
### Question:
Utils { public static byte[] xor(byte[] first, byte[] second) { checkArgument(first != null, "first is null"); checkArgument(second != null, "second is null"); checkArgument(first.length == second.length, "first and second must be the same length"); for (int i = 0; i < first.length; i++) { first[i] = (byte) (first[i] ^ second[i]); } return first; } private Utils(); static byte[] xor(byte[] first, byte[] second); static final byte[] EMPTY; static final Charset VISIBILITY_CHARSET; }### Answer:
@Test public void xorTest() { byte[] first = new byte[] {0, 1, 2}; byte[] second = new byte[] {0, 1, 1}; byte[] result = Utils.xor(first, second); assertThat("the return value is the same as the first argument", result == first, is(true)); assertThat("the correct result was achieved", result, is(equalTo(new byte[] {0, 0, 3}))); }
@Test public void xorExceptionTest() { byte[] first = new byte[] {0, 1, 2}; byte[] second = new byte[] {0, 1, 2, 3}; try { Utils.xor(null, second); fail("null first variable not allowed"); } catch (IllegalArgumentException e) { } try { Utils.xor(first, null); fail("null second variable not allowed"); } catch (IllegalArgumentException e) { } try { Utils.xor(first, second); fail("arrays with unequal length not allowed"); } catch (IllegalArgumentException e) { } } |
### Question:
SignatureConfig { public ValueSigner getAlgorithm() { return this.algorithm; } SignatureConfig(ValueSigner signer, String provider, Destination destination, String destinationTable, byte[] defaultVisibility); void write(Writer out); boolean isSignatureInSeparateTable(); ValueSigner getAlgorithm(); }### Answer:
@Test public void getAlgorithmTest() { assertThat("correct algorithm", config1.getAlgorithm(), Matchers.equalTo(config1.algorithm)); assertThat("correct algorithm", config2.getAlgorithm(), Matchers.equalTo(config2.algorithm)); assertThat("correct algorithm", config3.getAlgorithm(), Matchers.equalTo(config3.algorithm)); } |
### Question:
SignatureConfig { public boolean isSignatureInSeparateTable() { return this.destination == Destination.SEPARATE_TABLE; } SignatureConfig(ValueSigner signer, String provider, Destination destination, String destinationTable, byte[] defaultVisibility); void write(Writer out); boolean isSignatureInSeparateTable(); ValueSigner getAlgorithm(); }### Answer:
@Test public void isSignatureInSeparateTableTest() { assertThat("correct return value", config1.isSignatureInSeparateTable(), is(false)); assertThat("correct return value", config2.isSignatureInSeparateTable(), is(false)); assertThat("correct return value", config3.isSignatureInSeparateTable(), is(true)); } |
### Question:
SignedBatchScanner implements BatchScanner { @Override public Authorizations getAuthorizations() { return valueScanner.getAuthorizations(); } SignedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, SignatureConfig signatureConfig,
SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void setRanges(Collection<Range> collection); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); }### Answer:
@Test public void getAuthorizationsTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockScanner.getAuthorizations()).thenReturn(authorizations); Authorizations auths = new SignedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).getAuthorizations(); verify(mockScanner).getAuthorizations(); assertThat("correct authorizations returned", auths, equalTo(authorizations)); } |
### Question:
SignedBatchScanner implements BatchScanner { @Override public SamplerConfiguration getSamplerConfiguration() { return valueScanner.getSamplerConfiguration(); } SignedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, SignatureConfig signatureConfig,
SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void setRanges(Collection<Range> collection); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); }### Answer:
@Test public void getSamplerConfigurationTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); SamplerConfiguration config = new SamplerConfiguration("test"); when(mockScanner.getSamplerConfiguration()).thenReturn(config); SamplerConfiguration value = new SignedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).getSamplerConfiguration(); verify(mockScanner).getSamplerConfiguration(); assertThat("correct config returned", value, equalTo(config)); } |
### Question:
SignedBatchScanner implements BatchScanner { @Override public long getBatchTimeout(TimeUnit timeUnit) { return valueScanner.getBatchTimeout(timeUnit); } SignedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, SignatureConfig signatureConfig,
SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void setRanges(Collection<Range> collection); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); }### Answer:
@Test public void getBatchTimeoutTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockScanner.getBatchTimeout(TimeUnit.DAYS)).thenReturn(5L); long value = new SignedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .getBatchTimeout(TimeUnit.DAYS); verify(mockScanner).getBatchTimeout(TimeUnit.DAYS); assertThat("correct timeout returned", value, is(5L)); } |
### Question:
SignedBatchScanner implements BatchScanner { @Override public String getClassLoaderContext() { return valueScanner.getClassLoaderContext(); } SignedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, SignatureConfig signatureConfig,
SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void setRanges(Collection<Range> collection); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); }### Answer:
@Test public void getClassLoaderContextTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockScanner.getClassLoaderContext()).thenReturn("test"); String value = new SignedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .getClassLoaderContext(); verify(mockScanner).getClassLoaderContext(); assertThat("correct class loader context returned", value, is("test")); } |
### Question:
SignedBatchScanner implements BatchScanner { @Override public long getTimeout(TimeUnit timeUnit) { return valueScanner.getTimeout(timeUnit); } SignedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, SignatureConfig signatureConfig,
SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void setRanges(Collection<Range> collection); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); }### Answer:
@Test public void getTimeoutTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockScanner.getTimeout(TimeUnit.DAYS)).thenReturn(5L); Long value = new SignedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .getTimeout(TimeUnit.DAYS); verify(mockScanner).getTimeout(TimeUnit.DAYS); assertThat("correct timeout returned", value, is(5L)); } |
### Question:
AnnotationFinder { public static <T extends Annotation> T annotationFor(Package aPkg, Class< ? extends T> whichAnnotation) { T annotation = null; if ((annotation = aPkg.getAnnotation(whichAnnotation)) == null) { annotation = find(aPkg, whichAnnotation); } return annotation; } static T annotationFor(Package aPkg, Class< ? extends T> whichAnnotation); }### Answer:
@Test public void testAnnotationForPackageShouldAcceptWildCardClass() throws Exception { Class<? extends RamlGenerators> input = RamlGenerators.class; RamlGenerators generators = annotationFor(TOP_PACKAGE, input); assertNotNull("Wildcard โ null return not expected", generators); }
@Test public void testAnnotationForPackageShouldAcceptClassLiteral() throws Exception { RamlGenerators generators = annotationFor(TOP_PACKAGE, RamlGenerators.class); assertNotNull("Class literal โ null return not expected", generators); }
@Test public void testAnnotationForPackageShouldAcceptTypeWitness() throws Exception { RamlGenerators generators = AnnotationFinder.<RamlGenerators>annotationFor(TOP_PACKAGE, RamlGenerators.class); assertNotNull("Type witness โ null return not expected", generators); } |
### Question:
SimpleTypeNodeHandler extends NodeHandler<SimpleTypeNode<?>> { @Override public boolean handleSafely(SimpleTypeNode<?> node, YamlEmitter emitter) throws IOException { emitter.writeValue(node); return true; } SimpleTypeNodeHandler(); @Override boolean handles(Node node); @Override boolean handleSafely(SimpleTypeNode<?> node, YamlEmitter emitter); }### Answer:
@Test public void handleSafely() throws Exception { SimpleTypeNodeHandler rnh = new SimpleTypeNodeHandler(); rnh.handleSafely(goodNode, emitter); verify(emitter).writeValue(goodNode); } |
### Question:
DefaultNodeHandler extends NodeHandler<Node> { @Override public boolean handles(Node node) { return true; } @Override boolean handles(Node node); @Override boolean handleSafely(Node node, YamlEmitter emitter); }### Answer:
@Test public void handles() throws Exception { DefaultNodeHandler handler = new DefaultNodeHandler(); assertTrue(handler.handles(node)); } |
### Question:
DefaultNodeHandler extends NodeHandler<Node> { @Override public boolean handleSafely(Node node, YamlEmitter emitter) { System.err.println("not handled: " + node.getClass() + ", " + Arrays.asList(node.getClass().getInterfaces())); return true; } @Override boolean handles(Node node); @Override boolean handleSafely(Node node, YamlEmitter emitter); }### Answer:
@Test public void handleSafely() throws Exception { DefaultNodeHandler handler = new DefaultNodeHandler(); assertTrue(handler.handle(node, emitter)); verifyNoMoreInteractions(emitter); } |
### Question:
YamlEmitter { public void writeValue(SimpleTypeNode<?> node) throws IOException { if (node instanceof StringNode) { writeQuoted(node.getLiteralValue()); } else { writeNaked(node.getLiteralValue()); } } YamlEmitter(); YamlEmitter(Writer writer, int i); YamlEmitter indent(); YamlEmitter bulletListArray(); void writeTag(String tag); void writeValue(SimpleTypeNode<?> node); void writeObjectValue(String value); void writeSyntaxElement(String s); void writeIndent(); }### Answer:
@Test public void writeValueClean() throws Exception { when(stringNode.getLiteralValue()).thenReturn("hello"); YamlEmitter emitter = new YamlEmitter(writer, 0); emitter.writeValue(stringNode); assertEquals("hello", writer.toString()); }
@Test public void writeValue() throws Exception { when(stringNode.getLiteralValue()).thenReturn("hel@lo"); YamlEmitter emitter = new YamlEmitter(writer, 0); emitter.writeValue(stringNode); assertEquals("\"hel@lo\"", writer.toString()); }
@Test public void writeMultilineValue() throws Exception { when(stringNode.getLiteralValue()).thenReturn("hello\nman"); YamlEmitter emitter = new YamlEmitter(writer, 0); emitter.writeValue(stringNode); assertEquals("|\n hello\n man", writer.toString()); }
@Test public void writeMultilineValueBecauseOfQuote() throws Exception { when(stringNode.getLiteralValue()).thenReturn("hello\"man"); YamlEmitter emitter = new YamlEmitter(writer, 0); emitter.writeValue(stringNode); assertEquals("|\n hello\"man", writer.toString()); } |
### Question:
AllResourceSelector implements Selector<Resource> { @Override public FluentIterable<Resource> fromApi(Api api) { List<Resource> topResources = api.resources(); FluentIterable<Resource> fi = from(topResources); for (Resource resource : topResources) { fi = fi.append(fromResource(resource)); } return fi; } @Override FluentIterable<Resource> fromApi(Api api); @Override FluentIterable<Resource> fromResource(Resource topResource); }### Answer:
@Test public void fromApi() throws Exception { when(api.resources()).thenReturn(Collections.singletonList(resource)); when(resource.resources()).thenReturn(Collections.singletonList(subResource)); AllResourceSelector allResourceSelector = new AllResourceSelector(); FluentIterable<Resource> apiElements = allResourceSelector.fromApi(api); assertThat(apiElements, containsInAnyOrder(resource, subResource)); verify(api).resources(); verify(resource).resources(); verify(subResource).resources(); } |
### Question:
AllResourceSelector implements Selector<Resource> { @Override public FluentIterable<Resource> fromResource(Resource topResource) { List<Resource> resources = topResource.resources(); FluentIterable<Resource> fi = from(resources); for (Resource resource : resources) { fi = fi.append(fromResource(resource)); } return fi; } @Override FluentIterable<Resource> fromApi(Api api); @Override FluentIterable<Resource> fromResource(Resource topResource); }### Answer:
@Test public void fromResource() throws Exception { when(resource.resources()).thenReturn(Collections.singletonList(subResource)); AllResourceSelector allResourceSelector = new AllResourceSelector(); FluentIterable<Resource> apiElements = allResourceSelector.fromResource(resource); assertThat(apiElements, containsInAnyOrder(subResource)); verify(resource).resources(); verify(subResource).resources(); } |
### Question:
ApiQueryBaseHandler implements QueryBase { @Override public <B> FluentIterable<B> queryFor(Selector<B> selector) { return selector.fromApi(api); } ApiQueryBaseHandler(Api api); @Override FluentIterable<B> queryFor(Selector<B> selector); }### Answer:
@Test public void queryFor() throws Exception { when(selector.fromApi(api)).thenReturn(fluentIterator); ApiQueryBaseHandler handler = new ApiQueryBaseHandler(api); FluentIterable<Resource> iterable = handler.queryFor(selector); assertNotNull(iterable); verify(selector).fromApi(api); } |
### Question:
ResourceQueryBaseHandler implements QueryBase { @Override public <B> FluentIterable<B> queryFor(Selector<B> selector) { return selector.fromResource(resource); } ResourceQueryBaseHandler(Resource resource); @Override FluentIterable<B> queryFor(Selector<B> selector); }### Answer:
@Test public void queryFor() throws Exception { when(selector.fromResource(resource)).thenReturn(fluentIterator); ResourceQueryBaseHandler handler = new ResourceQueryBaseHandler(resource); FluentIterable<Resource> iterable = handler.queryFor(selector); assertNotNull(iterable); verify(selector).fromResource(resource); } |
### Question:
TopResourceSelector implements Selector<Resource> { @Override public FluentIterable<Resource> fromApi(Api api) { return from(api.resources()); } @Override FluentIterable<Resource> fromApi(Api api); @Override FluentIterable<Resource> fromResource(Resource resource); }### Answer:
@Test public void fromApi() throws Exception { TopResourceSelector topResourceSelector = new TopResourceSelector(); FluentIterable<Resource> apiElements = topResourceSelector.fromApi(api); assertEquals(0, apiElements.size()); verify(api).resources(); } |
### Question:
TopResourceSelector implements Selector<Resource> { @Override public FluentIterable<Resource> fromResource(Resource resource) { return FluentIterable.from(resource.resources()); } @Override FluentIterable<Resource> fromApi(Api api); @Override FluentIterable<Resource> fromResource(Resource resource); }### Answer:
@Test public void fromResource() throws Exception { TopResourceSelector topResourceSelector = new TopResourceSelector(); FluentIterable<Resource> resourceElements = topResourceSelector.fromResource(resource); assertEquals(0, resourceElements.size()); verify(resource).resources(); } |
### Question:
Query { public<T> FluentIterable<T> select(Selector<T> selector) { return queryBase.queryFor(selector); } Query(QueryBase queryBase); static Query from(Api api); static Query from(Resource resource); FluentIterable<T> select(Selector<T> selector); }### Answer:
@Test public void select() throws Exception { when(base.queryFor(selector)).thenReturn(fluentList); Query query = new Query(base); FluentIterable<Resource> resourceList = query.select(selector); assertSame(resourceList, fluentList); } |
### Question:
ResultingPojos { public void createAllTypes(String rootDirectory) throws IOException { generationContext.createSupportTypes(rootDirectory); for (CreationResult result : results) { result.createType(rootDirectory); } generationContext.createTypes(rootDirectory); } ResultingPojos(GenerationContextImpl generationContext); void addNewResult(CreationResult spec); List<CreationResult> creationResults(); void createFoundTypes(String rootDirectory); void createAllTypes(String rootDirectory); }### Answer:
@Test public void createAllTypes() throws Exception { ResultingPojos pojos = new ResultingPojos(generationContext); pojos.addNewResult(result); pojos.createAllTypes("/tmp/fun"); verify(generationContext).createTypes("/tmp/fun"); verify(generationContext).createSupportTypes("/tmp/fun"); verify(result).createType("/tmp/fun"); } |
### Question:
ResultingPojos { public void createFoundTypes(String rootDirectory) throws IOException { generationContext.createSupportTypes(rootDirectory); for (CreationResult result : results) { result.createType(rootDirectory); } } ResultingPojos(GenerationContextImpl generationContext); void addNewResult(CreationResult spec); List<CreationResult> creationResults(); void createFoundTypes(String rootDirectory); void createAllTypes(String rootDirectory); }### Answer:
@Test public void createFoundTypes() throws Exception { ResultingPojos pojos = new ResultingPojos(generationContext); pojos.addNewResult(result); pojos.createFoundTypes("/tmp/fun"); verify(result).createType("/tmp/fun"); verify(generationContext).createSupportTypes("/tmp/fun"); verify(generationContext, never()).createTypes("/tmp/fun"); } |
### Question:
CreationResult { public void createType(String rootDirectory) throws IOException { if ( interf.typeSpecs.size() == 0 ) { createInlineType(this); } createJavaFile(packageName, interf, rootDirectory, true); if ( implementationName != null ) { createJavaFile(packageName, impl, rootDirectory, false); } } CreationResult(String packageName, ClassName interfaceName, ClassName implementationName); CreationResult withInterface(TypeSpec spec); CreationResult withImplementation(TypeSpec spec); TypeSpec getInterface(); Optional<TypeSpec> getImplementation(); void createType(String rootDirectory); CreationResult getInternalTypeForProperty(String inside); ClassName getJavaName(EventType eventType); CreationResult withInternalType(String name, CreationResult internal); CreationResult internalType(String name); }### Answer:
@Test public void createType() throws Exception { CreationResult result = new CreationResult("pack.me", ClassName.get("", "foo"), ClassName.get("", "foo")) { TypeSpec[] specs = {interf, cls}; int c = 0; @Override protected void createJavaFile(String pack, TypeSpec spec, String root, boolean b) { assertEquals("pack.me", pack); assertEquals("/tmp/foo", root); assertSame(spec, specs[c ++]); } }; result.withInterface(interf).withImplementation(cls); result.createType("/tmp/foo"); } |
### Question:
PojoToRamlImpl implements PojoToRaml { @Override public Result classToRaml(final Class<?> clazz) { RamlType type = RamlTypeFactory.forType(clazz, classParserFactory.createParser(clazz), adjusterFactory).or(new RamlTypeSupplier(clazz)); if ( type.isScalar()) { return new Result(null, Collections.<String, TypeDeclarationBuilder>emptyMap()); } Map<String, TypeDeclarationBuilder> dependentTypes = new HashMap<>(); TypeDeclarationBuilder builder = handleSingleType(clazz, dependentTypes); dependentTypes.remove(builder.id()); return new Result(builder, dependentTypes); } PojoToRamlImpl(ClassParserFactory parser, AdjusterFactory adjusterFactory); @Override Result classToRaml(final Class<?> clazz); @Override TypeBuilder name(Class<?> clazz); @Override TypeBuilder name(Type type); }### Answer:
@Test public void scalarType() throws Exception { PojoToRamlImpl pojoToRaml = new PojoToRamlImpl(FieldClassParser.factory(), AdjusterFactory.NULL_FACTORY); Result types = pojoToRaml.classToRaml(String.class); Api api = createApi(types); List<TypeDeclaration> buildTypes = api.types(); assertEquals(0, buildTypes.size()); Emitter emitter = new Emitter(); emitter.emit(api); } |
### Question:
RenamePlugin extends AllTypesPluginHelper { @Override public ClassName className(ObjectPluginContext objectPluginContext, ObjectTypeDeclaration ramlType, ClassName currentSuggestion, EventType eventType) { return changeName(currentSuggestion, eventType); } RenamePlugin(List<String> arguments); @Override ClassName className(ObjectPluginContext objectPluginContext, ObjectTypeDeclaration ramlType, ClassName currentSuggestion, EventType eventType); }### Answer:
@Test public void className() { RenamePlugin plugin = new RenamePlugin(Arrays.asList("One", "OneImplementation")); ClassName cn = plugin.className((ObjectPluginContext) null, null, ClassName.bestGuess("fun.com.Allo"), EventType.INTERFACE); assertEquals("fun.com.One", cn.toString()); cn = plugin.className((ObjectPluginContext) null, null, ClassName.bestGuess("fun.com.Allo"), EventType.IMPLEMENTATION); assertEquals("fun.com.OneImplementation", cn.toString()); }
@Test public void classNameWithDefaultImpl() { RenamePlugin plugin = new RenamePlugin(Arrays.asList("One")); ClassName cn = plugin.className((ObjectPluginContext) null, null, ClassName.bestGuess("fun.com.Allo"), EventType.INTERFACE); assertEquals("fun.com.One", cn.toString()); cn = plugin.className((ObjectPluginContext) null, null, ClassName.bestGuess("fun.com.Allo"), EventType.IMPLEMENTATION); assertEquals("fun.com.OneImpl", cn.toString()); } |
### Question:
BoxWhenNotRequired implements ReferenceTypeHandlerPlugin { @Override public TypeName typeName(ReferencePluginContext referencePluginContext, TypeDeclaration ramlType, TypeName currentSuggestion) { if (! ramlType.required()) { return currentSuggestion.box(); } else { return currentSuggestion; } } BoxWhenNotRequired(List<String> arguments); @Override TypeName typeName(ReferencePluginContext referencePluginContext, TypeDeclaration ramlType, TypeName currentSuggestion); }### Answer:
@Test public void boxOnNotRequired() { when(integerDeclaration.required()).thenReturn(false); BoxWhenNotRequired boxWhenNotRequired = new BoxWhenNotRequired(null); TypeName tn = boxWhenNotRequired.typeName(null, integerDeclaration, TypeName.INT); assertEquals(TypeName.INT.box(), tn); }
@Test public void noBoxOnRequired() { when(integerDeclaration.required()).thenReturn(true); BoxWhenNotRequired boxWhenNotRequired = new BoxWhenNotRequired(null); TypeName tn = boxWhenNotRequired.typeName(null, integerDeclaration, TypeName.INT); assertEquals(TypeName.INT, tn); } |
### Question:
JaxbUnionExtension implements UnionTypeHandlerPlugin { @Override public ClassName className(UnionPluginContext unionPluginContext, UnionTypeDeclaration ramlType, ClassName currentSuggestion, EventType eventType) { return currentSuggestion; } @Override ClassName className(UnionPluginContext unionPluginContext, UnionTypeDeclaration ramlType, ClassName currentSuggestion, EventType eventType); @Override TypeSpec.Builder classCreated(UnionPluginContext unionPluginContext, UnionTypeDeclaration type, TypeSpec.Builder builder, EventType eventType); @Override FieldSpec.Builder anyFieldCreated(UnionPluginContext context, UnionTypeDeclaration union, TypeSpec.Builder typeSpec, FieldSpec.Builder anyType, EventType eventType); @Override FieldSpec.Builder fieldBuilt(UnionPluginContext context, TypeDeclaration property, FieldSpec.Builder fieldSpec, EventType eventType); }### Answer:
@Test public void className() { JaxbUnionExtension jaxb = new JaxbUnionExtension(); ClassName typeName = ClassName.bestGuess("foo.Union"); TypeName calculatedTypeName = jaxb.className(null, null, typeName, null); assertSame(typeName, calculatedTypeName); } |
### Question:
JaxbUnionExtension implements UnionTypeHandlerPlugin { @Override public FieldSpec.Builder anyFieldCreated(UnionPluginContext context, UnionTypeDeclaration union, TypeSpec.Builder typeSpec, FieldSpec.Builder anyType, EventType eventType) { AnnotationSpec.Builder elementsAnnotation = AnnotationSpec.builder(XmlElements.class); for (TypeDeclaration typeDeclaration : union.of()) { TypeName unionPossibility = context.unionClass(typeDeclaration).getJavaName(EventType.IMPLEMENTATION); elementsAnnotation.addMember("value", "$L", AnnotationSpec .builder(XmlElement.class) .addMember("name", "$S", typeDeclaration.name()) .addMember("type", "$T.class", unionPossibility ) .build()); } anyType.addAnnotation(elementsAnnotation.build()); return anyType; } @Override ClassName className(UnionPluginContext unionPluginContext, UnionTypeDeclaration ramlType, ClassName currentSuggestion, EventType eventType); @Override TypeSpec.Builder classCreated(UnionPluginContext unionPluginContext, UnionTypeDeclaration type, TypeSpec.Builder builder, EventType eventType); @Override FieldSpec.Builder anyFieldCreated(UnionPluginContext context, UnionTypeDeclaration union, TypeSpec.Builder typeSpec, FieldSpec.Builder anyType, EventType eventType); @Override FieldSpec.Builder fieldBuilt(UnionPluginContext context, TypeDeclaration property, FieldSpec.Builder fieldSpec, EventType eventType); }### Answer:
@Test public void anyFieldCreated() { } |
### Question:
PojoToRamlImpl implements PojoToRaml { @Override public TypeBuilder name(Class<?> clazz) { RamlAdjuster adjuster = this.adjusterFactory.createAdjuster(clazz); ClassParser parser = classParserFactory.createParser(clazz); RamlType type = RamlTypeFactory.forType(clazz, parser, adjusterFactory).or(new RamlTypeSupplier(clazz)); if ( type.isScalar()) { return type.getRamlSyntax(); } final String simpleName = adjuster.adjustTypeName(clazz, clazz.getSimpleName()); return TypeBuilder.type(simpleName); } PojoToRamlImpl(ClassParserFactory parser, AdjusterFactory adjusterFactory); @Override Result classToRaml(final Class<?> clazz); @Override TypeBuilder name(Class<?> clazz); @Override TypeBuilder name(Type type); }### Answer:
@Test public void name() throws Exception { PojoToRamlImpl pojoToRaml = new PojoToRamlImpl(FieldClassParser.factory(), AdjusterFactory.NULL_FACTORY); TypeBuilder builder = pojoToRaml.name(Fun.class.getMethod("stringMethod").getGenericReturnType()); ObjectNode node = builder.buildNode(); assertEquals("type: array", node.getChildren().get(0).toString()); } |
### Question:
Jsr303Extension extends AllTypesPluginHelper { @Override public FieldSpec.Builder anyFieldCreated( UnionPluginContext context, UnionTypeDeclaration union, TypeSpec.Builder typeSpec, FieldSpec.Builder anyType, EventType eventType) { FacetValidation.addFacetsForBuilt(new AnnotationAdder() { @Override public TypeName typeName() { return anyType.build().type; } @Override public void addAnnotation(AnnotationSpec spec) { anyType.addAnnotation(spec); } }); return anyType; } @Override FieldSpec.Builder fieldBuilt(ObjectPluginContext objectPluginContext, TypeDeclaration typeDeclaration, FieldSpec.Builder fieldSpec, EventType eventType); @Override FieldSpec.Builder fieldBuilt(UnionPluginContext unionPluginContext, TypeDeclaration ramlType, FieldSpec.Builder fieldSpec, EventType eventType); @Override FieldSpec.Builder anyFieldCreated( UnionPluginContext context, UnionTypeDeclaration union, TypeSpec.Builder typeSpec, FieldSpec.Builder anyType, EventType eventType); }### Answer:
@Test public void forUnion() throws Exception { Jsr303Extension ext = new Jsr303Extension(); TypeSpec.Builder typeBuilder = TypeSpec.classBuilder(ClassName.get("xx.bb", "Foo")); FieldSpec.Builder builder = FieldSpec.builder(ClassName.get(Double.class), "champ", Modifier.PUBLIC); ext.anyFieldCreated(unionPluginContext, union, typeBuilder, builder, EventType.IMPLEMENTATION); assertEquals(1, builder.build().annotations.size()); assertEquals(Valid.class.getName(), builder.build().annotations.get(0).type.toString()); } |
### Question:
TypeFetchers { public static TypeFetcher fromTypes() { return new TypeFetcher() { Iterable<TypeDeclaration> foundInApi; @Override public TypeDeclaration fetchType(Api api, final String name) throws GenerationException { return FluentIterable.from(Optional.fromNullable(foundInApi).or(api.types())) .firstMatch(namedPredicate(name)).or(fail(name)); } }; } static TypeFetcher fromTypes(); static TypeFetcher fromLibraries(); static TypeFetcher fromAnywhere(); static final TypeFetcher NULL_FETCHER; }### Answer:
@Test public void fromTypes() throws Exception { when(api.types()).thenReturn(Arrays.asList(t1, t2, t3)); TypeDeclaration typeDeclaration = TypeFetchers.fromTypes().fetchType(api, "t1"); assertSame(t1, typeDeclaration); }
@Test(expected = GenerationException.class) public void fromTypesFail() throws Exception { when(api.types()).thenReturn(Arrays.asList(t4, t5, t6)); when(api.uses()).thenReturn(Arrays.asList(l1, l2)); when(l1.uses()).thenReturn(Collections.singletonList(l3)); when(l1.types()).thenReturn(Collections.singletonList(t1)); when(l2.types()).thenReturn(Collections.singletonList(t2)); when(l3.types()).thenReturn(Collections.singletonList(t3)); TypeFetchers.fromTypes().fetchType(api, "nosuchtype"); } |
### Question:
TypeFetchers { public static TypeFetcher fromAnywhere() { return new TypeFetcher() { Iterable<TypeDeclaration> foundInApi; @Override public TypeDeclaration fetchType(Api api, final String name) throws GenerationException { return FluentIterable.from(Optional.fromNullable(foundInApi).or(FluentIterable.from(api.types()).append(Utils.goThroughLibraries(new ArrayList<TypeDeclaration>(), new HashSet<String>(), api.uses())))) .firstMatch(namedPredicate(name)).or(fail(name)); } }; } static TypeFetcher fromTypes(); static TypeFetcher fromLibraries(); static TypeFetcher fromAnywhere(); static final TypeFetcher NULL_FETCHER; }### Answer:
@Test public void fromAnywhere() throws Exception { when(api.types()).thenReturn(Arrays.asList(t4, t5, t6)); when(api.uses()).thenReturn(Arrays.asList(l1, l2)); when(l1.uses()).thenReturn(Collections.singletonList(l3)); when(l1.types()).thenReturn(Collections.singletonList(t1)); when(l2.types()).thenReturn(Collections.singletonList(t2)); when(l3.types()).thenReturn(Collections.singletonList(t3)); TypeDeclaration typeDeclaration1 = TypeFetchers.fromAnywhere().fetchType(api, "t1"); TypeDeclaration typeDeclaration2 = TypeFetchers.fromAnywhere().fetchType(api, "t2"); TypeDeclaration typeDeclaration3 = TypeFetchers.fromAnywhere().fetchType(api, "t3"); TypeDeclaration typeDeclaration4 = TypeFetchers.fromAnywhere().fetchType(api, "t4"); TypeDeclaration typeDeclaration5 = TypeFetchers.fromAnywhere().fetchType(api, "t5"); TypeDeclaration typeDeclaration6 = TypeFetchers.fromAnywhere().fetchType(api, "t6"); assertSame(typeDeclaration1, t1); assertSame(typeDeclaration2, t2); assertSame(typeDeclaration3, t3); assertSame(typeDeclaration4, t4); assertSame(typeDeclaration5, t5); assertSame(typeDeclaration6, t6); } |
### Question:
TypeFinders { public static TypeFinder inTypes() { return new TypeFinder() { @Override public Iterable<TypeDeclaration> findTypes(Api api) { return api.types(); } }; } static TypeFinder inTypes(); static TypeFinder inLibraries(); static TypeFinder everyWhere(); static TypeFinder inResources(); }### Answer:
@Test public void inTypes() { when(api.types()).thenReturn(Arrays.asList(t1, t2, t3)); Iterable<TypeDeclaration> it = TypeFinders.inTypes().findTypes(api); assertThat(it, contains(equalTo(t1), equalTo(t2), equalTo(t3))); } |
### Question:
TypeFinders { public static TypeFinder inLibraries() { return new TypeFinder() { @Override public Iterable<TypeDeclaration> findTypes(Api api) { List<TypeDeclaration> foundTypes = new ArrayList<>(); Utils.goThroughLibraries(foundTypes, new HashSet<String>(), api.uses()); return foundTypes; } }; } static TypeFinder inTypes(); static TypeFinder inLibraries(); static TypeFinder everyWhere(); static TypeFinder inResources(); }### Answer:
@Test public void inLibraries() { when(api.uses()).thenReturn(Arrays.asList(l1, l2)); when(l1.uses()).thenReturn(Collections.singletonList(l3)); when(l1.types()).thenReturn(Collections.singletonList(t1)); when(l2.types()).thenReturn(Collections.singletonList(t2)); when(l3.types()).thenReturn(Collections.singletonList(t3)); Iterable<TypeDeclaration> it = TypeFinders.inLibraries().findTypes(api); System.err.println(it); assertThat(it, containsInAnyOrder(equalTo(t1), equalTo(t2), equalTo(t3))); } |
### Question:
TypeFinders { public static TypeFinder everyWhere() { return new TypeFinder() { @Override public Iterable<TypeDeclaration> findTypes(Api api) { return FluentIterable.from(api.types()) .append(resourceTypes(api.resources())) .append(Utils.goThroughLibraries(new ArrayList<TypeDeclaration>(), new HashSet<String>(), api.uses())); } }; } static TypeFinder inTypes(); static TypeFinder inLibraries(); static TypeFinder everyWhere(); static TypeFinder inResources(); }### Answer:
@Test public void everyWhere() { when(api.types()).thenReturn(Arrays.asList(t4, t5, t6)); when(api.uses()).thenReturn(Arrays.asList(l1, l2)); when(l1.uses()).thenReturn(Collections.singletonList(l3)); when(l1.types()).thenReturn(Collections.singletonList(t1)); when(l2.types()).thenReturn(Collections.singletonList(t2)); when(l3.types()).thenReturn(Collections.singletonList(t3)); Iterable<TypeDeclaration> it = TypeFinders.everyWhere().findTypes(api); System.err.println(it); assertThat(it, containsInAnyOrder(equalTo(t1), equalTo(t2), equalTo(t3), equalTo(t4), equalTo(t5), equalTo(t6))); } |
### Question:
Augmenter { public static<T> T augment(Class<T> augmentedInterface, final Object delegate) { try { Extension extension = augmentedInterface.getAnnotation(Extension.class); ExtensionFactory extensionFactory = augmentedInterface.getAnnotation(ExtensionFactory.class); if ( extension == null && extensionFactory == null ) { throw new IllegalArgumentException("no @Extension or @ExtensionFactory annotation to build augmented interface"); } AugmentationExtensionFactory factory = createFactory(extension, extensionFactory); final Object handler = findFactoryMethod(delegate, factory); return buildProxy(augmentedInterface, delegate, handler); } catch (NoSuchMethodException| IllegalAccessException | InvocationTargetException | InstantiationException e) { throw new AugmentationException("trying to augment " + augmentedInterface, e); } } static T augment(Class<T> augmentedInterface, final Object delegate); }### Answer:
@Test public void simple() throws Exception { Foo foo = (Foo) Proxy.newProxyInstance(AugmenterTest.class.getClassLoader(), new Class[] {Foo.class}, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { return method.getName(); } }); Boo b = Augmenter.augment(Boo.class, foo); Assert.assertEquals("HandledBibi", b.getBibi()); Assert.assertEquals("getName", b.getName()); Assert.assertEquals("toString", b.toString()); }
@Test public void factory() throws Exception { SubFoo subFoo = (SubFoo) Proxy.newProxyInstance(AugmenterTest.class.getClassLoader(), new Class[] {SubFoo.class}, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { return method.getName(); } }); AugmentedNode b = Augmenter.augment(AugmentedNode.class, subFoo); Assert.assertEquals("toString", b.toString()); } |
### Question:
ResponseBuilder extends KeyValueNodeBuilder<ResponseBuilder> implements NodeBuilder, AnnotableBuilder<ResponseBuilder> { static public ResponseBuilder response(int code) { return new ResponseBuilder(code); } private ResponseBuilder(int code); static ResponseBuilder response(int code); ResponseBuilder withBodies(BodyBuilder... builder); @Override ResponseBuilder withAnnotations(AnnotationBuilder... builders); @Override KeyValueNode buildNode(); ResponseBuilder description(String description); }### Answer:
@Test public void response() { Api api = document() .baseUri("http: .title("doc") .version("one") .mediaType("foo/fun") .withResources( resource("/foo") .withMethods(MethodBuilder.method("get") .withResponses(ResponseBuilder.response(200) .withBodies(BodyBuilder.body("application/json").ofType(TypeBuilder.type("integer"))) ) ) ) .buildModel(); assertEquals("application/json", api.resources().get(0).methods().get(0).responses().get(0).body().get(0).name()); assertEquals("integer", api.resources().get(0).methods().get(0).responses().get(0).body().get(0).type()); } |
### Question:
ResourceBuilder extends KeyValueNodeBuilder<ResourceBuilder> implements NodeBuilder { private ResourceBuilder(String name) { super(name); } private ResourceBuilder(String name); static ResourceBuilder resource(String name); @Override KeyValueNode buildNode(); ResourceBuilder displayName(String displayName); ResourceBuilder description(String comment); ResourceBuilder relativeUri(String relativeUri); ResourceBuilder withResources(ResourceBuilder... resourceBuilders); ResourceBuilder withMethods(MethodBuilder... methodBuilders); }### Answer:
@Test public void resourceBuilder() { Api api = document() .baseUri("http: .title("doc") .version("one") .mediaType("foo/fun") .withResources( resource("/foo") .description("happy") ) .buildModel(); assertEquals("/foo", api.resources().get(0).displayName().value()); assertEquals("/foo", api.resources().get(0).resourcePath()); assertEquals("/foo", api.resources().get(0).relativeUri().value()); assertEquals("happy", api.resources().get(0).description().value()); } |
### Question:
TypeBuilder extends ObjectNodeBuilder<TypeBuilder> implements NodeBuilder, AnnotableBuilder<TypeBuilder> { static public TypeBuilder type(String type) { return new TypeBuilder(type); } private TypeBuilder(String type); TypeBuilder(String[] types); TypeBuilder(TypeBuilder builder); String id(); static TypeBuilder type(String type); static TypeBuilder arrayOf(TypeBuilder builder); static TypeBuilder type(); static TypeBuilder type(String... types); @Override TypeBuilder withAnnotations(AnnotationBuilder... builders); TypeBuilder withProperty(TypePropertyBuilder... properties); TypeBuilder withExamples(ExamplesBuilder... properties); TypeBuilder withExample(ExamplesBuilder example); TypeBuilder withFacets(FacetBuilder... facetBuilders); TypeBuilder description(String description); TypeBuilder enumValues(String... enumValues); TypeBuilder enumValues(long... enumValues); TypeBuilder enumValues(boolean... enumValues); @Override ObjectNode buildNode(); public String[] types; }### Answer:
@Test public void simpleType() { Api api = document() .baseUri("http: .title("doc") .version("one") .mediaType("foo/fun") .withTypes( TypeDeclarationBuilder.typeDeclaration("Mom") .ofType(TypeBuilder.type("boolean"))) .buildModel(); assertEquals("Mom", api.types().get(0).name()); assertEquals("boolean", api.types().get(0).type()); }
@Test public void unionType() { Api api = document() .baseUri("http: .title("doc") .version("one") .mediaType("foo/fun") .withTypes( TypeDeclarationBuilder.typeDeclaration("Mom") .ofType(TypeBuilder.type("string | integer") ) ) .buildModel(); assertEquals("Mom", api.types().get(0).name()); assertEquals("string | integer", api.types().get(0).type()); assertEquals("string | integer", ((UnionTypeDeclaration)api.types().get(0)).of().get(0).name()); assertEquals("string | integer", ((UnionTypeDeclaration)api.types().get(0)).of().get(1).name()); } |
### Question:
Emitter { public void emit(Api api) throws IOException { emit(api, new OutputStreamWriter(System.out)); } Emitter(HandlerList list); Emitter(); void emit(Api api); void emit(Api api, Writer w); }### Answer:
@Test public void emit() throws Exception { when(api.getNode()).thenReturn(node); when(node.getChildren()).thenReturn(Arrays.asList(child1, child2)); Emitter emitter = new Emitter(list) { @Override protected YamlEmitter createEmitter(Writer w) { assertSame(w, writer); return yamlEmitter; } }; emitter.emit(api, writer); verify(list).handle(eq(child1), any(YamlEmitter.class) ); verify(list).handle(eq(child2), any(YamlEmitter.class) ); } |
### Question:
HandlerList extends NodeHandler<Node> { @Override public boolean handles(final Node node) { return FluentIterable.from(handlerList).anyMatch(new Predicate<NodeHandler<? extends Node>>() { @Override public boolean apply(@Nullable NodeHandler<? extends Node> nodeHandler) { return nodeHandler.handles(node); } }); } HandlerList(List<NodeHandler<? extends Node>> handlers); HandlerList(); @Override boolean handles(final Node node); @Override boolean handleSafely(final Node node, YamlEmitter emitter); }### Answer:
@Test public void handles() throws Exception { when(nodeHandler1.handles(node)).thenReturn(true); HandlerList list = new HandlerList(Arrays.<NodeHandler<? extends Node>>asList(nodeHandler1, nodeHandler2)); assertTrue(list.handles(node)); verify(nodeHandler2, never()).handles(any(Node.class)); }
@Test public void handlesNone() throws Exception { when(nodeHandler1.handles(node)).thenReturn(false); when(nodeHandler2.handles(node)).thenReturn(false); HandlerList list = new HandlerList(Arrays.<NodeHandler<? extends Node>>asList(nodeHandler1, nodeHandler2)); assertFalse(list.handles(node)); }
@Test public void actuallyHandleSafely() throws Exception { when(nodeHandler1.handles(node)).thenReturn(false); when(nodeHandler2.handles(node)).thenReturn(true); when(nodeHandler2.handle(node, emitter)).thenReturn(true); HandlerList list = new HandlerList(Arrays.<NodeHandler<? extends Node>>asList(nodeHandler1, nodeHandler2)); assertTrue(list.handle(node, emitter)); verify(nodeHandler1, never()).handle(any(Node.class), any(YamlEmitter.class)); verify(nodeHandler2).handle(node, emitter); } |
### Question:
ReferenceNodeHandler extends NodeHandler<ReferenceNode> { @Override public boolean handles(Node node) { return node instanceof ReferenceNode; } @Override boolean handles(Node node); @Override boolean handleSafely(ReferenceNode node, YamlEmitter emitter); }### Answer:
@Test public void handles() throws Exception { ReferenceNodeHandler handler = new ReferenceNodeHandler(); assertFalse(handler.handles(badNode)); assertTrue(handler.handles(goodNode)); } |
### Question:
ReferenceNodeHandler extends NodeHandler<ReferenceNode> { @Override public boolean handleSafely(ReferenceNode node, YamlEmitter emitter) throws IOException { emitter.writeObjectValue(node.getRefName()); return true; } @Override boolean handles(Node node); @Override boolean handleSafely(ReferenceNode node, YamlEmitter emitter); }### Answer:
@Test public void handleSafely() throws Exception { when(goodNode.getRefName()).thenReturn("ref.value"); ReferenceNodeHandler rnh = new ReferenceNodeHandler(); rnh.handleSafely(goodNode, emitter); verify(emitter).writeObjectValue("ref.value"); } |
### Question:
TypeDeclarationNodeHandler extends NodeHandler<TypeDeclarationNode> { @Override public boolean handles(Node node) { return node instanceof TypeDeclarationNode; } TypeDeclarationNodeHandler(HandlerList handlerList); @Override boolean handles(Node node); @Override boolean handleSafely(TypeDeclarationNode node, YamlEmitter emitter); }### Answer:
@Test public void handles() throws Exception { TypeDeclarationNodeHandler tdnh = new TypeDeclarationNodeHandler(list); assertFalse(tdnh.handles(badNode)); assertTrue(tdnh.handles(goodNode)); } |
### Question:
TypeDeclarationNodeHandler extends NodeHandler<TypeDeclarationNode> { @Override public boolean handleSafely(TypeDeclarationNode node, YamlEmitter emitter) throws IOException { for (Node child : node.getChildren()) { handlerList.handle(child, emitter); } return true; } TypeDeclarationNodeHandler(HandlerList handlerList); @Override boolean handles(Node node); @Override boolean handleSafely(TypeDeclarationNode node, YamlEmitter emitter); }### Answer:
@Test public void handleSafely() throws Exception { when(goodNode.getChildren()).thenReturn(Collections.<Node>singletonList(keyValueNode)); TypeDeclarationNodeHandler handler = new TypeDeclarationNodeHandler(list); handler.handleSafely(goodNode, emitter); verify(list).handle(keyValueNode, emitter); } |
### Question:
ArrayNodeHandler extends NodeHandler<ArrayNode> { @Override public boolean handles(Node node) { return node instanceof ArrayNode; } ArrayNodeHandler(HandlerList handlerList); @Override boolean handles(Node node); @Override boolean handleSafely(ArrayNode node, YamlEmitter emitter); }### Answer:
@Test public void handles() throws Exception { ArrayNodeHandler handler = new ArrayNodeHandler(list); assertFalse(handler.handles(badNode)); assertTrue(handler.handles(goodNode)); } |
### Question:
KeyValueNodeHandler extends NodeHandler<KeyValueNode> { @Override public boolean handles(Node node) { return node instanceof KeyValueNode; } KeyValueNodeHandler(HandlerList handlerList); @Override boolean handles(Node node); @Override boolean handleSafely(KeyValueNode node, YamlEmitter emitter); }### Answer:
@Test public void handles() throws Exception { KeyValueNodeHandler handler = new KeyValueNodeHandler(list); assertFalse(handler.handles(notKeyNode)); assertTrue(handler.handles(keyNode)); } |
### Question:
KeyValueNodeHandler extends NodeHandler<KeyValueNode> { @Override public boolean handleSafely(KeyValueNode node, YamlEmitter emitter) throws IOException { String scalar = isScalar(node.getValue()); if ( scalar != null ) { emitter.writeTag(node.getKey().toString()); handlerList.handle(node.getValue(), emitter); } else { emitter.writeTag(node.getKey().toString()); handlerList.handle(node.getValue(), emitter.indent()); } return true; } KeyValueNodeHandler(HandlerList handlerList); @Override boolean handles(Node node); @Override boolean handleSafely(KeyValueNode node, YamlEmitter emitter); }### Answer:
@Test public void handleSafelyScalar() throws Exception { when(keyNode.getValue()).thenReturn(simpleNode); when(keyNode.getKey()).thenReturn(new StringNodeImpl("hello")); KeyValueNodeHandler handler = new KeyValueNodeHandler(list); assertTrue(handler.handleSafely(keyNode, emitter)); verify(emitter).writeTag("hello"); verify(list).handle(simpleNode, emitter); }
@Test public void handleSafelyObject() throws Exception { when(keyNode.getValue()).thenReturn(objectNode); when(emitter.indent()).thenReturn(subEmitter); when(keyNode.getKey()).thenReturn(new StringNodeImpl("hello")); KeyValueNodeHandler handler = new KeyValueNodeHandler(list); assertTrue(handler.handleSafely(keyNode, emitter)); verify(emitter).writeTag("hello"); verify(list).handle(objectNode, subEmitter); } |
### Question:
SubclassedNodeHandler extends NodeHandler<T> { @Override public boolean handle(Node node, YamlEmitter emitter) { try { return subclassHandlerList.handle(node, emitter) || handleSafely((T) node, emitter); } catch (IOException e) { throw new RuntimeException(e); } } SubclassedNodeHandler(Class<?> superClass, HandlerList subclassHandlerList); @Override boolean handles(Node node); @Override boolean handle(Node node, YamlEmitter emitter); }### Answer:
@Test public void fallsThrough() throws Exception { when(subNodeHandler.handle(node, emitter)).thenReturn(false); SubclassedNodeHandler<ObjectNode> on = new SubclassedNodeHandler<ObjectNode>(ObjectNode.class, subNodeHandler) { @Override public boolean handleSafely(ObjectNode node, YamlEmitter emitter) throws IOException { nodeVerifier.handleSafely(node, emitter); return true; } }; assertTrue(on.handle(node, emitter)); verify(subNodeHandler).handle(node, emitter); verify(nodeVerifier).handleSafely(node, emitter); }
@Test public void sublistHandles() throws Exception { when(subNodeHandler.handle(node, emitter)).thenReturn(true); SubclassedNodeHandler<ObjectNode> on = new SubclassedNodeHandler<ObjectNode>(ObjectNode.class, subNodeHandler) { @Override public boolean handleSafely(ObjectNode node, YamlEmitter emitter) throws IOException { nodeVerifier.handleSafely(node, emitter); return true; } }; assertTrue(on.handle(node, emitter)); verify(subNodeHandler).handle(node, emitter); verify(nodeVerifier, never()).handleSafely(node, emitter); } |
### Question:
TypeExpressionNodeHandler extends SubclassedNodeHandler<TypeExpressionNode> { @Override public boolean handles(Node node) { return node instanceof TypeExpressionNode; } TypeExpressionNodeHandler(HandlerList handlerList); @Override boolean handles(Node node); @Override boolean handleSafely(TypeExpressionNode node, YamlEmitter emitter); }### Answer:
@Test public void handles() throws Exception { TypeExpressionNodeHandler handler = new TypeExpressionNodeHandler(list); assertFalse(handler.handles(badNode)); assertTrue(handler.handles(goodNode)); } |
### Question:
TypeExpressionNodeHandler extends SubclassedNodeHandler<TypeExpressionNode> { @Override public boolean handleSafely(TypeExpressionNode node, YamlEmitter emitter) throws IOException { List<LibraryRefNode> descs = node.findDescendantsWith(LibraryRefNode.class); if ( descs.size() != 0 && descs.get(0) != null ) { emitter.writeObjectValue(descs.get(0).getRefName() + "." +node.getTypeExpressionText()); } else { emitter.writeObjectValue(node.getTypeExpressionText()); } return true; } TypeExpressionNodeHandler(HandlerList handlerList); @Override boolean handles(Node node); @Override boolean handleSafely(TypeExpressionNode node, YamlEmitter emitter); }### Answer:
@Test public void handleSafely() throws Exception { when(goodNode.getTypeExpressionText()).thenReturn("JustReference"); TypeExpressionNodeHandler handler = new TypeExpressionNodeHandler(list); handler.handle(goodNode, emitter); verify(emitter).writeObjectValue("JustReference"); } |
### Question:
ObjectNodeHandler extends SubclassedNodeHandler<ObjectNode> { @Override public boolean handleSafely(ObjectNode node, YamlEmitter emitter) throws IOException { for (Node child : node.getChildren()) { String scalar = isScalar(node.getChildren().get(0)); if ( scalar != null ) { emitter.writeObjectValue(scalar); } else { handlerList.handle(child, emitter); } } return true; } ObjectNodeHandler(HandlerList handlerList); @Override boolean handleSafely(ObjectNode node, YamlEmitter emitter); }### Answer:
@Test public void handleSafely() throws Exception { when(objectNode.getChildren()).thenReturn(Collections.<Node>singletonList(child)); ObjectNodeHandler on = new ObjectNodeHandler(list); on.handleSafely(objectNode, emitter); verify(list).handle(child, emitter); }
@Test public void handleSafelyScalar() throws Exception { when(objectNode.getChildren()).thenReturn(Collections.<Node>singletonList(scalarNode)); ObjectNodeHandler on = new ObjectNodeHandler(list); on.handleSafely(objectNode, emitter); verify(emitter).writeObjectValue("foo"); } |
### Question:
NullNodeHandler extends NodeHandler<NullNode> { @Override public boolean handles(Node node) { return node instanceof NullNode; } NullNodeHandler(); @Override boolean handles(Node node); @Override boolean handleSafely(NullNode node, YamlEmitter emitter); }### Answer:
@Test public void handles() throws Exception { NullNodeHandler handler = new NullNodeHandler(); assertFalse(handler.handles(notNullNode)); assertTrue(handler.handles(nullNode)); } |
### Question:
NullNodeHandler extends NodeHandler<NullNode> { @Override public boolean handleSafely(NullNode node, YamlEmitter emitter) throws IOException { return true; } NullNodeHandler(); @Override boolean handles(Node node); @Override boolean handleSafely(NullNode node, YamlEmitter emitter); }### Answer:
@Test public void handleSafely() throws Exception { NullNodeHandler nul = new NullNodeHandler(); nul.handleSafely(nullNode, emitter); verifyNoMoreInteractions(emitter); } |
### Question:
SimpleTypeNodeHandler extends NodeHandler<SimpleTypeNode<?>> { @Override public boolean handles(Node node) { return node instanceof SimpleTypeNode; } SimpleTypeNodeHandler(); @Override boolean handles(Node node); @Override boolean handleSafely(SimpleTypeNode<?> node, YamlEmitter emitter); }### Answer:
@Test public void handles() throws Exception { SimpleTypeNodeHandler handler = new SimpleTypeNodeHandler(); assertFalse(handler.handles(badNode)); assertTrue(handler.handles(goodNode)); } |
### Question:
ArabicUtilities { public static String handleTatweela(@NonNull String s) { Matcher matcher4 = TATWEELA_PATTERN.matcher(s); StringBuffer sb2 = new StringBuffer(); while (matcher4.find()) { matcher4.appendReplacement(sb2, "$1$3"); } matcher4.appendTail(sb2); return sb2.toString(); } static String cleanTashkeel(@NonNull String s); static String cleanTextForSearchingIndexing(String s); @NonNull static String cleanTextForSearchingQuery(@NonNull String s); static String handleTatweela(@NonNull String s); @NonNull static String cleanTextForSearchingWthStingBuilder(String s); static String prepareForPrefixingLam(@NonNull String string); static boolean startsWithDefiniteArticle(@NonNull String string); @NonNull static String cleanHtml(String htmlText); static final char ALEF; static final char ALEF_MADDA; static final char ALEF_HAMZA_ABOVE; static final char ALEF_HAMZA_BELOW; static final char YEH; static final char DOTLESS_YEH; static final char TEH_MARBUTA; static final char HEH; static final char TATWEEL; static final char FATHATAN; static final char DAMMATAN; static final char KASRATAN; static final char FATHA; static final char DAMMA; static final char KASRA; static final char SHADDA; static final char SUKUN; static final char HAMZAH; }### Answer:
@Test public void handleTatweela() throws Exception { assertEquals(ArabicUtilities.handleTatweela("ุจูููููููููููููููููููุณู
"), "ุจุณู
"); assertEquals(ArabicUtilities.handleTatweela("ูู"), "ูู"); } |
### Question:
ArabicUtilities { public static boolean startsWithDefiniteArticle(@NonNull String string) { return string.startsWith("ุงู"); } static String cleanTashkeel(@NonNull String s); static String cleanTextForSearchingIndexing(String s); @NonNull static String cleanTextForSearchingQuery(@NonNull String s); static String handleTatweela(@NonNull String s); @NonNull static String cleanTextForSearchingWthStingBuilder(String s); static String prepareForPrefixingLam(@NonNull String string); static boolean startsWithDefiniteArticle(@NonNull String string); @NonNull static String cleanHtml(String htmlText); static final char ALEF; static final char ALEF_MADDA; static final char ALEF_HAMZA_ABOVE; static final char ALEF_HAMZA_BELOW; static final char YEH; static final char DOTLESS_YEH; static final char TEH_MARBUTA; static final char HEH; static final char TATWEEL; static final char FATHATAN; static final char DAMMATAN; static final char KASRATAN; static final char FATHA; static final char DAMMA; static final char KASRA; static final char SHADDA; static final char SUKUN; static final char HAMZAH; }### Answer:
@Test public void startsWithDefiniteArticle() throws Exception { assertEquals(ArabicUtilities.startsWithDefiniteArticle("ุงูุจุฎุงุฑู"), true); assertEquals(ArabicUtilities.startsWithDefiniteArticle("ุงููุจู"), true); assertEquals(ArabicUtilities.startsWithDefiniteArticle("ุงููุญู
"), true); } |
### Question:
ConfigHelper { public static ConfigHelper fromFile(String file) throws IOException { return new ConfigHelper(file); } ConfigHelper(); ConfigHelper(Properties properties); @Inject ConfigHelper(List<ConfigHelper> configuration); private ConfigHelper(String configFilename); private ConfigHelper(File configFile); private ConfigHelper(InputStream input, String resourceName); static ConfigHelper fromClasspathResource(String resourceName); static ConfigHelper fromSystemProperty(String property); static ConfigHelper fromFile(String file); static ConfigHelper fromFile(File file); static ConfigHelper fromStream(InputStream input); void add(String propertyName, MappedConfiguration<String, Object> configuration); void add(Class<?> propertyType, String propertyName, MappedConfiguration<String, Object> configuration); void addIfExists(String propertyName, MappedConfiguration<String, Object> configuration); void addIfExists(Class<?> propertyType, String propertyName, MappedConfiguration<String, Object> configuration); void override(String propertyName, MappedConfiguration<String, Object> configuration); void override(Class<?> propertyType, String propertyName, MappedConfiguration<String, Object> configuration); void overrideIfExists(String propertyName, MappedConfiguration<String, Object> configuration); void overrideIfExists(Class<?> propertyType, String propertyName, MappedConfiguration<String, Object> configuration); Set<String> getPropertyNames(); Set<String> getReferenced(); Class<?> getPropertyType(String propertyName); String getRaw(String propertyName); void copyFrom(ConfigHelper source); static final String EXTEND; static final String PREFIX; }### Answer:
@Test public void testFromFile() throws IOException { ConfigHelper helper = ConfigHelper.fromFile("src/test/resources/base-config.properties"); Assert.assertEquals("Base Property 1", helper.getRaw("prop1")); Assert.assertEquals("Base Property 2", helper.getRaw("prop2")); } |
### Question:
JpaMetamodelRedGProvider implements NameProvider, DataTypeProvider { @Override public String getClassNameForTable(Table table) { ManagedType managedType = managedTypesByTableName.get(table.getName().toUpperCase()); return managedType != null ? managedType.getJavaType().getSimpleName() : fallbackNameProvider.getClassNameForTable(table); } JpaMetamodelRedGProvider(Metamodel metaModel); static JpaMetamodelRedGProvider fromPersistenceUnit(String perstistenceUnitName, String hibernateDialect); static JpaMetamodelRedGProvider fromPersistenceUnit(String perstistenceUnitName); @Override String getClassNameForTable(Table table); @Override String getMethodNameForColumn(schemacrawler.schema.Column column); @Override String getMethodNameForForeignKeyColumn(ForeignKey foreignKey, schemacrawler.schema.Column primaryKeyColumn, schemacrawler.schema.Column foreignKeyColumn); @Override String getMethodNameForReference(ForeignKey foreignKey); @Override String getMethodNameForIncomingForeignKey(ForeignKey foreignKey); @Override String getCanonicalDataTypeName(schemacrawler.schema.Column column); void setFallbackNameProvider(NameProvider fallbackNameProvider); void setFallbackDataTypeProvider(DataTypeProvider fallbackDataTypeProvider); }### Answer:
@Test public void testGetClassNameForTable() throws Exception { Assert.assertEquals("ManagedSuperClassJoined", provider.getClassNameForTable(getTable("MANAGEDSUPERCLASSJOINED"))); Assert.assertEquals("SubEntityJoined1", provider.getClassNameForTable(getTable("SUB_ENTITY_JOINED_1"))); Assert.assertEquals("SubEntityJoined2", provider.getClassNameForTable(getTable("SUBENTITY_JOINED_2"))); Assert.assertEquals("ManagedSuperClassSingleTable", provider.getClassNameForTable(getTable("MANAGED_SUPERCLASS_SINGLE_TABLE"))); Assert.assertEquals("SubEntityTablePerClass1", provider.getClassNameForTable(getTable("SUBENTITYTABLEPERCLASS1"))); Assert.assertEquals("SubEntityTablePerClass2", provider.getClassNameForTable(getTable("SUBENTITY_TABLE_PER_CLASS_2"))); } |
### Question:
RedGBuilder { public T build() { final T inst = instance; instance = null; return inst; } @SuppressWarnings("unchecked") RedGBuilder(); RedGBuilder(final Class<T> clazz); RedGBuilder<T> withDefaultValueStrategy(final DefaultValueStrategy strategy); RedGBuilder<T> withPreparedStatementParameterSetter(final PreparedStatementParameterSetter setter); RedGBuilder<T> withSqlValuesFormatter(final SQLValuesFormatter formatter); RedGBuilder<T> withDummyFactory(final DummyFactory dummyFactory); T build(); }### Answer:
@Test public void testBuilder_ClassPrivate() { expectedException.expect(RuntimeException.class); expectedException.expectMessage("Could not instantiate RedG instance"); AbstractRedG redG = new RedGBuilder<>(PrivateRedG.class).build(); }
@Test public void testBuilder_DefaultConstructor() throws Exception { try { AbstractRedG redG = new RedGBuilder<>().build(); } catch (RuntimeException e) { assertEquals("Could not load default RedG class", e.getMessage()); } final ClassLoader classLoader = this.getClass().getClassLoader(); final Method defineClassMethod = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class); defineClassMethod.setAccessible(true); byte[] classDef = java.util.Base64.getDecoder().decode(this.redGClassData); defineClassMethod.invoke(classLoader, "com.btc.redg.generated.RedG", classDef, 0, classDef.length); try { AbstractRedG redG = new RedGBuilder<>().build(); } catch (RuntimeException e) { assertEquals("Could not instantiate RedG instance", e.getMessage()); } }
@Test public void testBuilder_AllDefault() { MyRedG redG = new RedGBuilder<>(MyRedG.class) .build(); assertTrue(redG.getDefaultValueStrategy() instanceof DefaultDefaultValueStrategy); assertTrue(redG.getDummyFactory() instanceof DefaultDummyFactory); assertTrue(redG.getSqlValuesFormatter() instanceof DefaultSQLValuesFormatter); assertTrue(redG.getPreparedStatementParameterSetter() instanceof DefaultPreparedStatementParameterSetter); } |
### Question:
XmlFileDataTypeProvider implements DataTypeProvider { String getDataTypeByName(String tableName, String columnName) { if (typeMappings.getTableTypeMappings() == null) { return null; } return typeMappings.getTableTypeMappings().stream() .filter(tableTypeMapping -> tableName.matches(tableTypeMapping.getTableName())) .flatMap(tableTypeMapping -> tableTypeMapping.getColumnTypeMappings().stream()) .filter(columnTypeMapping -> columnName.matches(columnTypeMapping.getColumnName())) .findFirst() .map(ColumnTypeMapping::getJavaType) .orElse(null); } XmlFileDataTypeProvider(Reader xmlReader, DataTypeProvider fallbackDataTypeProvider); XmlFileDataTypeProvider(TypeMappings typeMappings, DataTypeProvider fallbackDataTypeProvider); @Override String getCanonicalDataTypeName(final Column column); }### Answer:
@Test public void testGetDataTypeByName() throws Exception { TypeMappings typeMappings = new TypeMappings(); typeMappings.setTableTypeMappings(Arrays.asList( new TableTypeMapping(".+", Collections.singletonList(new ColumnTypeMapping("ACTIVE", "java.lang.Boolean"))), new TableTypeMapping("JOIN_TABLE", Collections.singletonList(new ColumnTypeMapping(".*_ID", "java.math.BigDecimal"))) )); XmlFileDataTypeProvider dataTypeProvider = new XmlFileDataTypeProvider(typeMappings, new DefaultDataTypeProvider()); Assert.assertEquals(dataTypeProvider.getDataTypeByName("FOO", "ACTIVE"), "java.lang.Boolean"); Assert.assertEquals(dataTypeProvider.getDataTypeByName("BAR", "ACTIVE"), "java.lang.Boolean"); Assert.assertEquals(dataTypeProvider.getDataTypeByName("BAR", "INACTIVE"), null); Assert.assertEquals(dataTypeProvider.getDataTypeByName("JOIN_TABLE", "FOO_ID"), "java.math.BigDecimal"); Assert.assertEquals(dataTypeProvider.getDataTypeByName("JOIN_TABLE", "BAR"), null); } |
### Question:
TableModelExtractor { public static List<TableModel> extractTableModelsFromSourceCode(final Path srcDir, final String packageName, final String classPrefix) throws IOException, ClassNotFoundException { LOG.debug("Starting table model extraction from source code..."); final List<TableModel> results = new ArrayList<>(); final String packageNameAsFolders = packageName.replace(".", "/"); final Path codeFilePath = srcDir.resolve(packageNameAsFolders); LOG.debug("Folder with source files is {}", codeFilePath.toAbsolutePath().toString()); final List<Path> paths = Files.list(codeFilePath) .filter(path -> path.getFileName().toString().matches(classPrefix + ".+\\.java")) .collect(Collectors.toList()); LOG.debug("Found following java source files:\n{}", paths.stream().map(p -> p.toAbsolutePath().toString()).collect(Collectors.joining("\n"))); for (Path p : paths) { LOG.debug("Loading source file {}", p.toAbsolutePath().toString()); final String code = new String(Files.readAllBytes(p)); final Matcher m = tableModelPattern.matcher(code); if (m.find()) { LOG.debug("Found serialized table model inside of file. Extracting..."); final String encodedModel = m.group(1); final byte[] decodedModel = Base64.getDecoder().decode(encodedModel); final ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(decodedModel)); results.add((TableModel) ois.readObject()); LOG.debug("Table model successfully extracted and deserialized."); } } return results; } static List<TableModel> extractTableModelsFromSourceCode(final Path srcDir, final String packageName, final String classPrefix); static List<TableModel> extractTableModelFromClasses(final Path classDir, final String packageName, final String classPrefix); }### Answer:
@Test @Ignore public void extractTableModelsFromSourceCode() throws Exception { TableModelExtractor.extractTableModelsFromSourceCode(Paths.get("D:\\redg\\redg-playground\\target\\generated-test-sources\\redg"), "com.btc.redg.generated", "G"); } |
### Question:
TableModelExtractor { public static List<TableModel> extractTableModelFromClasses(final Path classDir, final String packageName, final String classPrefix) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException { LOG.debug("Starting table model extraction from compiled class files..."); final List<TableModel> results = new ArrayList<>(); final String packageNameAsFolders = packageName.replace(".", "/"); final Path codeFilePath = classDir.resolve(packageNameAsFolders); LOG.debug("Folder with class files is {}", codeFilePath.toAbsolutePath().toString()); final List<String> classNames = Files.list(codeFilePath) .filter(path -> path.getFileName().toString().matches(classPrefix + ".+\\.class")) .map(classDir::relativize) .map(Path::toString) .map(name -> name.replaceFirst("\\.class$", "")) .map(name -> name.replaceAll("(/|\\\\)", ".")) .collect(Collectors.toList()); LOG.debug("Found following class files:\n{}", classNames.stream().collect(Collectors.joining("\n"))); LOG.debug("Loading all found classes..."); final ClassLoader cl = new URLClassLoader(new URL[]{classDir.toUri().toURL()}); for (String className : classNames) { LOG.debug("Loading class {}.", className); final Class cls = cl.loadClass(className); final Method m = cls.getDeclaredMethod("getTableModel"); results.add((TableModel) m.invoke(null)); LOG.debug("Successfully extracted table model."); } return results; } static List<TableModel> extractTableModelsFromSourceCode(final Path srcDir, final String packageName, final String classPrefix); static List<TableModel> extractTableModelFromClasses(final Path classDir, final String packageName, final String classPrefix); }### Answer:
@Test @Ignore public void extractTableModelFromClasses() throws Exception { TableModelExtractor.extractTableModelFromClasses(Paths.get("D:\\redg\\redg-playground\\target\\test-classes"), "com.btc.redg.generated", "G"); } |
### Question:
XmlFileDataTypeProvider implements DataTypeProvider { @Override public String getCanonicalDataTypeName(final Column column) { String dataTypeByName = getDataTypeByName(column.getParent().getName(), column.getName()); String dataTypeByType = getDataTypeBySqlType(column); return dataTypeByName != null ? dataTypeByName : dataTypeByType != null ? dataTypeByType : fallbackDataTypeProvider.getCanonicalDataTypeName(column); } XmlFileDataTypeProvider(Reader xmlReader, DataTypeProvider fallbackDataTypeProvider); XmlFileDataTypeProvider(TypeMappings typeMappings, DataTypeProvider fallbackDataTypeProvider); @Override String getCanonicalDataTypeName(final Column column); }### Answer:
@Test public void testCanHandleMissingTableTypeMappings() throws Exception { TypeMappings typeMappings = new TypeMappings(); typeMappings.setDefaultTypeMappings(Collections.emptyList()); XmlFileDataTypeProvider dataTypeProvider = new XmlFileDataTypeProvider(typeMappings, new DefaultDataTypeProvider()); Assert.assertEquals("java.lang.Integer", dataTypeProvider.getCanonicalDataTypeName(createColumnMock())); }
@Test public void testCanHandleMissingDefaultTypeMappings() throws Exception { TypeMappings typeMappings = new TypeMappings(); typeMappings.setTableTypeMappings(Collections.emptyList()); XmlFileDataTypeProvider dataTypeProvider = new XmlFileDataTypeProvider(typeMappings, new DefaultDataTypeProvider()); Assert.assertEquals("java.lang.Integer", dataTypeProvider.getCanonicalDataTypeName(createColumnMock())); } |
### Question:
XmlFileConvenienceSetterProvider implements ConvenienceSetterProvider { @Override public List<ConvenienceSetterModel> getConvenienceSetters(Column column, String javaDataTypeName) { return this.convenienceSetterConfig.getConvenienceSetterConfigs().stream() .filter(dataTypeConvenienceSetterConfig -> dataTypeConvenienceSetterConfig.getJavaDataTypeName().equals(javaDataTypeName)) .flatMap(dataTypeConvenienceSetterConfig -> dataTypeConvenienceSetterConfig.getConvenienceSetters().stream()) .collect(Collectors.toList()); } XmlFileConvenienceSetterProvider(Reader xmlReader); XmlFileConvenienceSetterProvider(ConvenienceSetterConfig convenienceSetterConfig); @Override List<ConvenienceSetterModel> getConvenienceSetters(Column column, String javaDataTypeName); }### Answer:
@Test public void getConvenienceSetters() throws Exception { InputStream stream = this.getClass().getResourceAsStream("XmlFileConvencienceSetterProviderTest.xml"); InputStreamReader reader = new InputStreamReader(stream, "UTF-8"); XmlFileConvenienceSetterProvider provider = new XmlFileConvenienceSetterProvider(reader); Assert.assertEquals(1, provider.getConvenienceSetters(Mockito.mock(Column.class), "java.util.Date").size()); } |
### Question:
DatabaseManager { public static Connection connectToDatabase(final String jdbcDriver, final String connectionString, final String username, final String password) throws ClassNotFoundException, SQLException { try { LOG.debug("Trying to load jdbc driver " + jdbcDriver); Class.forName(jdbcDriver); LOG.info("Successfully loaded jdbc driver"); } catch (ClassNotFoundException e) { LOG.error("Could not load jdbc driver with name " + jdbcDriver); throw e; } try { LOG.debug("Connecting to extractor " + connectionString); final Connection conn = DriverManager.getConnection(connectionString, username, password); LOG.info("Successfully connected to extractor"); return conn; } catch (SQLException e) { LOG.error("Could not connect to extractor", e); throw e; } } static Connection connectToDatabase(final String jdbcDriver,
final String connectionString,
final String username,
final String password); static void executePreparationScripts(final Connection connection, final File[] sqlScripts); static Catalog crawlDatabase(final Connection connection, final InclusionRule schemaRule, final InclusionRule tableRule); }### Answer:
@Test public void testConnectToDatabase_H2Success() throws Exception { Connection connection = DatabaseManager.connectToDatabase("org.h2.Driver", "jdbc:h2:mem:redg", "", ""); assertNotNull(connection); assertTrue(connection.isValid(10)); }
@Test public void testConnectToDatabase_InvalidDriver() throws Exception { thrown.expect(ClassNotFoundException.class); DatabaseManager.connectToDatabase("does.not.exist.Driver", "jdbc:dne:mem:redg", "", ""); }
@Test public void testConnectToDatabase_FailedConnection() throws Exception { thrown.expect(SQLException.class); Connection connection = DatabaseManager.connectToDatabase("org.h2.Driver", "jdbc:h4:invalid:redg", "", ""); } |
### Question:
NameUtils { public static String firstCharacterToLowerCase(final String s) { if (s == null || s.length() < 1) { return s; } final char[] letters = s.toCharArray(); letters[0] = Character.toLowerCase(letters[0]); return new String(letters); } static String firstCharacterToLowerCase(final String s); static String firstCharacterToUpperCase(final String s); static String escapeQuotationMarks(final String s); }### Answer:
@Test public void testFirstCharacterToLowerCase() { assertEquals("hello", NameUtils.firstCharacterToLowerCase("hello")); assertEquals("hello", NameUtils.firstCharacterToLowerCase("Hello")); assertEquals("hELLO", NameUtils.firstCharacterToLowerCase("HELLO")); assertEquals("4heLLo", NameUtils.firstCharacterToLowerCase("4heLLo")); assertEquals("", NameUtils.firstCharacterToLowerCase("")); assertEquals(null, NameUtils.firstCharacterToLowerCase(null)); } |
### Question:
NameUtils { public static String firstCharacterToUpperCase(final String s) { if (s == null || s.length() < 1) { return s; } final char[] letters = s.toCharArray(); letters[0] = Character.toUpperCase(letters[0]); return new String(letters); } static String firstCharacterToLowerCase(final String s); static String firstCharacterToUpperCase(final String s); static String escapeQuotationMarks(final String s); }### Answer:
@Test public void testFirstCharacterToUpperCase() { assertEquals("Hello", NameUtils.firstCharacterToUpperCase("hello")); assertEquals("Hello", NameUtils.firstCharacterToUpperCase("Hello")); assertEquals("HELLO", NameUtils.firstCharacterToUpperCase("HELLO")); assertEquals("4heLLo", NameUtils.firstCharacterToUpperCase("4heLLo")); assertEquals("", NameUtils.firstCharacterToUpperCase("")); assertEquals(null, NameUtils.firstCharacterToUpperCase(null)); } |
### Question:
JavaSqlStringEscapeMap extends AbstractMap<String, Object> { @Override public Object get(Object key) { if (key instanceof String) { String str = (String) key; return this.escapeStringBefore + str.replace("\"", "") + this.escapeStringAfter; } return super.get(key); } JavaSqlStringEscapeMap(String escapeStringBefore, String escapeStringAfter); JavaSqlStringEscapeMap(String escapeString); JavaSqlStringEscapeMap(); @Override Object get(Object key); @Override boolean containsKey(Object key); @Override Set<Entry<String, Object>> entrySet(); }### Answer:
@Test public void get() { JavaSqlStringEscapeMap defaultMap = new JavaSqlStringEscapeMap(); assertThat(defaultMap.get("asdf")).isEqualTo("\\\"asdf\\\""); assertThat(defaultMap.get("ASDF")).isEqualTo("\\\"ASDF\\\""); assertThat(defaultMap.get("\"TABLE\"")).isEqualTo("\\\"TABLE\\\""); JavaSqlStringEscapeMap mySqlMap = new JavaSqlStringEscapeMap("`"); assertThat(mySqlMap.get("asdf")).isEqualTo("`asdf`"); assertThat(mySqlMap.get("ASDF")).isEqualTo("`ASDF`"); assertThat(mySqlMap.get("\"TABLE\"")).isEqualTo("`TABLE`"); JavaSqlStringEscapeMap msSqlMap = new JavaSqlStringEscapeMap("[", "]"); assertThat(msSqlMap.get("asdf")).isEqualTo("[asdf]"); assertThat(msSqlMap.get("ASDF")).isEqualTo("[ASDF]"); assertThat(msSqlMap.get("\"TABLE\"")).isEqualTo("[TABLE]"); } |
### Question:
JavaSqlStringEscapeMap extends AbstractMap<String, Object> { @Override public boolean containsKey(Object key) { return (key instanceof String); } JavaSqlStringEscapeMap(String escapeStringBefore, String escapeStringAfter); JavaSqlStringEscapeMap(String escapeString); JavaSqlStringEscapeMap(); @Override Object get(Object key); @Override boolean containsKey(Object key); @Override Set<Entry<String, Object>> entrySet(); }### Answer:
@Test public void containsKey() { JavaSqlStringEscapeMap map = new JavaSqlStringEscapeMap(); assertThat(map.containsKey("A")).isTrue(); assertThat(map.containsKey("Longer String")).isTrue(); assertThat(map.containsKey(10)).isFalse(); assertThat(map.containsKey(new BigDecimal(1))).isFalse(); assertThat(map.containsKey(new Date())).isFalse(); } |
### Question:
ClassAvailabilityChecker { public boolean isAvailable() { return available; } ClassAvailabilityChecker(String fqcn); boolean isAvailable(); }### Answer:
@Test public void testHappyPaths() throws Exception { Assert.assertTrue(new ClassAvailabilityChecker("java.util.HashMap").isAvailable()); Assert.assertFalse(new ClassAvailabilityChecker("no.java.util.HashMap").isAvailable()); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.